├── .github └── workflows │ └── release-github.yml ├── .gitignore ├── .vscode └── tasks.json ├── LICENSE ├── README.md ├── __init__.py ├── build.py ├── debug └── __init__.py ├── install.py ├── release └── .gitignore └── source ├── __init__.py ├── keymap_ui.py ├── keymaps.py ├── nodelists ├── 3.4 │ ├── CompositorNodeTree.json │ ├── GeometryNodeTree.json │ ├── ShaderNodeTree.json │ └── TextureNodeTree.json ├── 3.5 │ ├── CompositorNodeTree.json │ ├── GeometryNodeTree.json │ ├── ShaderNodeTree.json │ └── TextureNodeTree.json ├── 3.6 │ ├── CompositorNodeTree.json │ ├── GeometryNodeTree.json │ ├── ShaderNodeTree.json │ └── TextureNodeTree.json ├── 4.0 │ ├── CompositorNodeTree.json │ ├── GeometryNodeTree.json │ ├── ShaderNodeTree.json │ └── TextureNodeTree.json ├── 4.1 │ ├── CompositorNodeTree.json │ ├── GeometryNodeTree.json │ ├── ShaderNodeTree.json │ └── TextureNodeTree.json ├── 4.2 │ ├── CompositorNodeTree.json │ ├── GeometryNodeTree.json │ ├── ShaderNodeTree.json │ └── TextureNodeTree.json ├── 4.3 │ ├── CompositorNodeTree.json │ ├── GeometryNodeTree.json │ ├── ShaderNodeTree.json │ └── TextureNodeTree.json ├── 4.4 │ ├── CompositorNodeTree.json │ ├── GeometryNodeTree.json │ ├── ShaderNodeTree.json │ └── TextureNodeTree.json ├── 4.5 │ ├── CompositorNodeTree.json │ ├── GeometryNodeTree.json │ ├── ShaderNodeTree.json │ └── TextureNodeTree.json ├── __init__.py └── __poll_functions__.py ├── operators.py ├── prefs.py └── utils.py /.github/workflows/release-github.yml: -------------------------------------------------------------------------------- 1 | name: Build and Create Draft Release 2 | 3 | on: 4 | workflow_dispatch: 5 | push: 6 | tags: 7 | - '[0-9]+.[0-9]+.[0-9]+' 8 | 9 | jobs: 10 | build-and-draft-release: 11 | runs-on: ubuntu-latest 12 | permissions: 13 | contents: write 14 | discussions: write 15 | 16 | steps: 17 | - uses: actions/checkout@v4 18 | - uses: BradyAJohnston/setup-blender@v3 19 | with: 20 | version: 4.5 21 | - name: Build Extension 22 | run: | 23 | blender -b -P build.py 24 | - name: List build output 25 | run: ls -R 26 | - name: Create Draft Release 27 | run: | 28 | gh release create ${{ github.ref_name }} --draft --generate-notes release/*.zip 29 | env: 30 | GITHUB_TOKEN: ${{ github.token }} 31 | -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | .DS_Store 2 | /scripts 3 | **/__pycache__/ 4 | **.prof 5 | /source/**/*.json 6 | !/source/nodelists/**/*.json -------------------------------------------------------------------------------- /.vscode/tasks.json: -------------------------------------------------------------------------------- 1 | { 2 | // See https://go.microsoft.com/fwlink/?LinkId=733558 3 | // for the documentation about the tasks.json format 4 | "version": "2.0.0", 5 | "tasks": [ 6 | { 7 | "label": "Build Release ZIPs", 8 | "type": "shell", 9 | "command": "python", 10 | "args": ["./build.py"], 11 | "group": "build" 12 | }, 13 | { 14 | "label": "Install Versions", 15 | "type": "shell", 16 | "command": "python \"install.py\" SINGLE_VERSION", 17 | "group": "build", 18 | }, 19 | { 20 | "label": "Install Versions (Multi-version)", 21 | "type": "shell", 22 | "command": "python \"install.py\" MULTI_VERSION", 23 | "group": "build", 24 | }, 25 | { 26 | "label": "Install Versions (Symlink)", 27 | "type": "shell", 28 | "command": "python \"install.py\" SYMLINK", 29 | "group": "build", 30 | } 31 | ] 32 | } -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # node_tabber 2 | 3 | Node Tabber is a Houdini/Nuke style node adding tool for Blender's Node tree graphs; namely the Shader, Compositing, Texture and Geometry. 4 | 5 | Instead of having to press SHIFT+A and then scrolling the sub menus to find the correct node, or even clicking on the search menu and maybe getting the correct node; you can just press the TAB button which will bring up an intelligent search list which even supports node acronyms. For example, typing SX would bring up the Seperate XYZ node. 6 | This saves a lot of time when working with large node trees. 7 | 8 | ## Installation (Blender 3.4+) 9 | 10 | Download the latest version from the [Releases Page](https://github.com/williamchange/node_tabber/releases), pick the version that best suits the Blender version you are using, and install from Blender's preferences, just like any other add-on (no need to unzip) 11 | 12 | > **NOTE**: If you are a regular user, DO NOT go to `'<> Code' > 'Download as ZIP'` to download a copy of the addon. This gives you a development version of the addon which is larger in size and offers no advantage over the release versions outside of development. 13 | 14 | ## Older versions (Blender 3.1-3.3) 15 | 16 | Release versions for these versions are planned, but not implemented yet. 17 | 18 | For now the legacy branches where you can download these versions as ZIPs (i.e. [3.3](https://github.com/williamchange/node_tabber/tree/33), [3.2](https://github.com/williamchange/node_tabber/tree/32) and [3.1](https://github.com/williamchange/node_tabber/tree/31)), will be kept up for the time being. These legacy branches may not have the same functionality as the versions with up-to-date releases. 19 | 20 | --- 21 | 22 | 23 | # Fork 24 | 25 | This is a fork which includes: 26 | 27 | - Additional sub node entries for new vector math operations 28 | - Geometry Nodes sub-nodes 29 | - Fix for appending custom nodegroups (see https://github.com/jiggymoon69/node_tabber/pull/10) 30 | - Workaround for [this commit(Blender 3.4+)](https://github.com/blender/blender/commit/837144b4577f161baf1625f8a5478c83a088ea0f) which breaks the add-on with geonodes. See [D15973](https://developer.blender.org/D15973). 31 | -------------------------------------------------------------------------------- /__init__.py: -------------------------------------------------------------------------------- 1 | # ##### BEGIN GPL LICENSE BLOCK ##### 2 | # 3 | # This program is free software; you can redistribute it and/or 4 | # modify it under the terms of the GNU General Public License 5 | # as published by the Free Software Foundation; either version 2 6 | # of the License, or (at your option) any later version. 7 | # 8 | # This program is distributed in the hope that it will be useful, 9 | # but WITHOUT ANY WARRANTY; without even the implied warranty of 10 | # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 11 | # GNU General Public License for more details. 12 | # 13 | # You should have received a copy of the GNU General Public License 14 | # along with this program; if not, write to the Free Software Foundation, 15 | # Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. 16 | # 17 | # ##### END GPL LICENSE BLOCK ##### 18 | 19 | 20 | bl_info = { 21 | "name": "Node Tabber (Development)", 22 | "author": "Richard Lyons, williamchange, Quackers", 23 | "blender": (3, 4, 0), 24 | "version": (0, 3, 6), 25 | "description": "Allows quick smart searching of node types.", 26 | "category": "Node", 27 | } 28 | 29 | from .source import register, unregister 30 | 31 | if __name__ == "__main__": 32 | register() -------------------------------------------------------------------------------- /build.py: -------------------------------------------------------------------------------- 1 | import ast 2 | import shutil 3 | from pathlib import Path 4 | from tempfile import TemporaryDirectory 5 | 6 | versions = [p.name for p in Path("source", "nodelists").glob("[0-9].[0-9]")] 7 | root = Path(__file__).parent 8 | 9 | RELEASE_FOLDER = Path("release") 10 | SOURCE_FOLDER = Path("source") 11 | 12 | 13 | def get_bl_info(init_path): 14 | with open(init_path, 'r') as f: 15 | node = ast.parse(f.read()) 16 | 17 | n: ast.Module 18 | for n in ast.walk(node): 19 | for b in n.body: 20 | if isinstance(b, ast.Assign) and isinstance(b.value, ast.Dict) and ( 21 | any(t.id == 'bl_info' for t in b.targets)): 22 | bl_info_dict = ast.literal_eval(b.value) 23 | return bl_info_dict 24 | 25 | raise ValueError('Cannot find bl_info') 26 | 27 | 28 | BL_INFO_BASE = get_bl_info(Path("__init__.py")) 29 | BL_INFO_PATTERN = "### INSERT BL_INFO BLOCK HERE ###" 30 | 31 | 32 | def make_empty(path): 33 | if path.exists(): 34 | shutil.rmtree(path) 35 | path.mkdir() 36 | 37 | 38 | def initialize(path): 39 | if not path.exists(): 40 | path.mkdir() 41 | return 42 | 43 | for item in path.iterdir(): 44 | if item.is_dir(): 45 | shutil.rmtree(item) 46 | elif not str(item).endswith(".gitignore"): 47 | item.unlink() 48 | 49 | 50 | def generate_bl_info_text(bl_info): 51 | lines = ["bl_info = {"] 52 | 53 | for key, value in bl_info.items(): 54 | if isinstance(key, str): 55 | key = f'"{key}"' 56 | if isinstance(value, str): 57 | value = f'"{value}"' 58 | 59 | lines.append(f" {key} : {value},") 60 | 61 | lines.append("}") 62 | return "\n".join(lines) 63 | 64 | 65 | def replace_text(path, pattern, replacement): 66 | with open(path, "r") as f: 67 | text = f.read() 68 | 69 | text = text.replace(pattern, replacement) 70 | 71 | with open(path, "w") as f: 72 | f.write(text) 73 | 74 | 75 | def write_bl_info(init_path, version): 76 | bl_info = BL_INFO_BASE.copy() 77 | bl_info["name"] = bl_info["name"].removesuffix(" (Development)") 78 | 79 | if version is not None: 80 | bl_info["name"] = bl_info["name"] + f" (v{version})" 81 | bl_info["blender"] = tuple(map(int, version.split(".") + ["0"])) 82 | 83 | replace_text(init_path, BL_INFO_PATTERN, generate_bl_info_text(bl_info)) 84 | 85 | 86 | def build_package(archive_name, version=None): 87 | with TemporaryDirectory(dir=RELEASE_FOLDER) as temp_dir: 88 | dest_folder = Path(temp_dir, "Node Tabber") 89 | shutil.copytree(SOURCE_FOLDER, dest_folder, ignore=shutil.ignore_patterns("__pycache__", "*.pyc", "*.pyo")) 90 | make_empty(dest_folder / "tally_cache") 91 | 92 | if version is not None: 93 | versions_to_delete = (v for v in versions if v != version) 94 | for v in versions_to_delete: 95 | shutil.rmtree(dest_folder / "nodelists" / v) 96 | 97 | init_path = dest_folder / "__init__.py" 98 | write_bl_info(init_path, version) 99 | 100 | for f in dest_folder.glob("*.py"): 101 | replace_text(f, pattern="from ..debug import profile_code\n", replacement="") 102 | 103 | replace_text( 104 | dest_folder / "prefs.py", pattern='bl_idname = "Node Tabber"', replacement="bl_idname = __package__" 105 | ) 106 | replace_text( 107 | dest_folder / "utils.py", 108 | pattern='prefs = context.preferences.addons["Node Tabber"].preferences', 109 | replacement="prefs = context.preferences.addons[__package__].preferences", 110 | ) 111 | 112 | shutil.make_archive(RELEASE_FOLDER / archive_name, "zip", temp_dir) 113 | print(f"Successfully created archive at '{archive_name}'") 114 | 115 | 116 | def run(): 117 | initialize(RELEASE_FOLDER) 118 | 119 | version = BL_INFO_BASE['version'] 120 | addon_version = f"{version[0]}.{version[1]}.{version[2]}" 121 | 122 | for version in versions: 123 | build_package(archive_name=f"Node-Tabber_v{addon_version}_(Blender-v{version})", version=version) 124 | 125 | build_package(archive_name=f"Node-Tabber_v{addon_version}_(multi-version)") 126 | return 127 | 128 | 129 | if __name__ == "__main__": 130 | run() 131 | -------------------------------------------------------------------------------- /debug/__init__.py: -------------------------------------------------------------------------------- 1 | import cProfile 2 | import shutil 3 | from pstats import Stats, SortKey 4 | from pathlib import Path 5 | 6 | DEBUG_FOLDER = Path(__file__).parent 7 | PROFILE_FOLDER = DEBUG_FOLDER / "profiles" 8 | 9 | 10 | if not PROFILE_FOLDER.exists(): 11 | PROFILE_FOLDER.mkdir() 12 | 13 | def dump_stats(name, profile): 14 | stats = Stats(profile) 15 | stats.sort_stats(SortKey.TIME) 16 | stats.dump_stats(PROFILE_FOLDER / f"{name}.prof") 17 | 18 | def delete_profiles(): 19 | if PROFILE_FOLDER.exists(): 20 | shutil.rmtree(PROFILE_FOLDER) 21 | 22 | PROFILE_FOLDER.mkdir() 23 | 24 | 25 | def profile_code(func_type='FUNCTION'): 26 | if func_type == 'EXECUTE': 27 | return profile_execute 28 | elif func_type == 'INVOKE': 29 | return profile_invoke 30 | else: 31 | return profile_function 32 | 33 | 34 | def profile_function(func): 35 | def wrapped_func(*args, **kwargs): 36 | with cProfile.Profile() as pr: 37 | output = func(*args, **kwargs) 38 | 39 | dump_stats(name=func.__name__, profile=pr) 40 | return output 41 | 42 | return wrapped_func 43 | 44 | 45 | def profile_execute(func): 46 | def wrapped_func(self, context): 47 | with cProfile.Profile() as pr: 48 | output = func(self, context) 49 | 50 | dump_stats(name=func.__name__, profile=pr) 51 | return output 52 | 53 | return wrapped_func 54 | 55 | 56 | def profile_invoke(func): 57 | def wrapped_func(self, context, event): 58 | with cProfile.Profile() as pr: 59 | output = func(self, context, event) 60 | 61 | dump_stats(name=func.__name__, profile=pr) 62 | return output 63 | 64 | return wrapped_func 65 | 66 | 67 | if __name__ == "__main__": 68 | delete_profiles() -------------------------------------------------------------------------------- /install.py: -------------------------------------------------------------------------------- 1 | import re 2 | import shutil 3 | import argparse 4 | import platform 5 | 6 | from pathlib import Path 7 | from dataclasses import dataclass 8 | 9 | 10 | build_folder = Path(Path.cwd(), "release") 11 | 12 | 13 | @dataclass 14 | class AddonBuild: 15 | version_string : tuple 16 | install_path : Path 17 | zip_path : Path 18 | 19 | 20 | def get_version_string(zip_path): 21 | return str(re.findall(r"\d\.\d", zip_path.stem)[-1]) 22 | 23 | 24 | def userdata_folder(): 25 | sys_platform = platform.system() 26 | 27 | if sys_platform in {"linux", "linux2"}: 28 | return "~/.config/blender/" 29 | elif sys_platform == "darwin": 30 | return "~/Library/Application Support/Blender/" 31 | elif sys_platform in {"win32", "Windows"}: 32 | return "~/AppData/Roaming/Blender Foundation/Blender/" 33 | 34 | 35 | def version_to_string(version, depth=None, separator="."): 36 | if depth is not None: 37 | version = version[:depth] 38 | 39 | return separator.join(map(str, version[:depth])) 40 | 41 | 42 | def get_addon_builds(user_folder, addon_name, use_multiversion=False): 43 | versions = (path for path in build_folder.glob("*.zip") if not path.stem.endswith("(multi-version)")) 44 | multiversion_zip = next(path for path in build_folder.glob("*.zip") if path.stem.endswith("(multi-version)")) 45 | for zip_path in versions: 46 | version_string = get_version_string(zip_path) 47 | addon_path = Path( 48 | Path(user_folder).expanduser(), 49 | version_string, 50 | f"scripts/addons/{addon_name}", 51 | ) 52 | 53 | if use_multiversion: 54 | yield AddonBuild(version_string, addon_path, multiversion_zip) 55 | else: 56 | yield AddonBuild(version_string, addon_path, zip_path) 57 | 58 | 59 | def is_symbolic_link(path): 60 | if hasattr(path, "is_junction"): 61 | return path.is_junction() or path.is_symlink() 62 | else: 63 | return path.is_symlink() or not path.is_dir() 64 | 65 | 66 | def remove_symlink(addon_path, version): 67 | addon_path.unlink() 68 | print(f"Blender {version}: Unlinked working directory from \"{addon_path}\"") 69 | 70 | 71 | def uninstall_addon_builds(builds): 72 | for build in builds: 73 | version_string = build.version_string 74 | addon_path = build.install_path 75 | 76 | if not addon_path.exists(): 77 | print(f"Blender {version_string}: No installation found in \"{addon_path}\"") 78 | continue 79 | 80 | if is_symbolic_link(addon_path): 81 | remove_symlink(addon_path, version=version_string) 82 | continue 83 | else: 84 | try: 85 | shutil.rmtree(addon_path) 86 | print(f"Blender {version_string}: Uninstalled addon in \"{addon_path}\"") 87 | continue 88 | except OSError: 89 | remove_symlink(addon_path, version=version_string) 90 | continue 91 | 92 | 93 | def install_addon_builds(builds): 94 | for build in builds: 95 | version_string = build.version_string 96 | install_path = build.install_path 97 | zip_path = build.zip_path 98 | 99 | shutil.unpack_archive(zip_path, install_path.parent) 100 | print(f"Blender {version_string}: Installed addon \"{zip_path.stem}\" in \"{install_path}\"") 101 | 102 | 103 | def symlink_current_directory(builds): 104 | for build in builds: 105 | version_string = build.version_string 106 | install_path = build.install_path 107 | 108 | install_path.symlink_to(target=Path.cwd()) 109 | print(f"Blender {version_string}: Linked working directory from \"{install_path}\"") 110 | 111 | 112 | def parse_arguments(): 113 | parser = argparse.ArgumentParser() 114 | parser.add_argument("mode", choices=["SYMLINK", "MULTI_VERSION", "SINGLE_VERSION"], help="Specifies whether to install addon through symlinks, multiversion zip, or individual version zips.") 115 | args = parser.parse_args() 116 | 117 | if args.mode == "SYMLINK": 118 | use_symlinks = True 119 | use_multiversion = False 120 | 121 | elif args.mode == "MULTI_VERSION": 122 | use_symlinks = False 123 | use_multiversion = True 124 | 125 | elif args.mode == "SINGLE_VERSION": 126 | use_symlinks = False 127 | use_multiversion = False 128 | 129 | return (use_symlinks, use_multiversion) 130 | 131 | 132 | def run(): 133 | use_symlinks, use_multiversion = parse_arguments() 134 | builds = tuple(get_addon_builds(userdata_folder(), addon_name="Node Tabber", use_multiversion=use_multiversion)) 135 | 136 | print("===== UNINSTALLING ADDON BUILDS =====") 137 | uninstall_addon_builds(builds) 138 | print() 139 | 140 | print("===== INSTALLING ADDON BUILDS =====") 141 | if use_symlinks: 142 | symlink_current_directory(builds) 143 | else: 144 | install_addon_builds(builds) 145 | print() 146 | 147 | 148 | if __name__ == "__main__": 149 | run() 150 | -------------------------------------------------------------------------------- /release/.gitignore: -------------------------------------------------------------------------------- 1 | ** 2 | !.gitignore -------------------------------------------------------------------------------- /source/__init__.py: -------------------------------------------------------------------------------- 1 | # ##### BEGIN GPL LICENSE BLOCK ##### 2 | # 3 | # This program is free software; you can redistribute it and/or 4 | # modify it under the terms of the GNU General Public License 5 | # as published by the Free Software Foundation; either version 2 6 | # of the License, or (at your option) any later version. 7 | # 8 | # This program is distributed in the hope that it will be useful, 9 | # but WITHOUT ANY WARRANTY; without even the implied warranty of 10 | # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 11 | # GNU General Public License for more details. 12 | # 13 | # You should have received a copy of the GNU General Public License 14 | # along with this program; if not, write to the Free Software Foundation, 15 | # Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. 16 | # 17 | # ##### END GPL LICENSE BLOCK ##### 18 | 19 | ### INSERT BL_INFO BLOCK HERE ### 20 | 21 | from . import operators, keymaps, prefs 22 | modules = (operators, keymaps, prefs) 23 | 24 | 25 | def register(): 26 | for module in modules: 27 | module.register() 28 | 29 | 30 | def unregister(): 31 | for module in modules: 32 | module.unregister() 33 | 34 | 35 | if __name__ == "__main__": 36 | register() 37 | -------------------------------------------------------------------------------- /source/keymaps.py: -------------------------------------------------------------------------------- 1 | from .keymap_ui import KeymapItemDef, KeymapStructure, KeymapLayout 2 | from .operators import NODE_OT_add_tabber_search 3 | 4 | 5 | keymap_info = { 6 | "keymap_name" : "Node Editor", 7 | "space_type" : "NODE_EDITOR", 8 | } 9 | 10 | 11 | keymap_structure = KeymapStructure([ 12 | KeymapItemDef(NODE_OT_add_tabber_search.bl_idname, **keymap_info, key_type='TAB'), 13 | KeymapItemDef("node.group_edit", **keymap_info, key_type='TAB', ctrl=True), 14 | ] 15 | ) 16 | 17 | 18 | keymap_layout = KeymapLayout(layout_structure=keymap_structure) 19 | 20 | 21 | def register(): 22 | keymap_structure.register() 23 | 24 | 25 | def unregister(): 26 | keymap_structure.unregister() 27 | -------------------------------------------------------------------------------- /source/nodelists/3.4/CompositorNodeTree.json: -------------------------------------------------------------------------------- 1 | { 2 | "items": { 3 | "entries": [ 4 | "CompositorNodeBokehImage", 5 | "CompositorNodeImage", 6 | "CompositorNodeMask", 7 | "CompositorNodeMovieClip", 8 | "CompositorNodeTexture", 9 | "CompositorNodeRGB", 10 | "CompositorNodeValue", 11 | "CompositorNodeRLayers", 12 | "CompositorNodeSceneTime", 13 | "CompositorNodeTime", 14 | "CompositorNodeComposite", 15 | "CompositorNodeViewer", 16 | "CompositorNodeOutputFile", 17 | "CompositorNodeValToRGB", 18 | "CompositorNodeConvertColorSpace", 19 | "CompositorNodeInvert", 20 | "CompositorNodeRGBToBW", 21 | "CompositorNodeBrightContrast", 22 | "CompositorNodeColorCorrection", 23 | "CompositorNodeExposure", 24 | "CompositorNodeGamma", 25 | "CompositorNodeHueCorrect", 26 | "CompositorNodeHueSat", 27 | "CompositorNodeCurveRGB", 28 | "CompositorNodeAlphaOver", 29 | "CompositorNodeZcombine", 30 | "CompositorNodeAntiAliasing", 31 | "CompositorNodeDespeckle", 32 | "CompositorNodeInpaint", 33 | "CompositorNodePixelate", 34 | "CompositorNodePosterize", 35 | "CompositorNodeSunBeams", 36 | "CompositorNodeBilateralblur", 37 | "CompositorNodeBokehBlur", 38 | "CompositorNodeDBlur", 39 | "CompositorNodeVecBlur", 40 | "CompositorNodeChannelMatte", 41 | "CompositorNodeChromaMatte", 42 | "CompositorNodeColorMatte", 43 | "CompositorNodeColorSpill", 44 | "CompositorNodeDiffMatte", 45 | "CompositorNodeKeying", 46 | "CompositorNodeKeyingScreen", 47 | "CompositorNodeLumaMatte", 48 | "CompositorNodeCryptomatte", 49 | "CompositorNodeBoxMask", 50 | "CompositorNodeEllipseMask", 51 | "CompositorNodeDoubleEdgeMask", 52 | "CompositorNodeIDMask", 53 | "CompositorNodePlaneTrackDeform", 54 | "CompositorNodeStabilize", 55 | "CompositorNodeTrackPos", 56 | "CompositorNodeCornerPin", 57 | "CompositorNodeCrop", 58 | "CompositorNodeDisplace", 59 | "CompositorNodeMapUV", 60 | "CompositorNodeLensdist", 61 | "CompositorNodeMapRange", 62 | "CompositorNodeMapValue", 63 | "CompositorNodeNormalize", 64 | "CompositorNodeSwitch", 65 | "CompositorNodeCombineXYZ", 66 | "CompositorNodeSeparateXYZ", 67 | "CompositorNodeNormal", 68 | "CompositorNodeCurveVec" 69 | ] 70 | }, 71 | "combine_and_separate_color": { 72 | "entries": [ 73 | ["CompositorNodeCombineColor", {"subtypes": ["mode"]}], 74 | ["CompositorNodeCombineColor", { 75 | "only_subtypes" : true, 76 | "subtypes": [ 77 | {"name": "mode", "only_include": ["YCbCr"]}, 78 | "ycc_mode" 79 | ] 80 | } 81 | ], 82 | ["CompositorNodeSeparateColor", {"subtypes": ["mode"]}], 83 | ["CompositorNodeSeparateColor", { 84 | "only_subtypes" : true, 85 | "subtypes": [ 86 | {"name": "mode", "only_include": ["YCbCr"]}, 87 | "ycc_mode" 88 | ] 89 | } 90 | ] 91 | ] 92 | }, 93 | "specific_types": { 94 | "entries": [ 95 | ["CompositorNodeSwitchView", {"label": "Switch Stereo View"}] 96 | ] 97 | }, 98 | "basic_subtypes": { 99 | "entries": [ 100 | ["CompositorNodePremulKey", {"subtypes": ["mapping"]}], 101 | ["CompositorNodeColorBalance", {"subtypes": ["correction_method"]}], 102 | ["CompositorNodeCryptomatteV2", {"subtypes": ["source"]}], 103 | ["CompositorNodeDistanceMatte", {"subtypes": ["channel"]}], 104 | ["CompositorNodeMovieDistortion", {"subtypes": ["distortion_type"]}], 105 | ["CompositorNodeSetAlpha", {"subtypes": ["mode"]}], 106 | ["CompositorNodeDefocus", {"subtypes": ["bokeh"]}], 107 | ["CompositorNodeDenoise", {"subtypes": ["prefilter"]}], 108 | ["CompositorNodeDilateErode", {"subtypes": ["mode"]}], 109 | ["CompositorNodeDilateErode", { 110 | "only_subtypes": true, 111 | "subtypes": [ 112 | {"name": "mode", "only_include": ["Feather"]}, 113 | "falloff" 114 | ] 115 | } 116 | ], 117 | ["CompositorNodeGlare", {"subtypes": ["glare_type"]}], 118 | ["CompositorNodeRotate", {"subtypes": ["filter_type"]}], 119 | ["CompositorNodeScale", {"subtypes": ["space"]}], 120 | ["CompositorNodeScale", { 121 | "only_subtypes": true, 122 | "subtypes": [ 123 | {"name": "space", "only_include": ["Render Size"]}, 124 | "frame_method" 125 | ] 126 | } 127 | ], 128 | ["CompositorNodeTransform", {"subtypes": ["filter_type"]}], 129 | ["CompositorNodeTranslate", {"subtypes": ["wrap_axis"]}], 130 | ["CompositorNodeFlip", {"subtypes": ["axis"]}], 131 | ["CompositorNodeBlur", {"subtypes": ["filter_type"]}], 132 | ["CompositorNodeLevels", {"subtypes": ["channel"]}], 133 | ["CompositorNodeMath", {"subtypes": ["operation"]}], 134 | ["CompositorNodeFilter", {"subtypes": ["filter_type"]}], 135 | ["CompositorNodeSplitViewer", {"subtypes": ["axis"]}], 136 | ["CompositorNodeTonemap", {"subtypes": ["tonemap_type"]}] 137 | ] 138 | }, 139 | "mix_color": { 140 | "poll": "check_mix_color_alias", 141 | "poll_args": {"valid_options": ["DEFAULT", "MIX_COLOR", "BOTH"]}, 142 | "entries": [ 143 | ["CompositorNodeMixRGB", {"label": "Mix Color", "subtypes": ["blend_type"]}] 144 | ] 145 | }, 146 | "mix_rgb": { 147 | "poll": "check_mix_color_alias", 148 | "poll_args": { "valid_options": ["MIX_RGB", "BOTH"]}, 149 | "entries": [ 150 | ["CompositorNodeMixRGB", {"label": "Mix RGB", "subtypes": ["blend_type"]}] 151 | ] 152 | }, 153 | "group_nodes": { 154 | "poll": "in_nodegroup", 155 | "entries": [ 156 | "NodeGroupInput", 157 | "NodeGroupOutput" 158 | ] 159 | }, 160 | "frame_and_reroute": { 161 | "entries": [ 162 | "NodeFrame", 163 | "NodeReroute" 164 | ] 165 | } 166 | } -------------------------------------------------------------------------------- /source/nodelists/3.4/ShaderNodeTree.json: -------------------------------------------------------------------------------- 1 | { 2 | "items": { 3 | "entries": [ 4 | "ShaderNodeAmbientOcclusion", 5 | "ShaderNodeAttribute", 6 | "ShaderNodeBevel", 7 | "ShaderNodeCameraData", 8 | "ShaderNodeVertexColor", 9 | "ShaderNodeHairInfo", 10 | "ShaderNodeFresnel", 11 | "ShaderNodeNewGeometry", 12 | "ShaderNodeLayerWeight", 13 | "ShaderNodeLightPath", 14 | "ShaderNodeObjectInfo", 15 | "ShaderNodeParticleInfo", 16 | "ShaderNodePointInfo", 17 | "ShaderNodeRGB", 18 | "ShaderNodeTangent", 19 | "ShaderNodeTexCoord", 20 | "ShaderNodeUVMap", 21 | "ShaderNodeValue", 22 | "ShaderNodeVolumeInfo", 23 | "ShaderNodeWireframe", 24 | "ShaderNodeOutputAOV", 25 | "ShaderNodeVolumePrincipled", 26 | "ShaderNodeBrightContrast", 27 | "ShaderNodeGamma", 28 | "ShaderNodeHueSaturation", 29 | "ShaderNodeInvert", 30 | "ShaderNodeLightFalloff", 31 | "ShaderNodeRGBCurve", 32 | "ShaderNodeBlackbody", 33 | "ShaderNodeValToRGB", 34 | "ShaderNodeCombineXYZ", 35 | "ShaderNodeFloatCurve", 36 | "ShaderNodeRGBToBW", 37 | "ShaderNodeSeparateXYZ", 38 | "ShaderNodeWavelength", 39 | "ShaderNodeTexBrick", 40 | "ShaderNodeTexChecker", 41 | "ShaderNodeTexEnvironment", 42 | "ShaderNodeTexImage", 43 | "ShaderNodeTexMagic", 44 | "ShaderNodeTexPointDensity", 45 | "ShaderNodeBump", 46 | "ShaderNodeNormal", 47 | "ShaderNodeVectorCurve", 48 | "ShaderNodeVectorTransform" 49 | ] 50 | }, 51 | "specific_types": { 52 | "entries": [ 53 | "ShaderNodeMix", 54 | ["ShaderNodeMix", {"label": "Mix Vector", "settings": {"data_type": "VECTOR"}, "subtypes": ["factor_mode"]}], 55 | "ShaderNodeMapRange", 56 | ["ShaderNodeMapRange", { 57 | "label": "Map Range - Float", 58 | "settings": {"data_type": "FLOAT"}, 59 | "subtypes": ["interpolation_type"] 60 | } 61 | ], 62 | ["ShaderNodeMapRange", { 63 | "label": "Map Range - Vector", 64 | "settings": {"data_type": "FLOAT_VECTOR"}, 65 | "subtypes": ["interpolation_type"] 66 | } 67 | ] 68 | ] 69 | }, 70 | "basic_subtypes": { 71 | "entries": [ 72 | ["ShaderNodeClamp", {"subtypes": ["clamp_type"]}], 73 | ["ShaderNodeMath", {"subtypes": ["operation"]}], 74 | ["ShaderNodeVectorMath", {"subtypes": ["operation"]}], 75 | ["ShaderNodeVectorRotate", {"subtypes": ["rotation_type"]}], 76 | ["ShaderNodeCombineColor", {"subtypes": ["mode"]}], 77 | ["ShaderNodeSeparateColor", {"subtypes": ["mode"]}], 78 | ["ShaderNodeNormalMap", {"subtypes": ["space"]}], 79 | ["ShaderNodeDisplacement", {"subtypes": ["space"]}], 80 | ["ShaderNodeVectorDisplacement", {"subtypes": ["space"]}], 81 | ["ShaderNodeScript", {"subtypes": ["mode"]}], 82 | ["ShaderNodeMapping", {"subtypes": ["vector_type"]}] 83 | ] 84 | }, 85 | "texture_subtypes": { 86 | "entries": [ 87 | ["ShaderNodeTexSky", {"subtypes": ["sky_type"]}], 88 | ["ShaderNodeTexIES", {"subtypes": ["mode"]}], 89 | ["ShaderNodeTexGradient", {"subtypes": ["gradient_type"]}], 90 | ["ShaderNodeTexMusgrave", {"subtypes": ["musgrave_type", "musgrave_dimensions"]}], 91 | "ShaderNodeTexVoronoi", 92 | ["ShaderNodeTexVoronoi", { 93 | "only_subtypes": true, 94 | "subtypes": [ 95 | {"name": "voronoi_dimensions", "only_include": ["1D"]} 96 | ] 97 | } 98 | ], 99 | ["ShaderNodeTexVoronoi", { 100 | "only_subtypes": true, 101 | "subtypes": [ 102 | "distance", {"name": "voronoi_dimensions", "only_include": ["2D", "3D", "4D"]} 103 | ] 104 | } 105 | ], 106 | ["ShaderNodeTexNoise", {"subtypes": ["noise_dimensions"]}], 107 | ["ShaderNodeTexWhiteNoise", {"subtypes": ["noise_dimensions"]}], 108 | "ShaderNodeTexWave", 109 | ["ShaderNodeTexWave", { 110 | "only_subtypes": true, 111 | "subtypes": [ 112 | {"name": "bands_direction", "only_include": ["X", "Y", "Z", "Diagonal"]}, 113 | "wave_profile", 114 | {"name": "wave_type", "only_include": "Bands"} 115 | ] 116 | } 117 | ], 118 | ["ShaderNodeTexWave", { 119 | "only_subtypes": true, 120 | "subtypes": [ 121 | {"name": "rings_direction", "only_include": ["X", "Y", "Z", "Spherical"]}, 122 | "wave_profile", 123 | {"name": "wave_type", "only_include": "Rings"} 124 | ] 125 | } 126 | ] 127 | ] 128 | }, 129 | "group_nodes": { 130 | "poll": "in_nodegroup", 131 | "entries": [ 132 | "NodeGroupInput", 133 | "NodeGroupOutput" 134 | ] 135 | }, 136 | "mix_color": { 137 | "poll": "check_mix_color_alias", 138 | "poll_args": {"valid_options": ["DEFAULT", "MIX_COLOR", "BOTH"]}, 139 | "entries": [ 140 | ["ShaderNodeMix", { 141 | "label": "Mix Color", 142 | "settings": {"data_type": "RGBA"}, 143 | "subtypes": ["blend_type"] 144 | } 145 | ] 146 | ] 147 | }, 148 | "mix_rgb": { 149 | "poll": "check_mix_color_alias", 150 | "poll_args": { "valid_options": ["MIX_RGB", "BOTH"]}, 151 | "entries": [ 152 | ["ShaderNodeMix", { 153 | "label": "Mix RGB", 154 | "settings": {"data_type": "RGBA"}, 155 | "subtypes": ["blend_type"] 156 | } 157 | ] 158 | ] 159 | }, 160 | "world_shader_nodes": { 161 | "poll": "engine_and_shader_type_poll", 162 | "poll_args": {"shader_types": "WORLD"}, 163 | "entries": [ 164 | "ShaderNodeOutputWorld", 165 | "ShaderNodeBackground" 166 | ] 167 | }, 168 | "line_style_shader_nodes": { 169 | "poll": "engine_and_shader_type_poll", 170 | "poll_args": {"shader_types": "LINESTYLE"}, 171 | "entries": [ 172 | "ShaderNodeUVAlongStroke", 173 | "ShaderNodeOutputLineStyle" 174 | ] 175 | }, 176 | "cycles_eevee_shader_nodes": { 177 | "poll": "engine_and_shader_type_poll", 178 | "poll_args": { 179 | "engines": [ 180 | "CYCLES", 181 | "BLENDER_EEVEE" 182 | ] 183 | }, 184 | "entries": [ 185 | "ShaderNodeAddShader", 186 | "ShaderNodeEmission", 187 | "ShaderNodeMixShader", 188 | "ShaderNodeVolumeAbsorption", 189 | "ShaderNodeVolumeScatter" 190 | ] 191 | }, 192 | "object_cycles_shader_nodes": { 193 | "poll": "engine_and_shader_type_poll", 194 | "poll_args": {"shader_types": "OBJECT", "engines": "CYCLES"}, 195 | "entries": [ 196 | "ShaderNodeOutputLight", 197 | "ShaderNodeBsdfHair", 198 | "ShaderNodeBsdfHairPrincipled", 199 | ["ShaderNodeBsdfToon", {"subtypes": ["component"]}] 200 | ] 201 | }, 202 | "object_eevee_shader_nodes": { 203 | "poll": "engine_and_shader_type_poll", 204 | "poll_args": {"shader_types": "OBJECT", "engines": "BLENDER_EEVEE"}, 205 | "entries": [ 206 | "ShaderNodeShaderToRGB", 207 | "ShaderNodeEeveeSpecular" 208 | ] 209 | }, 210 | "object_cycles_eevee_shader_nodes": { 211 | "poll": "engine_and_shader_type_poll", 212 | "poll_args": { 213 | "shader_types": "OBJECT", 214 | "engines": [ 215 | "CYCLES", 216 | "BLENDER_EEVEE" 217 | ] 218 | }, 219 | "entries": [ 220 | "ShaderNodeOutputMaterial", 221 | "ShaderNodeBsdfDiffuse", 222 | ["ShaderNodeBsdfGlass", {"subtypes": ["distribution"]}], 223 | ["ShaderNodeBsdfAnisotropic", {"subtypes": ["distribution"]}], 224 | ["ShaderNodeBsdfGlossy", {"subtypes": ["distribution"]}], 225 | "ShaderNodeHoldout", 226 | "ShaderNodeBsdfPrincipled", 227 | ["ShaderNodeBsdfRefraction", {"subtypes": ["distribution"]}], 228 | ["ShaderNodeSubsurfaceScattering", {"subtypes": ["falloff"]}], 229 | "ShaderNodeBsdfTranslucent", 230 | "ShaderNodeBsdfTransparent" 231 | ] 232 | }, 233 | "frame_and_reroute": { 234 | "entries": [ 235 | "NodeFrame", 236 | "NodeReroute" 237 | ] 238 | } 239 | } -------------------------------------------------------------------------------- /source/nodelists/3.4/TextureNodeTree.json: -------------------------------------------------------------------------------- 1 | { 2 | "items": { 3 | "entries": [ 4 | "TextureNodeCoordinates", 5 | "TextureNodeCurveTime", 6 | "TextureNodeImage", 7 | "TextureNodeTexture", 8 | "TextureNodeOutput", 9 | "TextureNodeViewer", 10 | "TextureNodeHueSaturation", 11 | "TextureNodeInvert", 12 | "TextureNodeCurveRGB", 13 | "TextureNodeValToRGB", 14 | "TextureNodeDistance", 15 | "TextureNodeRGBToBW", 16 | "TextureNodeValToNor", 17 | "TextureNodeAt", 18 | "TextureNodeRotate", 19 | "TextureNodeScale", 20 | "TextureNodeTranslate", 21 | "TextureNodeBricks", 22 | "TextureNodeChecker", 23 | "TextureNodeTexBlend", 24 | "TextureNodeTexClouds", 25 | "TextureNodeTexDistNoise", 26 | "TextureNodeTexMagic", 27 | "TextureNodeTexMarble", 28 | "TextureNodeTexMusgrave", 29 | "TextureNodeTexNoise", 30 | "TextureNodeTexStucci", 31 | "TextureNodeTexVoronoi", 32 | "TextureNodeTexWood" 33 | ] 34 | }, 35 | "basic_subtypes": { 36 | "entries": [ 37 | ["TextureNodeMath", {"subtypes": ["operation"]}], 38 | ["TextureNodeCombineColor", {"subtypes": ["mode"]}], 39 | ["TextureNodeSeparateColor", {"subtypes": ["mode"]}] 40 | ] 41 | }, 42 | "mix_color": { 43 | "poll": "check_mix_color_alias", 44 | "poll_args": { 45 | "valid_options": ["MIX_COLOR", "BOTH"] 46 | }, 47 | "entries": [ 48 | ["TextureNodeMixRGB", {"label": "Mix Color", "subtypes": ["blend_type"]}] 49 | ] 50 | }, 51 | "mix_rgb": { 52 | "poll": "check_mix_color_alias", 53 | "poll_args": { 54 | "valid_options": ["DEFAULT", "MIX_RGB", "BOTH"] 55 | }, 56 | "entries": [ 57 | ["TextureNodeMixRGB", {"subtypes": ["blend_type"]}] 58 | ] 59 | }, 60 | "group_nodes": { 61 | "poll": "in_nodegroup", 62 | "entries": [ 63 | "NodeGroupInput", 64 | "NodeGroupOutput" 65 | ] 66 | }, 67 | "frame_and_reroute": { 68 | "entries": [ 69 | "NodeFrame", 70 | "NodeReroute" 71 | ] 72 | } 73 | } -------------------------------------------------------------------------------- /source/nodelists/3.5/CompositorNodeTree.json: -------------------------------------------------------------------------------- 1 | { 2 | "items": { 3 | "entries": [ 4 | "CompositorNodeBokehImage", 5 | "CompositorNodeImage", 6 | "CompositorNodeMask", 7 | "CompositorNodeMovieClip", 8 | "CompositorNodeTexture", 9 | "CompositorNodeRGB", 10 | "CompositorNodeValue", 11 | "CompositorNodeRLayers", 12 | "CompositorNodeSceneTime", 13 | "CompositorNodeTime", 14 | "CompositorNodeComposite", 15 | "CompositorNodeViewer", 16 | "CompositorNodeOutputFile", 17 | "CompositorNodeValToRGB", 18 | "CompositorNodeConvertColorSpace", 19 | "CompositorNodeInvert", 20 | "CompositorNodeRGBToBW", 21 | "CompositorNodeBrightContrast", 22 | "CompositorNodeColorCorrection", 23 | "CompositorNodeExposure", 24 | "CompositorNodeGamma", 25 | "CompositorNodeHueCorrect", 26 | "CompositorNodeHueSat", 27 | "CompositorNodeCurveRGB", 28 | "CompositorNodeAlphaOver", 29 | "CompositorNodeZcombine", 30 | "CompositorNodeAntiAliasing", 31 | "CompositorNodeDespeckle", 32 | "CompositorNodeInpaint", 33 | "CompositorNodePixelate", 34 | "CompositorNodePosterize", 35 | "CompositorNodeSunBeams", 36 | "CompositorNodeBilateralblur", 37 | "CompositorNodeBokehBlur", 38 | "CompositorNodeDBlur", 39 | "CompositorNodeVecBlur", 40 | "CompositorNodeChannelMatte", 41 | "CompositorNodeChromaMatte", 42 | "CompositorNodeColorMatte", 43 | "CompositorNodeColorSpill", 44 | "CompositorNodeDiffMatte", 45 | "CompositorNodeKeying", 46 | "CompositorNodeKeyingScreen", 47 | "CompositorNodeLumaMatte", 48 | "CompositorNodeCryptomatte", 49 | "CompositorNodeBoxMask", 50 | "CompositorNodeEllipseMask", 51 | "CompositorNodeDoubleEdgeMask", 52 | "CompositorNodeIDMask", 53 | "CompositorNodePlaneTrackDeform", 54 | "CompositorNodeStabilize", 55 | "CompositorNodeTrackPos", 56 | "CompositorNodeCornerPin", 57 | "CompositorNodeCrop", 58 | "CompositorNodeDisplace", 59 | "CompositorNodeMapUV", 60 | "CompositorNodeLensdist", 61 | "CompositorNodeMapRange", 62 | "CompositorNodeMapValue", 63 | "CompositorNodeNormalize", 64 | "CompositorNodeSwitch", 65 | "CompositorNodeCombineXYZ", 66 | "CompositorNodeSeparateXYZ", 67 | "CompositorNodeNormal", 68 | "CompositorNodeCurveVec" 69 | ] 70 | }, 71 | "combine_and_separate_color": { 72 | "entries": [ 73 | ["CompositorNodeCombineColor", {"subtypes": ["mode"]}], 74 | ["CompositorNodeCombineColor", { 75 | "only_subtypes" : true, 76 | "subtypes": [ 77 | {"name": "mode", "only_include": ["YCbCr"]}, 78 | "ycc_mode" 79 | ] 80 | } 81 | ], 82 | ["CompositorNodeSeparateColor", {"subtypes": ["mode"]}], 83 | ["CompositorNodeSeparateColor", { 84 | "only_subtypes" : true, 85 | "subtypes": [ 86 | {"name": "mode", "only_include": ["YCbCr"]}, 87 | "ycc_mode" 88 | ] 89 | } 90 | ] 91 | ] 92 | }, 93 | "specific_types": { 94 | "entries": [ 95 | ["CompositorNodeSwitchView", {"label": "Switch Stereo View"}] 96 | ] 97 | }, 98 | "basic_subtypes": { 99 | "entries": [ 100 | ["CompositorNodePremulKey", {"subtypes": ["mapping"]}], 101 | ["CompositorNodeColorBalance", {"subtypes": ["correction_method"]}], 102 | ["CompositorNodeCryptomatteV2", {"subtypes": ["source"]}], 103 | ["CompositorNodeDistanceMatte", {"subtypes": ["channel"]}], 104 | ["CompositorNodeMovieDistortion", {"subtypes": ["distortion_type"]}], 105 | ["CompositorNodeSetAlpha", {"subtypes": ["mode"]}], 106 | ["CompositorNodeDefocus", {"subtypes": ["bokeh"]}], 107 | ["CompositorNodeDenoise", {"subtypes": ["prefilter"]}], 108 | ["CompositorNodeDilateErode", {"subtypes": ["mode"]}], 109 | ["CompositorNodeDilateErode", { 110 | "only_subtypes": true, 111 | "subtypes": [ 112 | {"name": "mode", "only_include": ["Feather"]}, 113 | "falloff" 114 | ] 115 | } 116 | ], 117 | ["CompositorNodeGlare", {"subtypes": ["glare_type"]}], 118 | ["CompositorNodeRotate", {"subtypes": ["filter_type"]}], 119 | ["CompositorNodeScale", {"subtypes": ["space"]}], 120 | ["CompositorNodeScale", { 121 | "only_subtypes": true, 122 | "subtypes": [ 123 | {"name": "space", "only_include": ["Render Size"]}, 124 | "frame_method" 125 | ] 126 | } 127 | ], 128 | ["CompositorNodeTransform", {"subtypes": ["filter_type"]}], 129 | ["CompositorNodeTranslate", {"subtypes": ["wrap_axis"]}], 130 | ["CompositorNodeFlip", {"subtypes": ["axis"]}], 131 | ["CompositorNodeBlur", {"subtypes": ["filter_type"]}], 132 | ["CompositorNodeLevels", {"subtypes": ["channel"]}], 133 | ["CompositorNodeMath", {"subtypes": ["operation"]}], 134 | ["CompositorNodeFilter", {"subtypes": ["filter_type"]}], 135 | ["CompositorNodeSplitViewer", {"subtypes": ["axis"]}], 136 | ["CompositorNodeTonemap", {"subtypes": ["tonemap_type"]}] 137 | ] 138 | }, 139 | "mix_color": { 140 | "poll": "check_mix_color_alias", 141 | "poll_args": {"valid_options": ["DEFAULT", "MIX_COLOR", "BOTH"]}, 142 | "entries": [ 143 | ["CompositorNodeMixRGB", {"label": "Mix Color", "subtypes": ["blend_type"]}] 144 | ] 145 | }, 146 | "mix_rgb": { 147 | "poll": "check_mix_color_alias", 148 | "poll_args": { "valid_options": ["MIX_RGB", "BOTH"]}, 149 | "entries": [ 150 | ["CompositorNodeMixRGB", {"label": "Mix RGB", "subtypes": ["blend_type"]}] 151 | ] 152 | }, 153 | "group_nodes": { 154 | "poll": "in_nodegroup", 155 | "entries": [ 156 | "NodeGroupInput", 157 | "NodeGroupOutput" 158 | ] 159 | }, 160 | "frame_and_reroute": { 161 | "entries": [ 162 | "NodeFrame", 163 | "NodeReroute" 164 | ] 165 | } 166 | } -------------------------------------------------------------------------------- /source/nodelists/3.5/ShaderNodeTree.json: -------------------------------------------------------------------------------- 1 | { 2 | "items": { 3 | "entries": [ 4 | "ShaderNodeAmbientOcclusion", 5 | "ShaderNodeAttribute", 6 | "ShaderNodeBevel", 7 | "ShaderNodeCameraData", 8 | "ShaderNodeVertexColor", 9 | "ShaderNodeHairInfo", 10 | "ShaderNodeFresnel", 11 | "ShaderNodeNewGeometry", 12 | "ShaderNodeLayerWeight", 13 | "ShaderNodeLightPath", 14 | "ShaderNodeObjectInfo", 15 | "ShaderNodeParticleInfo", 16 | "ShaderNodePointInfo", 17 | "ShaderNodeRGB", 18 | "ShaderNodeTangent", 19 | "ShaderNodeTexCoord", 20 | "ShaderNodeUVMap", 21 | "ShaderNodeValue", 22 | "ShaderNodeVolumeInfo", 23 | "ShaderNodeWireframe", 24 | "ShaderNodeOutputAOV", 25 | "ShaderNodeVolumePrincipled", 26 | "ShaderNodeBrightContrast", 27 | "ShaderNodeGamma", 28 | "ShaderNodeHueSaturation", 29 | "ShaderNodeInvert", 30 | "ShaderNodeLightFalloff", 31 | "ShaderNodeRGBCurve", 32 | "ShaderNodeBlackbody", 33 | "ShaderNodeValToRGB", 34 | "ShaderNodeCombineXYZ", 35 | "ShaderNodeFloatCurve", 36 | "ShaderNodeRGBToBW", 37 | "ShaderNodeSeparateXYZ", 38 | "ShaderNodeWavelength", 39 | "ShaderNodeTexBrick", 40 | "ShaderNodeTexChecker", 41 | "ShaderNodeTexEnvironment", 42 | "ShaderNodeTexImage", 43 | "ShaderNodeTexMagic", 44 | "ShaderNodeTexPointDensity", 45 | "ShaderNodeBump", 46 | "ShaderNodeNormal", 47 | "ShaderNodeVectorCurve", 48 | "ShaderNodeVectorTransform" 49 | ] 50 | }, 51 | "specific_types": { 52 | "entries": [ 53 | "ShaderNodeMix", 54 | ["ShaderNodeMix", {"label": "Mix Vector", "settings": {"data_type": "VECTOR"}, "subtypes": ["factor_mode"]}], 55 | "ShaderNodeMapRange", 56 | ["ShaderNodeMapRange", { 57 | "label": "Map Range - Float", 58 | "settings": {"data_type": "FLOAT"}, 59 | "subtypes": ["interpolation_type"] 60 | } 61 | ], 62 | ["ShaderNodeMapRange", { 63 | "label": "Map Range - Vector", 64 | "settings": {"data_type": "FLOAT_VECTOR"}, 65 | "subtypes": ["interpolation_type"] 66 | } 67 | ] 68 | ] 69 | }, 70 | "basic_subtypes": { 71 | "entries": [ 72 | ["ShaderNodeClamp", {"subtypes": ["clamp_type"]}], 73 | ["ShaderNodeMath", {"subtypes": ["operation"]}], 74 | ["ShaderNodeVectorMath", {"subtypes": ["operation"]}], 75 | ["ShaderNodeVectorRotate", {"subtypes": ["rotation_type"]}], 76 | ["ShaderNodeCombineColor", {"subtypes": ["mode"]}], 77 | ["ShaderNodeSeparateColor", {"subtypes": ["mode"]}], 78 | ["ShaderNodeNormalMap", {"subtypes": ["space"]}], 79 | ["ShaderNodeDisplacement", {"subtypes": ["space"]}], 80 | ["ShaderNodeVectorDisplacement", {"subtypes": ["space"]}], 81 | ["ShaderNodeScript", {"subtypes": ["mode"]}], 82 | ["ShaderNodeMapping", {"subtypes": ["vector_type"]}] 83 | ] 84 | }, 85 | "texture_subtypes": { 86 | "entries": [ 87 | ["ShaderNodeTexSky", {"subtypes": ["sky_type"]}], 88 | ["ShaderNodeTexIES", {"subtypes": ["mode"]}], 89 | ["ShaderNodeTexGradient", {"subtypes": ["gradient_type"]}], 90 | ["ShaderNodeTexMusgrave", {"subtypes": ["musgrave_type", "musgrave_dimensions"]}], 91 | "ShaderNodeTexVoronoi", 92 | ["ShaderNodeTexVoronoi", { 93 | "only_subtypes": true, 94 | "subtypes": [ 95 | {"name": "voronoi_dimensions", "only_include": ["1D"]} 96 | ] 97 | } 98 | ], 99 | ["ShaderNodeTexVoronoi", { 100 | "only_subtypes": true, 101 | "subtypes": [ 102 | "distance", {"name": "voronoi_dimensions", "only_include": ["2D", "3D", "4D"]} 103 | ] 104 | } 105 | ], 106 | ["ShaderNodeTexNoise", {"subtypes": ["noise_dimensions"]}], 107 | ["ShaderNodeTexWhiteNoise", {"subtypes": ["noise_dimensions"]}], 108 | "ShaderNodeTexWave", 109 | ["ShaderNodeTexWave", { 110 | "only_subtypes": true, 111 | "subtypes": [ 112 | {"name": "bands_direction", "only_include": ["X", "Y", "Z", "Diagonal"]}, 113 | "wave_profile", 114 | {"name": "wave_type", "only_include": "Bands"} 115 | ] 116 | } 117 | ], 118 | ["ShaderNodeTexWave", { 119 | "only_subtypes": true, 120 | "subtypes": [ 121 | {"name": "rings_direction", "only_include": ["X", "Y", "Z", "Spherical"]}, 122 | "wave_profile", 123 | {"name": "wave_type", "only_include": "Rings"} 124 | ] 125 | } 126 | ] 127 | ] 128 | }, 129 | "group_nodes": { 130 | "poll": "in_nodegroup", 131 | "entries": [ 132 | "NodeGroupInput", 133 | "NodeGroupOutput" 134 | ] 135 | }, 136 | "mix_color": { 137 | "poll": "check_mix_color_alias", 138 | "poll_args": {"valid_options": ["DEFAULT", "MIX_COLOR", "BOTH"]}, 139 | "entries": [ 140 | ["ShaderNodeMix", { 141 | "label": "Mix Color", 142 | "settings": {"data_type": "RGBA"}, 143 | "subtypes": ["blend_type"] 144 | } 145 | ] 146 | ] 147 | }, 148 | "mix_rgb": { 149 | "poll": "check_mix_color_alias", 150 | "poll_args": { "valid_options": ["MIX_RGB", "BOTH"]}, 151 | "entries": [ 152 | ["ShaderNodeMix", { 153 | "label": "Mix RGB", 154 | "settings": {"data_type": "RGBA"}, 155 | "subtypes": ["blend_type"] 156 | } 157 | ] 158 | ] 159 | }, 160 | "world_shader_nodes": { 161 | "poll": "engine_and_shader_type_poll", 162 | "poll_args": {"shader_types": "WORLD"}, 163 | "entries": [ 164 | "ShaderNodeOutputWorld", 165 | "ShaderNodeBackground" 166 | ] 167 | }, 168 | "line_style_shader_nodes": { 169 | "poll": "engine_and_shader_type_poll", 170 | "poll_args": {"shader_types": "LINESTYLE"}, 171 | "entries": [ 172 | "ShaderNodeUVAlongStroke", 173 | "ShaderNodeOutputLineStyle" 174 | ] 175 | }, 176 | "cycles_eevee_shader_nodes": { 177 | "poll": "engine_and_shader_type_poll", 178 | "poll_args": { 179 | "engines": [ 180 | "CYCLES", 181 | "BLENDER_EEVEE" 182 | ] 183 | }, 184 | "entries": [ 185 | "ShaderNodeAddShader", 186 | "ShaderNodeEmission", 187 | "ShaderNodeMixShader", 188 | "ShaderNodeVolumeAbsorption", 189 | "ShaderNodeVolumeScatter" 190 | ] 191 | }, 192 | "object_cycles_shader_nodes": { 193 | "poll": "engine_and_shader_type_poll", 194 | "poll_args": {"shader_types": "OBJECT", "engines": "CYCLES"}, 195 | "entries": [ 196 | "ShaderNodeOutputLight", 197 | "ShaderNodeBsdfHair", 198 | "ShaderNodeBsdfHairPrincipled", 199 | ["ShaderNodeBsdfToon", {"subtypes": ["component"]}] 200 | ] 201 | }, 202 | "object_eevee_shader_nodes": { 203 | "poll": "engine_and_shader_type_poll", 204 | "poll_args": {"shader_types": "OBJECT", "engines": "BLENDER_EEVEE"}, 205 | "entries": [ 206 | "ShaderNodeShaderToRGB", 207 | "ShaderNodeEeveeSpecular" 208 | ] 209 | }, 210 | "object_cycles_eevee_shader_nodes": { 211 | "poll": "engine_and_shader_type_poll", 212 | "poll_args": { 213 | "shader_types": "OBJECT", 214 | "engines": [ 215 | "CYCLES", 216 | "BLENDER_EEVEE" 217 | ] 218 | }, 219 | "entries": [ 220 | "ShaderNodeOutputMaterial", 221 | "ShaderNodeBsdfDiffuse", 222 | ["ShaderNodeBsdfGlass", {"subtypes": ["distribution"]}], 223 | ["ShaderNodeBsdfAnisotropic", {"subtypes": ["distribution"]}], 224 | ["ShaderNodeBsdfGlossy", {"subtypes": ["distribution"]}], 225 | "ShaderNodeHoldout", 226 | "ShaderNodeBsdfPrincipled", 227 | ["ShaderNodeBsdfRefraction", {"subtypes": ["distribution"]}], 228 | ["ShaderNodeSubsurfaceScattering", {"subtypes": ["falloff"]}], 229 | "ShaderNodeBsdfTranslucent", 230 | "ShaderNodeBsdfTransparent" 231 | ] 232 | }, 233 | "frame_and_reroute": { 234 | "entries": [ 235 | "NodeFrame", 236 | "NodeReroute" 237 | ] 238 | } 239 | } -------------------------------------------------------------------------------- /source/nodelists/3.5/TextureNodeTree.json: -------------------------------------------------------------------------------- 1 | { 2 | "items": { 3 | "entries": [ 4 | "TextureNodeCoordinates", 5 | "TextureNodeCurveTime", 6 | "TextureNodeImage", 7 | "TextureNodeTexture", 8 | "TextureNodeOutput", 9 | "TextureNodeViewer", 10 | "TextureNodeHueSaturation", 11 | "TextureNodeInvert", 12 | "TextureNodeCurveRGB", 13 | "TextureNodeValToRGB", 14 | "TextureNodeDistance", 15 | "TextureNodeRGBToBW", 16 | "TextureNodeValToNor", 17 | "TextureNodeAt", 18 | "TextureNodeRotate", 19 | "TextureNodeScale", 20 | "TextureNodeTranslate", 21 | "TextureNodeBricks", 22 | "TextureNodeChecker", 23 | "TextureNodeTexBlend", 24 | "TextureNodeTexClouds", 25 | "TextureNodeTexDistNoise", 26 | "TextureNodeTexMagic", 27 | "TextureNodeTexMarble", 28 | "TextureNodeTexMusgrave", 29 | "TextureNodeTexNoise", 30 | "TextureNodeTexStucci", 31 | "TextureNodeTexVoronoi", 32 | "TextureNodeTexWood" 33 | ] 34 | }, 35 | "basic_subtypes": { 36 | "entries": [ 37 | ["TextureNodeMath", {"subtypes": ["operation"]}], 38 | ["TextureNodeCombineColor", {"subtypes": ["mode"]}], 39 | ["TextureNodeSeparateColor", {"subtypes": ["mode"]}] 40 | ] 41 | }, 42 | "mix_color": { 43 | "poll": "check_mix_color_alias", 44 | "poll_args": { 45 | "valid_options": ["MIX_COLOR", "BOTH"] 46 | }, 47 | "entries": [ 48 | ["TextureNodeMixRGB", {"label": "Mix Color", "subtypes": ["blend_type"]}] 49 | ] 50 | }, 51 | "mix_rgb": { 52 | "poll": "check_mix_color_alias", 53 | "poll_args": { 54 | "valid_options": ["DEFAULT", "MIX_RGB", "BOTH"] 55 | }, 56 | "entries": [ 57 | ["TextureNodeMixRGB", {"subtypes": ["blend_type"]}] 58 | ] 59 | }, 60 | "group_nodes": { 61 | "poll": "in_nodegroup", 62 | "entries": [ 63 | "NodeGroupInput", 64 | "NodeGroupOutput" 65 | ] 66 | }, 67 | "frame_and_reroute": { 68 | "entries": [ 69 | "NodeFrame", 70 | "NodeReroute" 71 | ] 72 | } 73 | } -------------------------------------------------------------------------------- /source/nodelists/3.6/CompositorNodeTree.json: -------------------------------------------------------------------------------- 1 | { 2 | "items": { 3 | "entries": [ 4 | "CompositorNodeBokehImage", 5 | "CompositorNodeImage", 6 | "CompositorNodeMask", 7 | "CompositorNodeMovieClip", 8 | "CompositorNodeTexture", 9 | "CompositorNodeRGB", 10 | "CompositorNodeValue", 11 | "CompositorNodeRLayers", 12 | "CompositorNodeSceneTime", 13 | "CompositorNodeTime", 14 | "CompositorNodeComposite", 15 | "CompositorNodeViewer", 16 | "CompositorNodeOutputFile", 17 | "CompositorNodeValToRGB", 18 | "CompositorNodeConvertColorSpace", 19 | "CompositorNodeInvert", 20 | "CompositorNodeRGBToBW", 21 | "CompositorNodeBrightContrast", 22 | "CompositorNodeColorCorrection", 23 | "CompositorNodeExposure", 24 | "CompositorNodeGamma", 25 | "CompositorNodeHueCorrect", 26 | "CompositorNodeHueSat", 27 | "CompositorNodeCurveRGB", 28 | "CompositorNodeAlphaOver", 29 | "CompositorNodeZcombine", 30 | "CompositorNodeAntiAliasing", 31 | "CompositorNodeDespeckle", 32 | "CompositorNodeInpaint", 33 | "CompositorNodePixelate", 34 | "CompositorNodePosterize", 35 | "CompositorNodeSunBeams", 36 | "CompositorNodeBilateralblur", 37 | "CompositorNodeBokehBlur", 38 | "CompositorNodeDBlur", 39 | "CompositorNodeVecBlur", 40 | "CompositorNodeChannelMatte", 41 | "CompositorNodeChromaMatte", 42 | "CompositorNodeColorMatte", 43 | "CompositorNodeColorSpill", 44 | "CompositorNodeDiffMatte", 45 | "CompositorNodeKeying", 46 | "CompositorNodeKeyingScreen", 47 | "CompositorNodeLumaMatte", 48 | "CompositorNodeCryptomatte", 49 | "CompositorNodeBoxMask", 50 | "CompositorNodeEllipseMask", 51 | "CompositorNodeDoubleEdgeMask", 52 | "CompositorNodeIDMask", 53 | "CompositorNodePlaneTrackDeform", 54 | "CompositorNodeStabilize", 55 | "CompositorNodeTrackPos", 56 | "CompositorNodeCornerPin", 57 | "CompositorNodeCrop", 58 | "CompositorNodeDisplace", 59 | "CompositorNodeMapUV", 60 | "CompositorNodeLensdist", 61 | "CompositorNodeMapRange", 62 | "CompositorNodeMapValue", 63 | "CompositorNodeNormalize", 64 | "CompositorNodeSwitch", 65 | "CompositorNodeCombineXYZ", 66 | "CompositorNodeSeparateXYZ", 67 | "CompositorNodeNormal", 68 | "CompositorNodeCurveVec" 69 | ] 70 | }, 71 | "combine_and_separate_color": { 72 | "entries": [ 73 | ["CompositorNodeCombineColor", {"subtypes": ["mode"]}], 74 | ["CompositorNodeCombineColor", { 75 | "only_subtypes" : true, 76 | "subtypes": [ 77 | {"name": "mode", "only_include": ["YCbCr"]}, 78 | "ycc_mode" 79 | ] 80 | } 81 | ], 82 | ["CompositorNodeSeparateColor", {"subtypes": ["mode"]}], 83 | ["CompositorNodeSeparateColor", { 84 | "only_subtypes" : true, 85 | "subtypes": [ 86 | {"name": "mode", "only_include": ["YCbCr"]}, 87 | "ycc_mode" 88 | ] 89 | } 90 | ] 91 | ] 92 | }, 93 | "specific_types": { 94 | "entries": [ 95 | ["CompositorNodeSwitchView", {"label": "Switch Stereo View"}] 96 | ] 97 | }, 98 | "basic_subtypes": { 99 | "entries": [ 100 | ["CompositorNodePremulKey", {"subtypes": ["mapping"]}], 101 | ["CompositorNodeColorBalance", {"subtypes": ["correction_method"]}], 102 | ["CompositorNodeCryptomatteV2", {"subtypes": ["source"]}], 103 | ["CompositorNodeDistanceMatte", {"subtypes": ["channel"]}], 104 | ["CompositorNodeMovieDistortion", {"subtypes": ["distortion_type"]}], 105 | ["CompositorNodeSetAlpha", {"subtypes": ["mode"]}], 106 | ["CompositorNodeDefocus", {"subtypes": ["bokeh"]}], 107 | ["CompositorNodeDenoise", {"subtypes": ["prefilter"]}], 108 | ["CompositorNodeDilateErode", {"subtypes": ["mode"]}], 109 | ["CompositorNodeDilateErode", { 110 | "only_subtypes": true, 111 | "subtypes": [ 112 | {"name": "mode", "only_include": ["Feather"]}, 113 | "falloff" 114 | ] 115 | } 116 | ], 117 | ["CompositorNodeGlare", {"subtypes": ["glare_type"]}], 118 | ["CompositorNodeRotate", {"subtypes": ["filter_type"]}], 119 | ["CompositorNodeScale", {"subtypes": ["space"]}], 120 | ["CompositorNodeScale", { 121 | "only_subtypes": true, 122 | "subtypes": [ 123 | {"name": "space", "only_include": ["Render Size"]}, 124 | "frame_method" 125 | ] 126 | } 127 | ], 128 | ["CompositorNodeTransform", {"subtypes": ["filter_type"]}], 129 | ["CompositorNodeTranslate", {"subtypes": ["wrap_axis"]}], 130 | ["CompositorNodeFlip", {"subtypes": ["axis"]}], 131 | ["CompositorNodeBlur", {"subtypes": ["filter_type"]}], 132 | ["CompositorNodeLevels", {"subtypes": ["channel"]}], 133 | ["CompositorNodeMath", {"subtypes": ["operation"]}], 134 | ["CompositorNodeFilter", {"subtypes": ["filter_type"]}], 135 | ["CompositorNodeSplitViewer", {"subtypes": ["axis"]}], 136 | ["CompositorNodeTonemap", {"subtypes": ["tonemap_type"]}] 137 | ] 138 | }, 139 | "mix_color": { 140 | "poll": "check_mix_color_alias", 141 | "poll_args": {"valid_options": ["DEFAULT", "MIX_COLOR", "BOTH"]}, 142 | "entries": [ 143 | ["CompositorNodeMixRGB", {"label": "Mix Color", "subtypes": ["blend_type"]}] 144 | ] 145 | }, 146 | "mix_rgb": { 147 | "poll": "check_mix_color_alias", 148 | "poll_args": { "valid_options": ["MIX_RGB", "BOTH"]}, 149 | "entries": [ 150 | ["CompositorNodeMixRGB", {"label": "Mix RGB", "subtypes": ["blend_type"]}] 151 | ] 152 | }, 153 | "group_nodes": { 154 | "poll": "in_nodegroup", 155 | "entries": [ 156 | "NodeGroupInput", 157 | "NodeGroupOutput" 158 | ] 159 | }, 160 | "frame_and_reroute": { 161 | "entries": [ 162 | "NodeFrame", 163 | "NodeReroute" 164 | ] 165 | } 166 | } -------------------------------------------------------------------------------- /source/nodelists/3.6/ShaderNodeTree.json: -------------------------------------------------------------------------------- 1 | { 2 | "items": { 3 | "entries": [ 4 | "ShaderNodeAmbientOcclusion", 5 | "ShaderNodeAttribute", 6 | "ShaderNodeBevel", 7 | "ShaderNodeCameraData", 8 | "ShaderNodeVertexColor", 9 | "ShaderNodeHairInfo", 10 | "ShaderNodeFresnel", 11 | "ShaderNodeNewGeometry", 12 | "ShaderNodeLayerWeight", 13 | "ShaderNodeLightPath", 14 | "ShaderNodeObjectInfo", 15 | "ShaderNodeParticleInfo", 16 | "ShaderNodePointInfo", 17 | "ShaderNodeRGB", 18 | "ShaderNodeTangent", 19 | "ShaderNodeTexCoord", 20 | "ShaderNodeUVMap", 21 | "ShaderNodeValue", 22 | "ShaderNodeVolumeInfo", 23 | "ShaderNodeWireframe", 24 | "ShaderNodeOutputAOV", 25 | "ShaderNodeVolumePrincipled", 26 | "ShaderNodeBrightContrast", 27 | "ShaderNodeGamma", 28 | "ShaderNodeHueSaturation", 29 | "ShaderNodeInvert", 30 | "ShaderNodeLightFalloff", 31 | "ShaderNodeRGBCurve", 32 | "ShaderNodeBlackbody", 33 | "ShaderNodeValToRGB", 34 | "ShaderNodeCombineXYZ", 35 | "ShaderNodeFloatCurve", 36 | "ShaderNodeRGBToBW", 37 | "ShaderNodeSeparateXYZ", 38 | "ShaderNodeWavelength", 39 | "ShaderNodeTexBrick", 40 | "ShaderNodeTexChecker", 41 | "ShaderNodeTexEnvironment", 42 | "ShaderNodeTexImage", 43 | "ShaderNodeTexMagic", 44 | "ShaderNodeTexPointDensity", 45 | "ShaderNodeBump", 46 | "ShaderNodeNormal", 47 | "ShaderNodeVectorCurve", 48 | "ShaderNodeVectorTransform" 49 | ] 50 | }, 51 | "specific_types": { 52 | "entries": [ 53 | "ShaderNodeMix", 54 | ["ShaderNodeMix", {"label": "Mix Vector", "settings": {"data_type": "VECTOR"}, "subtypes": ["factor_mode"]}], 55 | "ShaderNodeMapRange", 56 | ["ShaderNodeMapRange", { 57 | "label": "Map Range - Float", 58 | "settings": {"data_type": "FLOAT"}, 59 | "subtypes": ["interpolation_type"] 60 | } 61 | ], 62 | ["ShaderNodeMapRange", { 63 | "label": "Map Range - Vector", 64 | "settings": {"data_type": "FLOAT_VECTOR"}, 65 | "subtypes": ["interpolation_type"] 66 | } 67 | ] 68 | ] 69 | }, 70 | "basic_subtypes": { 71 | "entries": [ 72 | ["ShaderNodeClamp", {"subtypes": ["clamp_type"]}], 73 | ["ShaderNodeMath", {"subtypes": ["operation"]}], 74 | ["ShaderNodeVectorMath", {"subtypes": ["operation"]}], 75 | ["ShaderNodeVectorRotate", {"subtypes": ["rotation_type"]}], 76 | ["ShaderNodeCombineColor", {"subtypes": ["mode"]}], 77 | ["ShaderNodeSeparateColor", {"subtypes": ["mode"]}], 78 | ["ShaderNodeNormalMap", {"subtypes": ["space"]}], 79 | ["ShaderNodeDisplacement", {"subtypes": ["space"]}], 80 | ["ShaderNodeVectorDisplacement", {"subtypes": ["space"]}], 81 | ["ShaderNodeScript", {"subtypes": ["mode"]}], 82 | ["ShaderNodeMapping", {"subtypes": ["vector_type"]}] 83 | ] 84 | }, 85 | "texture_subtypes": { 86 | "entries": [ 87 | ["ShaderNodeTexSky", {"subtypes": ["sky_type"]}], 88 | ["ShaderNodeTexIES", {"subtypes": ["mode"]}], 89 | ["ShaderNodeTexGradient", {"subtypes": ["gradient_type"]}], 90 | ["ShaderNodeTexMusgrave", {"subtypes": ["musgrave_type", "musgrave_dimensions"]}], 91 | "ShaderNodeTexVoronoi", 92 | ["ShaderNodeTexVoronoi", { 93 | "only_subtypes": true, 94 | "subtypes": [ 95 | {"name": "voronoi_dimensions", "only_include": ["1D"]} 96 | ] 97 | } 98 | ], 99 | ["ShaderNodeTexVoronoi", { 100 | "only_subtypes": true, 101 | "subtypes": [ 102 | "distance", {"name": "voronoi_dimensions", "only_include": ["2D", "3D", "4D"]} 103 | ] 104 | } 105 | ], 106 | ["ShaderNodeTexNoise", {"subtypes": ["noise_dimensions"]}], 107 | ["ShaderNodeTexWhiteNoise", {"subtypes": ["noise_dimensions"]}], 108 | "ShaderNodeTexWave", 109 | ["ShaderNodeTexWave", { 110 | "only_subtypes": true, 111 | "subtypes": [ 112 | {"name": "bands_direction", "only_include": ["X", "Y", "Z", "Diagonal"]}, 113 | "wave_profile", 114 | {"name": "wave_type", "only_include": "Bands"} 115 | ] 116 | } 117 | ], 118 | ["ShaderNodeTexWave", { 119 | "only_subtypes": true, 120 | "subtypes": [ 121 | {"name": "rings_direction", "only_include": ["X", "Y", "Z", "Spherical"]}, 122 | "wave_profile", 123 | {"name": "wave_type", "only_include": "Rings"} 124 | ] 125 | } 126 | ] 127 | ] 128 | }, 129 | "group_nodes": { 130 | "poll": "in_nodegroup", 131 | "entries": [ 132 | "NodeGroupInput", 133 | "NodeGroupOutput" 134 | ] 135 | }, 136 | "mix_color": { 137 | "poll": "check_mix_color_alias", 138 | "poll_args": {"valid_options": ["DEFAULT", "MIX_COLOR", "BOTH"]}, 139 | "entries": [ 140 | ["ShaderNodeMix", { 141 | "label": "Mix Color", 142 | "settings": {"data_type": "RGBA"}, 143 | "subtypes": ["blend_type"] 144 | } 145 | ] 146 | ] 147 | }, 148 | "mix_rgb": { 149 | "poll": "check_mix_color_alias", 150 | "poll_args": { "valid_options": ["MIX_RGB", "BOTH"]}, 151 | "entries": [ 152 | ["ShaderNodeMix", { 153 | "label": "Mix RGB", 154 | "settings": {"data_type": "RGBA"}, 155 | "subtypes": ["blend_type"] 156 | } 157 | ] 158 | ] 159 | }, 160 | "world_shader_nodes": { 161 | "poll": "engine_and_shader_type_poll", 162 | "poll_args": {"shader_types": "WORLD"}, 163 | "entries": [ 164 | "ShaderNodeOutputWorld", 165 | "ShaderNodeBackground" 166 | ] 167 | }, 168 | "line_style_shader_nodes": { 169 | "poll": "engine_and_shader_type_poll", 170 | "poll_args": {"shader_types": "LINESTYLE"}, 171 | "entries": [ 172 | "ShaderNodeUVAlongStroke", 173 | "ShaderNodeOutputLineStyle" 174 | ] 175 | }, 176 | "cycles_eevee_shader_nodes": { 177 | "poll": "engine_and_shader_type_poll", 178 | "poll_args": { 179 | "engines": [ 180 | "CYCLES", 181 | "BLENDER_EEVEE" 182 | ] 183 | }, 184 | "entries": [ 185 | "ShaderNodeAddShader", 186 | "ShaderNodeEmission", 187 | "ShaderNodeMixShader", 188 | "ShaderNodeVolumeAbsorption", 189 | "ShaderNodeVolumeScatter" 190 | ] 191 | }, 192 | "object_cycles_shader_nodes": { 193 | "poll": "engine_and_shader_type_poll", 194 | "poll_args": {"shader_types": "OBJECT", "engines": "CYCLES"}, 195 | "entries": [ 196 | "ShaderNodeOutputLight", 197 | "ShaderNodeBsdfHair", 198 | "ShaderNodeBsdfHairPrincipled", 199 | ["ShaderNodeBsdfToon", {"subtypes": ["component"]}] 200 | ] 201 | }, 202 | "object_eevee_shader_nodes": { 203 | "poll": "engine_and_shader_type_poll", 204 | "poll_args": {"shader_types": "OBJECT", "engines": "BLENDER_EEVEE"}, 205 | "entries": [ 206 | "ShaderNodeShaderToRGB", 207 | "ShaderNodeEeveeSpecular" 208 | ] 209 | }, 210 | "object_cycles_eevee_shader_nodes": { 211 | "poll": "engine_and_shader_type_poll", 212 | "poll_args": { 213 | "shader_types": "OBJECT", 214 | "engines": [ 215 | "CYCLES", 216 | "BLENDER_EEVEE" 217 | ] 218 | }, 219 | "entries": [ 220 | "ShaderNodeOutputMaterial", 221 | "ShaderNodeBsdfDiffuse", 222 | ["ShaderNodeBsdfGlass", {"subtypes": ["distribution"]}], 223 | ["ShaderNodeBsdfAnisotropic", {"subtypes": ["distribution"]}], 224 | ["ShaderNodeBsdfGlossy", {"subtypes": ["distribution"]}], 225 | "ShaderNodeHoldout", 226 | "ShaderNodeBsdfPrincipled", 227 | ["ShaderNodeBsdfRefraction", {"subtypes": ["distribution"]}], 228 | ["ShaderNodeSubsurfaceScattering", {"subtypes": ["falloff"]}], 229 | "ShaderNodeBsdfTranslucent", 230 | "ShaderNodeBsdfTransparent" 231 | ] 232 | }, 233 | "frame_and_reroute": { 234 | "entries": [ 235 | "NodeFrame", 236 | "NodeReroute" 237 | ] 238 | } 239 | } -------------------------------------------------------------------------------- /source/nodelists/3.6/TextureNodeTree.json: -------------------------------------------------------------------------------- 1 | { 2 | "items": { 3 | "entries": [ 4 | "TextureNodeCoordinates", 5 | "TextureNodeCurveTime", 6 | "TextureNodeImage", 7 | "TextureNodeTexture", 8 | "TextureNodeOutput", 9 | "TextureNodeViewer", 10 | "TextureNodeHueSaturation", 11 | "TextureNodeInvert", 12 | "TextureNodeCurveRGB", 13 | "TextureNodeValToRGB", 14 | "TextureNodeDistance", 15 | "TextureNodeRGBToBW", 16 | "TextureNodeValToNor", 17 | "TextureNodeAt", 18 | "TextureNodeRotate", 19 | "TextureNodeScale", 20 | "TextureNodeTranslate", 21 | "TextureNodeBricks", 22 | "TextureNodeChecker", 23 | "TextureNodeTexBlend", 24 | "TextureNodeTexClouds", 25 | "TextureNodeTexDistNoise", 26 | "TextureNodeTexMagic", 27 | "TextureNodeTexMarble", 28 | "TextureNodeTexMusgrave", 29 | "TextureNodeTexNoise", 30 | "TextureNodeTexStucci", 31 | "TextureNodeTexVoronoi", 32 | "TextureNodeTexWood" 33 | ] 34 | }, 35 | "basic_subtypes": { 36 | "entries": [ 37 | ["TextureNodeMath", {"subtypes": ["operation"]}], 38 | ["TextureNodeCombineColor", {"subtypes": ["mode"]}], 39 | ["TextureNodeSeparateColor", {"subtypes": ["mode"]}] 40 | ] 41 | }, 42 | "mix_color": { 43 | "poll": "check_mix_color_alias", 44 | "poll_args": { 45 | "valid_options": ["MIX_COLOR", "BOTH"] 46 | }, 47 | "entries": [ 48 | ["TextureNodeMixRGB", {"label": "Mix Color", "subtypes": ["blend_type"]}] 49 | ] 50 | }, 51 | "mix_rgb": { 52 | "poll": "check_mix_color_alias", 53 | "poll_args": { 54 | "valid_options": ["DEFAULT", "MIX_RGB", "BOTH"] 55 | }, 56 | "entries": [ 57 | ["TextureNodeMixRGB", {"subtypes": ["blend_type"]}] 58 | ] 59 | }, 60 | "group_nodes": { 61 | "poll": "in_nodegroup", 62 | "entries": [ 63 | "NodeGroupInput", 64 | "NodeGroupOutput" 65 | ] 66 | }, 67 | "frame_and_reroute": { 68 | "entries": [ 69 | "NodeFrame", 70 | "NodeReroute" 71 | ] 72 | } 73 | } -------------------------------------------------------------------------------- /source/nodelists/4.0/CompositorNodeTree.json: -------------------------------------------------------------------------------- 1 | { 2 | "items": { 3 | "entries": [ 4 | "CompositorNodeBokehImage", 5 | "CompositorNodeImage", 6 | "CompositorNodeMask", 7 | "CompositorNodeMovieClip", 8 | "CompositorNodeTexture", 9 | "CompositorNodeRGB", 10 | "CompositorNodeValue", 11 | "CompositorNodeRLayers", 12 | "CompositorNodeSceneTime", 13 | "CompositorNodeTime", 14 | "CompositorNodeComposite", 15 | "CompositorNodeViewer", 16 | "CompositorNodeOutputFile", 17 | "CompositorNodeValToRGB", 18 | "CompositorNodeConvertColorSpace", 19 | "CompositorNodeInvert", 20 | "CompositorNodeRGBToBW", 21 | "CompositorNodeBrightContrast", 22 | "CompositorNodeColorCorrection", 23 | "CompositorNodeExposure", 24 | "CompositorNodeGamma", 25 | "CompositorNodeHueCorrect", 26 | "CompositorNodeHueSat", 27 | "CompositorNodeCurveRGB", 28 | "CompositorNodeAlphaOver", 29 | "CompositorNodeZcombine", 30 | "CompositorNodeAntiAliasing", 31 | "CompositorNodeDespeckle", 32 | "CompositorNodeInpaint", 33 | "CompositorNodePixelate", 34 | "CompositorNodePosterize", 35 | "CompositorNodeSunBeams", 36 | "CompositorNodeBilateralblur", 37 | "CompositorNodeBokehBlur", 38 | "CompositorNodeDBlur", 39 | "CompositorNodeVecBlur", 40 | "CompositorNodeChannelMatte", 41 | "CompositorNodeChromaMatte", 42 | "CompositorNodeColorMatte", 43 | "CompositorNodeColorSpill", 44 | "CompositorNodeDiffMatte", 45 | "CompositorNodeKeying", 46 | "CompositorNodeKeyingScreen", 47 | "CompositorNodeLumaMatte", 48 | "CompositorNodeCryptomatte", 49 | "CompositorNodeBoxMask", 50 | "CompositorNodeEllipseMask", 51 | "CompositorNodeDoubleEdgeMask", 52 | "CompositorNodeIDMask", 53 | "CompositorNodePlaneTrackDeform", 54 | "CompositorNodeStabilize", 55 | "CompositorNodeTrackPos", 56 | "CompositorNodeCornerPin", 57 | "CompositorNodeCrop", 58 | "CompositorNodeDisplace", 59 | "CompositorNodeMapUV", 60 | "CompositorNodeLensdist", 61 | "CompositorNodeMapRange", 62 | "CompositorNodeMapValue", 63 | "CompositorNodeNormalize", 64 | "CompositorNodeSwitch", 65 | "CompositorNodeCombineXYZ", 66 | "CompositorNodeSeparateXYZ", 67 | "CompositorNodeNormal", 68 | "CompositorNodeCurveVec" 69 | ] 70 | }, 71 | "combine_and_separate_color": { 72 | "entries": [ 73 | ["CompositorNodeCombineColor", {"subtypes": ["mode"]}], 74 | ["CompositorNodeCombineColor", { 75 | "only_subtypes" : true, 76 | "subtypes": [ 77 | {"name": "mode", "only_include": ["YCbCr"]}, 78 | "ycc_mode" 79 | ] 80 | } 81 | ], 82 | ["CompositorNodeSeparateColor", {"subtypes": ["mode"]}], 83 | ["CompositorNodeSeparateColor", { 84 | "only_subtypes" : true, 85 | "subtypes": [ 86 | {"name": "mode", "only_include": ["YCbCr"]}, 87 | "ycc_mode" 88 | ] 89 | } 90 | ] 91 | ] 92 | }, 93 | "specific_types": { 94 | "entries": [ 95 | ["CompositorNodeSwitchView", {"label": "Switch Stereo View"}] 96 | ] 97 | }, 98 | "basic_subtypes": { 99 | "entries": [ 100 | ["CompositorNodePremulKey", {"subtypes": ["mapping"]}], 101 | ["CompositorNodeColorBalance", {"subtypes": ["correction_method"]}], 102 | ["CompositorNodeCryptomatteV2", {"subtypes": ["source"]}], 103 | ["CompositorNodeDistanceMatte", {"subtypes": ["channel"]}], 104 | ["CompositorNodeMovieDistortion", {"subtypes": ["distortion_type"]}], 105 | ["CompositorNodeSetAlpha", {"subtypes": ["mode"]}], 106 | ["CompositorNodeDefocus", {"subtypes": ["bokeh"]}], 107 | ["CompositorNodeDenoise", {"subtypes": ["prefilter"]}], 108 | ["CompositorNodeDilateErode", {"subtypes": ["mode"]}], 109 | ["CompositorNodeDilateErode", { 110 | "only_subtypes": true, 111 | "subtypes": [ 112 | {"name": "mode", "only_include": ["Feather"]}, 113 | "falloff" 114 | ] 115 | } 116 | ], 117 | ["CompositorNodeGlare", {"subtypes": ["glare_type"]}], 118 | ["CompositorNodeRotate", {"subtypes": ["filter_type"]}], 119 | ["CompositorNodeScale", {"subtypes": ["space"]}], 120 | ["CompositorNodeScale", { 121 | "only_subtypes": true, 122 | "subtypes": [ 123 | {"name": "space", "only_include": ["Render Size"]}, 124 | "frame_method" 125 | ] 126 | } 127 | ], 128 | ["CompositorNodeTransform", {"subtypes": ["filter_type"]}], 129 | ["CompositorNodeTranslate", {"subtypes": ["wrap_axis"]}], 130 | ["CompositorNodeFlip", {"subtypes": ["axis"]}], 131 | ["CompositorNodeBlur", {"subtypes": ["filter_type"]}], 132 | ["CompositorNodeKuwahara", {"subtypes": ["variation"]}], 133 | ["CompositorNodeLevels", {"subtypes": ["channel"]}], 134 | ["CompositorNodeMath", {"subtypes": ["operation"]}], 135 | ["CompositorNodeFilter", {"subtypes": ["filter_type"]}], 136 | ["CompositorNodeSplitViewer", {"subtypes": ["axis"]}], 137 | ["CompositorNodeTonemap", {"subtypes": ["tonemap_type"]}] 138 | ] 139 | }, 140 | "mix_color": { 141 | "poll": "check_mix_color_alias", 142 | "poll_args": {"valid_options": ["DEFAULT", "MIX_COLOR", "BOTH"]}, 143 | "entries": [ 144 | ["CompositorNodeMixRGB", {"label": "Mix Color", "subtypes": ["blend_type"]}] 145 | ] 146 | }, 147 | "mix_rgb": { 148 | "poll": "check_mix_color_alias", 149 | "poll_args": { "valid_options": ["MIX_RGB", "BOTH"]}, 150 | "entries": [ 151 | ["CompositorNodeMixRGB", {"label": "Mix RGB", "subtypes": ["blend_type"]}] 152 | ] 153 | }, 154 | "group_nodes": { 155 | "poll": "in_nodegroup", 156 | "entries": [ 157 | "NodeGroupInput", 158 | "NodeGroupOutput" 159 | ] 160 | }, 161 | "frame_and_reroute": { 162 | "entries": [ 163 | "NodeFrame", 164 | "NodeReroute" 165 | ] 166 | } 167 | } -------------------------------------------------------------------------------- /source/nodelists/4.0/ShaderNodeTree.json: -------------------------------------------------------------------------------- 1 | { 2 | "items": { 3 | "entries": [ 4 | "ShaderNodeAddShader", 5 | "ShaderNodeEmission", 6 | "ShaderNodeMixShader", 7 | "ShaderNodeAmbientOcclusion", 8 | "ShaderNodeAttribute", 9 | "ShaderNodeBevel", 10 | "ShaderNodeCameraData", 11 | "ShaderNodeVertexColor", 12 | "ShaderNodeHairInfo", 13 | "ShaderNodeFresnel", 14 | "ShaderNodeNewGeometry", 15 | "ShaderNodeLayerWeight", 16 | "ShaderNodeLightPath", 17 | "ShaderNodeObjectInfo", 18 | "ShaderNodeParticleInfo", 19 | "ShaderNodePointInfo", 20 | "ShaderNodeRGB", 21 | "ShaderNodeTangent", 22 | "ShaderNodeTexCoord", 23 | "ShaderNodeUVMap", 24 | "ShaderNodeValue", 25 | "ShaderNodeVolumeInfo", 26 | "ShaderNodeWireframe", 27 | "ShaderNodeOutputAOV", 28 | "ShaderNodeVolumePrincipled", 29 | "ShaderNodeBrightContrast", 30 | "ShaderNodeGamma", 31 | "ShaderNodeHueSaturation", 32 | "ShaderNodeInvert", 33 | "ShaderNodeLightFalloff", 34 | "ShaderNodeRGBCurve", 35 | "ShaderNodeBlackbody", 36 | "ShaderNodeValToRGB", 37 | "ShaderNodeCombineXYZ", 38 | "ShaderNodeFloatCurve", 39 | "ShaderNodeRGBToBW", 40 | "ShaderNodeSeparateXYZ", 41 | "ShaderNodeWavelength", 42 | "ShaderNodeTexBrick", 43 | "ShaderNodeTexChecker", 44 | "ShaderNodeTexEnvironment", 45 | "ShaderNodeTexImage", 46 | "ShaderNodeTexMagic", 47 | "ShaderNodeTexPointDensity", 48 | "ShaderNodeBump", 49 | "ShaderNodeNormal", 50 | "ShaderNodeVectorCurve", 51 | "ShaderNodeVectorTransform", 52 | "ShaderNodeVolumeAbsorption", 53 | "ShaderNodeVolumeScatter" 54 | ] 55 | }, 56 | "specific_types": { 57 | "entries": [ 58 | "ShaderNodeMix", 59 | ["ShaderNodeMix", {"label": "Mix Vector", "settings": {"data_type": "VECTOR"}, "subtypes": ["factor_mode"]}], 60 | "ShaderNodeMapRange", 61 | ["ShaderNodeMapRange", { 62 | "label": "Map Range - Float", 63 | "settings": {"data_type": "FLOAT"}, 64 | "subtypes": ["interpolation_type"] 65 | } 66 | ], 67 | ["ShaderNodeMapRange", { 68 | "label": "Map Range - Vector", 69 | "settings": {"data_type": "FLOAT_VECTOR"}, 70 | "subtypes": ["interpolation_type"] 71 | } 72 | ] 73 | ] 74 | }, 75 | "basic_subtypes": { 76 | "entries": [ 77 | ["ShaderNodeClamp", {"subtypes": ["clamp_type"]}], 78 | ["ShaderNodeMath", {"subtypes": ["operation"]}], 79 | ["ShaderNodeVectorMath", {"subtypes": ["operation"]}], 80 | ["ShaderNodeVectorRotate", {"subtypes": ["rotation_type"]}], 81 | ["ShaderNodeCombineColor", {"subtypes": ["mode"]}], 82 | ["ShaderNodeSeparateColor", {"subtypes": ["mode"]}], 83 | ["ShaderNodeNormalMap", {"subtypes": ["space"]}], 84 | ["ShaderNodeDisplacement", {"subtypes": ["space"]}], 85 | ["ShaderNodeVectorDisplacement", {"subtypes": ["space"]}], 86 | ["ShaderNodeScript", {"subtypes": ["mode"]}], 87 | ["ShaderNodeMapping", {"subtypes": ["vector_type"]}] 88 | ] 89 | }, 90 | "texture_subtypes": { 91 | "entries": [ 92 | ["ShaderNodeTexSky", {"subtypes": ["sky_type"]}], 93 | ["ShaderNodeTexIES", {"subtypes": ["mode"]}], 94 | ["ShaderNodeTexGradient", {"subtypes": ["gradient_type"]}], 95 | ["ShaderNodeTexMusgrave", {"subtypes": ["musgrave_type", "musgrave_dimensions"]}], 96 | "ShaderNodeTexVoronoi", 97 | ["ShaderNodeTexVoronoi", { 98 | "only_subtypes": true, 99 | "subtypes": [ 100 | {"name": "voronoi_dimensions", "only_include": ["1D"]} 101 | ] 102 | } 103 | ], 104 | ["ShaderNodeTexVoronoi", { 105 | "only_subtypes": true, 106 | "subtypes": [ 107 | "distance", {"name": "voronoi_dimensions", "only_include": ["2D", "3D", "4D"]} 108 | ] 109 | } 110 | ], 111 | ["ShaderNodeTexNoise", {"subtypes": ["noise_dimensions"]}], 112 | ["ShaderNodeTexWhiteNoise", {"subtypes": ["noise_dimensions"]}], 113 | "ShaderNodeTexWave", 114 | ["ShaderNodeTexWave", { 115 | "only_subtypes": true, 116 | "subtypes": [ 117 | {"name": "bands_direction", "only_include": ["X", "Y", "Z", "Diagonal"]}, 118 | "wave_profile", 119 | {"name": "wave_type", "only_include": "Bands"} 120 | ] 121 | } 122 | ], 123 | ["ShaderNodeTexWave", { 124 | "only_subtypes": true, 125 | "subtypes": [ 126 | {"name": "rings_direction", "only_include": ["X", "Y", "Z", "Spherical"]}, 127 | "wave_profile", 128 | {"name": "wave_type", "only_include": "Rings"} 129 | ] 130 | } 131 | ] 132 | ] 133 | }, 134 | "group_nodes": { 135 | "poll": "in_nodegroup", 136 | "entries": [ 137 | "NodeGroupInput", 138 | "NodeGroupOutput" 139 | ] 140 | }, 141 | "mix_color": { 142 | "poll": "check_mix_color_alias", 143 | "poll_args": {"valid_options": ["DEFAULT", "MIX_COLOR", "BOTH"]}, 144 | "entries": [ 145 | ["ShaderNodeMix", { 146 | "label": "Mix Color", 147 | "settings": {"data_type": "RGBA"}, 148 | "subtypes": ["blend_type"] 149 | } 150 | ] 151 | ] 152 | }, 153 | "mix_rgb": { 154 | "poll": "check_mix_color_alias", 155 | "poll_args": { "valid_options": ["MIX_RGB", "BOTH"]}, 156 | "entries": [ 157 | ["ShaderNodeMix", { 158 | "label": "Mix RGB", 159 | "settings": {"data_type": "RGBA"}, 160 | "subtypes": ["blend_type"] 161 | } 162 | ] 163 | ] 164 | }, 165 | "world_shader_nodes": { 166 | "poll": "engine_and_shader_type_poll", 167 | "poll_args": {"shader_types": "WORLD"}, 168 | "entries": [ 169 | "ShaderNodeOutputWorld", 170 | "ShaderNodeBackground" 171 | ] 172 | }, 173 | "line_style_shader_nodes": { 174 | "poll": "engine_and_shader_type_poll", 175 | "poll_args": {"shader_types": "LINESTYLE"}, 176 | "entries": [ 177 | "ShaderNodeUVAlongStroke", 178 | "ShaderNodeOutputLineStyle" 179 | ] 180 | }, 181 | "object_not_eevee_shader_nodes": { 182 | "poll": "engine_and_shader_type_poll", 183 | "poll_args": {"shader_types": "OBJECT", "exclude_engines": "BLENDER_EEVEE"}, 184 | "entries": [ 185 | "ShaderNodeOutputLight", 186 | "ShaderNodeBsdfHair", 187 | "ShaderNodeBsdfHairPrincipled", 188 | ["ShaderNodeBsdfSheen", {"subtypes": ["distribution"]}], 189 | ["ShaderNodeBsdfToon", {"subtypes": ["component"]}] 190 | ] 191 | }, 192 | "object_eevee_shader_nodes": { 193 | "poll": "engine_and_shader_type_poll", 194 | "poll_args": {"shader_types": "OBJECT", "engines": "BLENDER_EEVEE"}, 195 | "entries": [ 196 | "ShaderNodeShaderToRGB", 197 | "ShaderNodeEeveeSpecular" 198 | ] 199 | }, 200 | "object_shader_nodes": { 201 | "poll": "engine_and_shader_type_poll", 202 | "poll_args": {"shader_types": "OBJECT"}, 203 | "entries": [ 204 | "ShaderNodeOutputMaterial", 205 | "ShaderNodeBsdfDiffuse", 206 | ["ShaderNodeBsdfGlass", {"subtypes": ["distribution"]}], 207 | ["ShaderNodeBsdfAnisotropic", {"subtypes": ["distribution"]}], 208 | "ShaderNodeHoldout", 209 | "ShaderNodeBsdfPrincipled", 210 | ["ShaderNodeBsdfRefraction", {"subtypes": ["distribution"]}], 211 | ["ShaderNodeSubsurfaceScattering", {"subtypes": ["falloff"]}], 212 | "ShaderNodeBsdfTranslucent", 213 | "ShaderNodeBsdfTransparent" 214 | ] 215 | }, 216 | "frame_and_reroute": { 217 | "entries": [ 218 | "NodeFrame", 219 | "NodeReroute" 220 | ] 221 | } 222 | } -------------------------------------------------------------------------------- /source/nodelists/4.0/TextureNodeTree.json: -------------------------------------------------------------------------------- 1 | { 2 | "items": { 3 | "entries": [ 4 | "TextureNodeCoordinates", 5 | "TextureNodeCurveTime", 6 | "TextureNodeImage", 7 | "TextureNodeTexture", 8 | "TextureNodeOutput", 9 | "TextureNodeViewer", 10 | "TextureNodeHueSaturation", 11 | "TextureNodeInvert", 12 | "TextureNodeCurveRGB", 13 | "TextureNodeValToRGB", 14 | "TextureNodeDistance", 15 | "TextureNodeRGBToBW", 16 | "TextureNodeValToNor", 17 | "TextureNodeAt", 18 | "TextureNodeRotate", 19 | "TextureNodeScale", 20 | "TextureNodeTranslate", 21 | "TextureNodeBricks", 22 | "TextureNodeChecker", 23 | "TextureNodeTexBlend", 24 | "TextureNodeTexClouds", 25 | "TextureNodeTexDistNoise", 26 | "TextureNodeTexMagic", 27 | "TextureNodeTexMarble", 28 | "TextureNodeTexMusgrave", 29 | "TextureNodeTexNoise", 30 | "TextureNodeTexStucci", 31 | "TextureNodeTexVoronoi", 32 | "TextureNodeTexWood" 33 | ] 34 | }, 35 | "basic_subtypes": { 36 | "entries": [ 37 | ["TextureNodeMath", {"subtypes": ["operation"]}], 38 | ["TextureNodeCombineColor", {"subtypes": ["mode"]}], 39 | ["TextureNodeSeparateColor", {"subtypes": ["mode"]}] 40 | ] 41 | }, 42 | "mix_color": { 43 | "poll": "check_mix_color_alias", 44 | "poll_args": { 45 | "valid_options": ["MIX_COLOR", "BOTH"] 46 | }, 47 | "entries": [ 48 | ["TextureNodeMixRGB", {"label": "Mix Color", "subtypes": ["blend_type"]}] 49 | ] 50 | }, 51 | "mix_rgb": { 52 | "poll": "check_mix_color_alias", 53 | "poll_args": { 54 | "valid_options": ["DEFAULT", "MIX_RGB", "BOTH"] 55 | }, 56 | "entries": [ 57 | ["TextureNodeMixRGB", {"subtypes": ["blend_type"]}] 58 | ] 59 | }, 60 | "group_nodes": { 61 | "poll": "in_nodegroup", 62 | "entries": [ 63 | "NodeGroupInput", 64 | "NodeGroupOutput" 65 | ] 66 | }, 67 | "frame_and_reroute": { 68 | "entries": [ 69 | "NodeFrame", 70 | "NodeReroute" 71 | ] 72 | } 73 | } -------------------------------------------------------------------------------- /source/nodelists/4.1/CompositorNodeTree.json: -------------------------------------------------------------------------------- 1 | { 2 | "items": { 3 | "entries": [ 4 | "CompositorNodeBokehImage", 5 | "CompositorNodeImage", 6 | "CompositorNodeMask", 7 | "CompositorNodeMovieClip", 8 | "CompositorNodeTexture", 9 | "CompositorNodeRGB", 10 | "CompositorNodeValue", 11 | "CompositorNodeRLayers", 12 | "CompositorNodeSceneTime", 13 | "CompositorNodeTime", 14 | "CompositorNodeComposite", 15 | "CompositorNodeViewer", 16 | "CompositorNodeOutputFile", 17 | "CompositorNodeValToRGB", 18 | "CompositorNodeConvertColorSpace", 19 | "CompositorNodeInvert", 20 | "CompositorNodeRGBToBW", 21 | "CompositorNodeBrightContrast", 22 | "CompositorNodeColorCorrection", 23 | "CompositorNodeExposure", 24 | "CompositorNodeGamma", 25 | "CompositorNodeHueCorrect", 26 | "CompositorNodeHueSat", 27 | "CompositorNodeCurveRGB", 28 | "CompositorNodeAlphaOver", 29 | "CompositorNodeZcombine", 30 | "CompositorNodeAntiAliasing", 31 | "CompositorNodeDespeckle", 32 | "CompositorNodeInpaint", 33 | "CompositorNodePixelate", 34 | "CompositorNodePosterize", 35 | "CompositorNodeSunBeams", 36 | "CompositorNodeBilateralblur", 37 | "CompositorNodeBokehBlur", 38 | "CompositorNodeDBlur", 39 | "CompositorNodeVecBlur", 40 | "CompositorNodeChannelMatte", 41 | "CompositorNodeChromaMatte", 42 | "CompositorNodeColorMatte", 43 | "CompositorNodeColorSpill", 44 | "CompositorNodeDiffMatte", 45 | "CompositorNodeKeying", 46 | "CompositorNodeKeyingScreen", 47 | "CompositorNodeLumaMatte", 48 | "CompositorNodeCryptomatte", 49 | "CompositorNodeBoxMask", 50 | "CompositorNodeEllipseMask", 51 | "CompositorNodeDoubleEdgeMask", 52 | "CompositorNodeIDMask", 53 | "CompositorNodePlaneTrackDeform", 54 | "CompositorNodeStabilize", 55 | "CompositorNodeTrackPos", 56 | "CompositorNodeCornerPin", 57 | "CompositorNodeCrop", 58 | "CompositorNodeDisplace", 59 | "CompositorNodeMapUV", 60 | "CompositorNodeLensdist", 61 | "CompositorNodeMapRange", 62 | "CompositorNodeMapValue", 63 | "CompositorNodeNormalize", 64 | "CompositorNodeSwitch", 65 | "CompositorNodeCombineXYZ", 66 | "CompositorNodeSeparateXYZ", 67 | "CompositorNodeNormal", 68 | "CompositorNodeCurveVec" 69 | ] 70 | }, 71 | "combine_and_separate_color": { 72 | "entries": [ 73 | ["CompositorNodeCombineColor", {"subtypes": ["mode"]}], 74 | ["CompositorNodeCombineColor", { 75 | "only_subtypes" : true, 76 | "subtypes": [ 77 | {"name": "mode", "only_include": ["YCbCr"]}, 78 | "ycc_mode" 79 | ] 80 | } 81 | ], 82 | ["CompositorNodeSeparateColor", {"subtypes": ["mode"]}], 83 | ["CompositorNodeSeparateColor", { 84 | "only_subtypes" : true, 85 | "subtypes": [ 86 | {"name": "mode", "only_include": ["YCbCr"]}, 87 | "ycc_mode" 88 | ] 89 | } 90 | ] 91 | ] 92 | }, 93 | "specific_types": { 94 | "entries": [ 95 | ["CompositorNodeSwitchView", {"label": "Switch Stereo View"}] 96 | ] 97 | }, 98 | "basic_subtypes": { 99 | "entries": [ 100 | ["CompositorNodePremulKey", {"subtypes": ["mapping"]}], 101 | ["CompositorNodeColorBalance", {"subtypes": ["correction_method"]}], 102 | ["CompositorNodeCryptomatteV2", {"subtypes": ["source"]}], 103 | ["CompositorNodeDistanceMatte", {"subtypes": ["channel"]}], 104 | ["CompositorNodeMovieDistortion", {"subtypes": ["distortion_type"]}], 105 | ["CompositorNodeSetAlpha", {"subtypes": ["mode"]}], 106 | ["CompositorNodeDefocus", {"subtypes": ["bokeh"]}], 107 | ["CompositorNodeDenoise", {"subtypes": ["prefilter"]}], 108 | ["CompositorNodeDilateErode", {"subtypes": ["mode"]}], 109 | ["CompositorNodeDilateErode", { 110 | "only_subtypes": true, 111 | "subtypes": [ 112 | {"name": "mode", "only_include": ["Feather"]}, 113 | "falloff" 114 | ] 115 | } 116 | ], 117 | ["CompositorNodeGlare", {"subtypes": ["glare_type"]}], 118 | ["CompositorNodeRotate", {"subtypes": ["filter_type"]}], 119 | ["CompositorNodeScale", {"subtypes": ["space"]}], 120 | ["CompositorNodeScale", { 121 | "only_subtypes": true, 122 | "subtypes": [ 123 | {"name": "space", "only_include": ["Render Size"]}, 124 | "frame_method" 125 | ] 126 | } 127 | ], 128 | ["CompositorNodeTransform", {"subtypes": ["filter_type"]}], 129 | ["CompositorNodeTranslate", {"subtypes": ["wrap_axis"]}], 130 | ["CompositorNodeFlip", {"subtypes": ["axis"]}], 131 | ["CompositorNodeBlur", {"subtypes": ["filter_type"]}], 132 | ["CompositorNodeKuwahara", {"subtypes": ["variation"]}], 133 | ["CompositorNodeLevels", {"subtypes": ["channel"]}], 134 | ["CompositorNodeMath", {"subtypes": ["operation"]}], 135 | ["CompositorNodeFilter", {"subtypes": ["filter_type"]}], 136 | ["CompositorNodeSplit", {"subtypes": ["axis"]}], 137 | ["CompositorNodeTonemap", {"subtypes": ["tonemap_type"]}] 138 | ] 139 | }, 140 | "mix_color": { 141 | "poll": "check_mix_color_alias", 142 | "poll_args": {"valid_options": ["DEFAULT", "MIX_COLOR", "BOTH"]}, 143 | "entries": [ 144 | ["CompositorNodeMixRGB", {"label": "Mix Color", "subtypes": ["blend_type"]}] 145 | ] 146 | }, 147 | "mix_rgb": { 148 | "poll": "check_mix_color_alias", 149 | "poll_args": { "valid_options": ["MIX_RGB", "BOTH"]}, 150 | "entries": [ 151 | ["CompositorNodeMixRGB", {"label": "Mix RGB", "subtypes": ["blend_type"]}] 152 | ] 153 | }, 154 | "group_nodes": { 155 | "poll": "in_nodegroup", 156 | "entries": [ 157 | "NodeGroupInput", 158 | "NodeGroupOutput" 159 | ] 160 | }, 161 | "frame_and_reroute": { 162 | "entries": [ 163 | "NodeFrame", 164 | "NodeReroute" 165 | ] 166 | } 167 | } -------------------------------------------------------------------------------- /source/nodelists/4.1/ShaderNodeTree.json: -------------------------------------------------------------------------------- 1 | { 2 | "items": { 3 | "entries": [ 4 | "ShaderNodeAddShader", 5 | "ShaderNodeEmission", 6 | "ShaderNodeMixShader", 7 | "ShaderNodeAmbientOcclusion", 8 | "ShaderNodeAttribute", 9 | "ShaderNodeBevel", 10 | "ShaderNodeCameraData", 11 | "ShaderNodeVertexColor", 12 | "ShaderNodeHairInfo", 13 | "ShaderNodeFresnel", 14 | "ShaderNodeNewGeometry", 15 | "ShaderNodeLayerWeight", 16 | "ShaderNodeLightPath", 17 | "ShaderNodeObjectInfo", 18 | "ShaderNodeParticleInfo", 19 | "ShaderNodePointInfo", 20 | "ShaderNodeRGB", 21 | "ShaderNodeTangent", 22 | "ShaderNodeTexCoord", 23 | "ShaderNodeUVMap", 24 | "ShaderNodeValue", 25 | "ShaderNodeVolumeInfo", 26 | "ShaderNodeWireframe", 27 | "ShaderNodeOutputAOV", 28 | "ShaderNodeVolumePrincipled", 29 | "ShaderNodeBrightContrast", 30 | "ShaderNodeGamma", 31 | "ShaderNodeHueSaturation", 32 | "ShaderNodeInvert", 33 | "ShaderNodeLightFalloff", 34 | "ShaderNodeRGBCurve", 35 | "ShaderNodeBlackbody", 36 | "ShaderNodeValToRGB", 37 | "ShaderNodeCombineXYZ", 38 | "ShaderNodeFloatCurve", 39 | "ShaderNodeRGBToBW", 40 | "ShaderNodeSeparateXYZ", 41 | "ShaderNodeWavelength", 42 | "ShaderNodeTexBrick", 43 | "ShaderNodeTexChecker", 44 | "ShaderNodeTexEnvironment", 45 | "ShaderNodeTexImage", 46 | "ShaderNodeTexMagic", 47 | "ShaderNodeTexPointDensity", 48 | "ShaderNodeBump", 49 | "ShaderNodeNormal", 50 | "ShaderNodeVectorCurve", 51 | "ShaderNodeVectorTransform", 52 | "ShaderNodeVolumeAbsorption", 53 | "ShaderNodeVolumeScatter" 54 | ] 55 | }, 56 | "specific_types": { 57 | "entries": [ 58 | "ShaderNodeMix", 59 | ["ShaderNodeMix", {"label": "Mix Vector", "settings": {"data_type": "VECTOR"}, "subtypes": ["factor_mode"]}], 60 | "ShaderNodeMapRange", 61 | ["ShaderNodeMapRange", { 62 | "label": "Map Range - Float", 63 | "settings": {"data_type": "FLOAT"}, 64 | "subtypes": ["interpolation_type"] 65 | } 66 | ], 67 | ["ShaderNodeMapRange", { 68 | "label": "Map Range - Vector", 69 | "settings": {"data_type": "FLOAT_VECTOR"}, 70 | "subtypes": ["interpolation_type"] 71 | } 72 | ] 73 | ] 74 | }, 75 | "basic_subtypes": { 76 | "entries": [ 77 | ["ShaderNodeClamp", {"subtypes": ["clamp_type"]}], 78 | ["ShaderNodeMath", {"subtypes": ["operation"]}], 79 | ["ShaderNodeVectorMath", {"subtypes": ["operation"]}], 80 | ["ShaderNodeVectorRotate", {"subtypes": ["rotation_type"]}], 81 | ["ShaderNodeCombineColor", {"subtypes": ["mode"]}], 82 | ["ShaderNodeSeparateColor", {"subtypes": ["mode"]}], 83 | ["ShaderNodeNormalMap", {"subtypes": ["space"]}], 84 | ["ShaderNodeDisplacement", {"subtypes": ["space"]}], 85 | ["ShaderNodeVectorDisplacement", {"subtypes": ["space"]}], 86 | ["ShaderNodeScript", {"subtypes": ["mode"]}], 87 | ["ShaderNodeMapping", {"subtypes": ["vector_type"]}] 88 | ] 89 | }, 90 | "texture_subtypes": { 91 | "entries": [ 92 | ["ShaderNodeTexSky", {"subtypes": ["sky_type"]}], 93 | ["ShaderNodeTexIES", {"subtypes": ["mode"]}], 94 | ["ShaderNodeTexGradient", {"subtypes": ["gradient_type"]}], 95 | "ShaderNodeTexVoronoi", 96 | ["ShaderNodeTexVoronoi", { 97 | "only_subtypes": true, 98 | "subtypes": [ 99 | {"name": "voronoi_dimensions", "only_include": ["1D"]} 100 | ] 101 | } 102 | ], 103 | ["ShaderNodeTexVoronoi", { 104 | "only_subtypes": true, 105 | "subtypes": [ 106 | "distance", {"name": "voronoi_dimensions", "only_include": ["2D", "3D", "4D"]} 107 | ] 108 | } 109 | ], 110 | ["ShaderNodeTexNoise", {"subtypes": ["noise_dimensions"]}], 111 | ["ShaderNodeTexNoise", {"only_subtypes": true, "subtypes": ["noise_dimensions", "noise_type"]}], 112 | ["ShaderNodeTexWhiteNoise", {"subtypes": ["noise_dimensions"]}], 113 | "ShaderNodeTexWave", 114 | ["ShaderNodeTexWave", { 115 | "only_subtypes": true, 116 | "subtypes": [ 117 | {"name": "bands_direction", "only_include": ["X", "Y", "Z", "Diagonal"]}, 118 | "wave_profile", 119 | {"name": "wave_type", "only_include": "Bands"} 120 | ] 121 | } 122 | ], 123 | ["ShaderNodeTexWave", { 124 | "only_subtypes": true, 125 | "subtypes": [ 126 | {"name": "rings_direction", "only_include": ["X", "Y", "Z", "Spherical"]}, 127 | "wave_profile", 128 | {"name": "wave_type", "only_include": "Rings"} 129 | ] 130 | } 131 | ] 132 | ] 133 | }, 134 | "group_nodes": { 135 | "poll": "in_nodegroup", 136 | "entries": [ 137 | "NodeGroupInput", 138 | "NodeGroupOutput" 139 | ] 140 | }, 141 | "mix_color": { 142 | "poll": "check_mix_color_alias", 143 | "poll_args": {"valid_options": ["DEFAULT", "MIX_COLOR", "BOTH"]}, 144 | "entries": [ 145 | ["ShaderNodeMix", { 146 | "label": "Mix Color", 147 | "settings": {"data_type": "RGBA"}, 148 | "subtypes": ["blend_type"] 149 | } 150 | ] 151 | ] 152 | }, 153 | "mix_rgb": { 154 | "poll": "check_mix_color_alias", 155 | "poll_args": { "valid_options": ["MIX_RGB", "BOTH"]}, 156 | "entries": [ 157 | ["ShaderNodeMix", { 158 | "label": "Mix RGB", 159 | "settings": {"data_type": "RGBA"}, 160 | "subtypes": ["blend_type"] 161 | } 162 | ] 163 | ] 164 | }, 165 | "world_shader_nodes": { 166 | "poll": "engine_and_shader_type_poll", 167 | "poll_args": {"shader_types": "WORLD"}, 168 | "entries": [ 169 | "ShaderNodeOutputWorld", 170 | "ShaderNodeBackground" 171 | ] 172 | }, 173 | "line_style_shader_nodes": { 174 | "poll": "engine_and_shader_type_poll", 175 | "poll_args": {"shader_types": "LINESTYLE"}, 176 | "entries": [ 177 | "ShaderNodeUVAlongStroke", 178 | "ShaderNodeOutputLineStyle" 179 | ] 180 | }, 181 | "object_not_eevee_shader_nodes": { 182 | "poll": "engine_and_shader_type_poll", 183 | "poll_args": {"shader_types": "OBJECT", "exclude_engines": "BLENDER_EEVEE"}, 184 | "entries": [ 185 | "ShaderNodeOutputLight", 186 | "ShaderNodeBsdfHair", 187 | "ShaderNodeBsdfHairPrincipled", 188 | ["ShaderNodeBsdfSheen", {"subtypes": ["distribution"]}], 189 | ["ShaderNodeBsdfToon", {"subtypes": ["component"]}] 190 | ] 191 | }, 192 | "object_eevee_shader_nodes": { 193 | "poll": "engine_and_shader_type_poll", 194 | "poll_args": {"shader_types": "OBJECT", "engines": "BLENDER_EEVEE"}, 195 | "entries": [ 196 | "ShaderNodeShaderToRGB", 197 | "ShaderNodeEeveeSpecular" 198 | ] 199 | }, 200 | "object_shader_nodes": { 201 | "poll": "engine_and_shader_type_poll", 202 | "poll_args": {"shader_types": "OBJECT"}, 203 | "entries": [ 204 | "ShaderNodeOutputMaterial", 205 | "ShaderNodeBsdfDiffuse", 206 | ["ShaderNodeBsdfGlass", {"subtypes": ["distribution"]}], 207 | 208 | ["ShaderNodeBsdfAnisotropic", {"subtypes": ["distribution"]}], 209 | "ShaderNodeHoldout", 210 | "ShaderNodeBsdfPrincipled", 211 | ["ShaderNodeBsdfRefraction", {"subtypes": ["distribution"]}], 212 | ["ShaderNodeSubsurfaceScattering", {"subtypes": ["falloff"]}], 213 | "ShaderNodeBsdfTranslucent", 214 | "ShaderNodeBsdfTransparent" 215 | ] 216 | }, 217 | "frame_and_reroute": { 218 | "entries": [ 219 | "NodeFrame", 220 | "NodeReroute" 221 | ] 222 | } 223 | } -------------------------------------------------------------------------------- /source/nodelists/4.1/TextureNodeTree.json: -------------------------------------------------------------------------------- 1 | { 2 | "items": { 3 | "entries": [ 4 | "TextureNodeCoordinates", 5 | "TextureNodeCurveTime", 6 | "TextureNodeImage", 7 | "TextureNodeTexture", 8 | "TextureNodeOutput", 9 | "TextureNodeViewer", 10 | "TextureNodeHueSaturation", 11 | "TextureNodeInvert", 12 | "TextureNodeCurveRGB", 13 | "TextureNodeValToRGB", 14 | "TextureNodeDistance", 15 | "TextureNodeRGBToBW", 16 | "TextureNodeValToNor", 17 | "TextureNodeAt", 18 | "TextureNodeRotate", 19 | "TextureNodeScale", 20 | "TextureNodeTranslate", 21 | "TextureNodeBricks", 22 | "TextureNodeChecker", 23 | "TextureNodeTexBlend", 24 | "TextureNodeTexClouds", 25 | "TextureNodeTexDistNoise", 26 | "TextureNodeTexMagic", 27 | "TextureNodeTexMarble", 28 | "TextureNodeTexMusgrave", 29 | "TextureNodeTexNoise", 30 | "TextureNodeTexStucci", 31 | "TextureNodeTexVoronoi", 32 | "TextureNodeTexWood" 33 | ] 34 | }, 35 | "basic_subtypes": { 36 | "entries": [ 37 | ["TextureNodeMath", {"subtypes": ["operation"]}], 38 | ["TextureNodeCombineColor", {"subtypes": ["mode"]}], 39 | ["TextureNodeSeparateColor", {"subtypes": ["mode"]}] 40 | ] 41 | }, 42 | "mix_color": { 43 | "poll": "check_mix_color_alias", 44 | "poll_args": { 45 | "valid_options": ["MIX_COLOR", "BOTH"] 46 | }, 47 | "entries": [ 48 | ["TextureNodeMixRGB", {"label": "Mix Color", "subtypes": ["blend_type"]}] 49 | ] 50 | }, 51 | "mix_rgb": { 52 | "poll": "check_mix_color_alias", 53 | "poll_args": { 54 | "valid_options": ["DEFAULT", "MIX_RGB", "BOTH"] 55 | }, 56 | "entries": [ 57 | ["TextureNodeMixRGB", {"subtypes": ["blend_type"]}] 58 | ] 59 | }, 60 | "group_nodes": { 61 | "poll": "in_nodegroup", 62 | "entries": [ 63 | "NodeGroupInput", 64 | "NodeGroupOutput" 65 | ] 66 | }, 67 | "frame_and_reroute": { 68 | "entries": [ 69 | "NodeFrame", 70 | "NodeReroute" 71 | ] 72 | } 73 | } -------------------------------------------------------------------------------- /source/nodelists/4.2/CompositorNodeTree.json: -------------------------------------------------------------------------------- 1 | { 2 | "items": { 3 | "entries": [ 4 | "CompositorNodeBokehImage", 5 | "CompositorNodeImage", 6 | "CompositorNodeMask", 7 | "CompositorNodeMovieClip", 8 | "CompositorNodeTexture", 9 | "CompositorNodeRGB", 10 | "CompositorNodeValue", 11 | "CompositorNodeRLayers", 12 | "CompositorNodeSceneTime", 13 | "CompositorNodeTime", 14 | "CompositorNodeComposite", 15 | "CompositorNodeViewer", 16 | "CompositorNodeOutputFile", 17 | "CompositorNodeValToRGB", 18 | "CompositorNodeConvertColorSpace", 19 | "CompositorNodeInvert", 20 | "CompositorNodeRGBToBW", 21 | "CompositorNodeBrightContrast", 22 | "CompositorNodeColorCorrection", 23 | "CompositorNodeExposure", 24 | "CompositorNodeGamma", 25 | "CompositorNodeHueCorrect", 26 | "CompositorNodeHueSat", 27 | "CompositorNodeCurveRGB", 28 | "CompositorNodeAlphaOver", 29 | "CompositorNodeZcombine", 30 | "CompositorNodeAntiAliasing", 31 | "CompositorNodeDespeckle", 32 | "CompositorNodeInpaint", 33 | "CompositorNodePixelate", 34 | "CompositorNodePosterize", 35 | "CompositorNodeSunBeams", 36 | "CompositorNodeBilateralblur", 37 | "CompositorNodeBokehBlur", 38 | "CompositorNodeDBlur", 39 | "CompositorNodeVecBlur", 40 | "CompositorNodeChannelMatte", 41 | "CompositorNodeChromaMatte", 42 | "CompositorNodeColorMatte", 43 | "CompositorNodeColorSpill", 44 | "CompositorNodeDiffMatte", 45 | "CompositorNodeKeying", 46 | "CompositorNodeKeyingScreen", 47 | "CompositorNodeLumaMatte", 48 | "CompositorNodeCryptomatte", 49 | "CompositorNodeBoxMask", 50 | "CompositorNodeEllipseMask", 51 | "CompositorNodeDoubleEdgeMask", 52 | "CompositorNodeIDMask", 53 | "CompositorNodePlaneTrackDeform", 54 | "CompositorNodeStabilize", 55 | "CompositorNodeTrackPos", 56 | "CompositorNodeCornerPin", 57 | "CompositorNodeCrop", 58 | "CompositorNodeDisplace", 59 | "CompositorNodeMapUV", 60 | "CompositorNodeLensdist", 61 | "CompositorNodeMapRange", 62 | "CompositorNodeMapValue", 63 | "CompositorNodeNormalize", 64 | "CompositorNodeSwitch", 65 | "CompositorNodeCombineXYZ", 66 | "CompositorNodeSeparateXYZ", 67 | "CompositorNodeNormal", 68 | "CompositorNodeCurveVec" 69 | ] 70 | }, 71 | "combine_and_separate_color": { 72 | "entries": [ 73 | ["CompositorNodeCombineColor", {"subtypes": ["mode"]}], 74 | ["CompositorNodeCombineColor", { 75 | "only_subtypes" : true, 76 | "subtypes": [ 77 | {"name": "mode", "only_include": ["YCbCr"]}, 78 | "ycc_mode" 79 | ] 80 | } 81 | ], 82 | ["CompositorNodeSeparateColor", {"subtypes": ["mode"]}], 83 | ["CompositorNodeSeparateColor", { 84 | "only_subtypes" : true, 85 | "subtypes": [ 86 | {"name": "mode", "only_include": ["YCbCr"]}, 87 | "ycc_mode" 88 | ] 89 | } 90 | ] 91 | ] 92 | }, 93 | "specific_types": { 94 | "entries": [ 95 | ["CompositorNodeSwitchView", {"label": "Switch Stereo View"}] 96 | ] 97 | }, 98 | "basic_subtypes": { 99 | "entries": [ 100 | ["CompositorNodePremulKey", {"subtypes": ["mapping"]}], 101 | ["CompositorNodeColorBalance", {"subtypes": ["correction_method"]}], 102 | ["CompositorNodeCryptomatteV2", {"subtypes": ["source"]}], 103 | ["CompositorNodeDistanceMatte", {"subtypes": ["channel"]}], 104 | ["CompositorNodeMovieDistortion", {"subtypes": ["distortion_type"]}], 105 | ["CompositorNodeSetAlpha", {"subtypes": ["mode"]}], 106 | ["CompositorNodeDefocus", {"subtypes": ["bokeh"]}], 107 | ["CompositorNodeDenoise", {"subtypes": ["prefilter"]}], 108 | ["CompositorNodeDilateErode", {"subtypes": ["mode"]}], 109 | ["CompositorNodeDilateErode", { 110 | "only_subtypes": true, 111 | "subtypes": [ 112 | {"name": "mode", "only_include": ["Feather"]}, 113 | "falloff" 114 | ] 115 | } 116 | ], 117 | ["CompositorNodeGlare", {"subtypes": ["glare_type"]}], 118 | ["CompositorNodeRotate", {"subtypes": ["filter_type"]}], 119 | ["CompositorNodeScale", {"subtypes": ["space"]}], 120 | ["CompositorNodeScale", { 121 | "only_subtypes": true, 122 | "subtypes": [ 123 | {"name": "space", "only_include": ["Render Size"]}, 124 | "frame_method" 125 | ] 126 | } 127 | ], 128 | ["CompositorNodeTransform", {"subtypes": ["filter_type"]}], 129 | ["CompositorNodeTranslate", {"subtypes": ["wrap_axis"]}], 130 | ["CompositorNodeFlip", {"subtypes": ["axis"]}], 131 | ["CompositorNodeBlur", {"subtypes": ["filter_type"]}], 132 | ["CompositorNodeKuwahara", {"subtypes": ["variation"]}], 133 | ["CompositorNodeLevels", {"subtypes": ["channel"]}], 134 | ["CompositorNodeMath", {"subtypes": ["operation"]}], 135 | ["CompositorNodeFilter", {"subtypes": ["filter_type"]}], 136 | ["CompositorNodeSplit", {"subtypes": ["axis"]}], 137 | ["CompositorNodeTonemap", {"subtypes": ["tonemap_type"]}] 138 | ] 139 | }, 140 | "mix_color": { 141 | "poll": "check_mix_color_alias", 142 | "poll_args": {"valid_options": ["DEFAULT", "MIX_COLOR", "BOTH"]}, 143 | "entries": [ 144 | ["CompositorNodeMixRGB", {"label": "Mix Color", "subtypes": ["blend_type"]}] 145 | ] 146 | }, 147 | "mix_rgb": { 148 | "poll": "check_mix_color_alias", 149 | "poll_args": { "valid_options": ["MIX_RGB", "BOTH"]}, 150 | "entries": [ 151 | ["CompositorNodeMixRGB", {"label": "Mix RGB", "subtypes": ["blend_type"]}] 152 | ] 153 | }, 154 | "group_nodes": { 155 | "poll": "in_nodegroup", 156 | "entries": [ 157 | "NodeGroupInput", 158 | "NodeGroupOutput" 159 | ] 160 | }, 161 | "frame_and_reroute": { 162 | "entries": [ 163 | "NodeFrame", 164 | "NodeReroute" 165 | ] 166 | } 167 | } -------------------------------------------------------------------------------- /source/nodelists/4.2/ShaderNodeTree.json: -------------------------------------------------------------------------------- 1 | { 2 | "items": { 3 | "entries": [ 4 | "ShaderNodeAddShader", 5 | "ShaderNodeEmission", 6 | "ShaderNodeMixShader", 7 | "ShaderNodeAmbientOcclusion", 8 | "ShaderNodeAttribute", 9 | "ShaderNodeBevel", 10 | "ShaderNodeCameraData", 11 | "ShaderNodeVertexColor", 12 | "ShaderNodeHairInfo", 13 | "ShaderNodeFresnel", 14 | "ShaderNodeNewGeometry", 15 | "ShaderNodeLayerWeight", 16 | "ShaderNodeLightPath", 17 | "ShaderNodeObjectInfo", 18 | "ShaderNodeParticleInfo", 19 | "ShaderNodePointInfo", 20 | "ShaderNodeRGB", 21 | "ShaderNodeTangent", 22 | "ShaderNodeTexCoord", 23 | "ShaderNodeUVMap", 24 | "ShaderNodeValue", 25 | "ShaderNodeVolumeInfo", 26 | "ShaderNodeWireframe", 27 | "ShaderNodeOutputAOV", 28 | "ShaderNodeVolumePrincipled", 29 | "ShaderNodeBrightContrast", 30 | "ShaderNodeGamma", 31 | "ShaderNodeHueSaturation", 32 | "ShaderNodeInvert", 33 | "ShaderNodeLightFalloff", 34 | "ShaderNodeRGBCurve", 35 | "ShaderNodeBlackbody", 36 | "ShaderNodeValToRGB", 37 | "ShaderNodeCombineXYZ", 38 | "ShaderNodeFloatCurve", 39 | "ShaderNodeRGBToBW", 40 | "ShaderNodeSeparateXYZ", 41 | "ShaderNodeWavelength", 42 | "ShaderNodeTexBrick", 43 | "ShaderNodeTexChecker", 44 | "ShaderNodeTexEnvironment", 45 | "ShaderNodeTexImage", 46 | "ShaderNodeTexMagic", 47 | "ShaderNodeTexPointDensity", 48 | "ShaderNodeBump", 49 | "ShaderNodeNormal", 50 | "ShaderNodeVectorCurve", 51 | "ShaderNodeVectorTransform", 52 | "ShaderNodeVolumeAbsorption", 53 | "ShaderNodeVolumeScatter" 54 | ] 55 | }, 56 | "specific_types": { 57 | "entries": [ 58 | "ShaderNodeMix", 59 | ["ShaderNodeMix", {"label": "Mix Vector", "settings": {"data_type": "VECTOR"}, "subtypes": ["factor_mode"]}], 60 | "ShaderNodeMapRange", 61 | ["ShaderNodeMapRange", { 62 | "label": "Map Range - Float", 63 | "settings": {"data_type": "FLOAT"}, 64 | "subtypes": ["interpolation_type"] 65 | } 66 | ], 67 | ["ShaderNodeMapRange", { 68 | "label": "Map Range - Vector", 69 | "settings": {"data_type": "FLOAT_VECTOR"}, 70 | "subtypes": ["interpolation_type"] 71 | } 72 | ] 73 | ] 74 | }, 75 | "basic_subtypes": { 76 | "entries": [ 77 | ["ShaderNodeClamp", {"subtypes": ["clamp_type"]}], 78 | ["ShaderNodeMath", {"subtypes": ["operation"]}], 79 | ["ShaderNodeVectorMath", {"subtypes": ["operation"]}], 80 | ["ShaderNodeVectorRotate", {"subtypes": ["rotation_type"]}], 81 | ["ShaderNodeCombineColor", {"subtypes": ["mode"]}], 82 | ["ShaderNodeSeparateColor", {"subtypes": ["mode"]}], 83 | ["ShaderNodeNormalMap", {"subtypes": ["space"]}], 84 | ["ShaderNodeDisplacement", {"subtypes": ["space"]}], 85 | ["ShaderNodeVectorDisplacement", {"subtypes": ["space"]}], 86 | ["ShaderNodeScript", {"subtypes": ["mode"]}], 87 | ["ShaderNodeMapping", {"subtypes": ["vector_type"]}] 88 | ] 89 | }, 90 | "texture_subtypes": { 91 | "entries": [ 92 | ["ShaderNodeTexSky", {"subtypes": ["sky_type"]}], 93 | ["ShaderNodeTexIES", {"subtypes": ["mode"]}], 94 | ["ShaderNodeTexGradient", {"subtypes": ["gradient_type"]}], 95 | "ShaderNodeTexVoronoi", 96 | ["ShaderNodeTexVoronoi", { 97 | "only_subtypes": true, 98 | "subtypes": [ 99 | {"name": "voronoi_dimensions", "only_include": ["1D"]} 100 | ] 101 | } 102 | ], 103 | ["ShaderNodeTexVoronoi", { 104 | "only_subtypes": true, 105 | "subtypes": [ 106 | "distance", {"name": "voronoi_dimensions", "only_include": ["2D", "3D", "4D"]} 107 | ] 108 | } 109 | ], 110 | ["ShaderNodeTexNoise", {"subtypes": ["noise_dimensions"]}], 111 | ["ShaderNodeTexNoise", {"only_subtypes": true, "subtypes": ["noise_dimensions", "noise_type"]}], 112 | ["ShaderNodeTexWhiteNoise", {"subtypes": ["noise_dimensions"]}], 113 | "ShaderNodeTexWave", 114 | ["ShaderNodeTexWave", { 115 | "only_subtypes": true, 116 | "subtypes": [ 117 | {"name": "bands_direction", "only_include": ["X", "Y", "Z", "Diagonal"]}, 118 | "wave_profile", 119 | {"name": "wave_type", "only_include": "Bands"} 120 | ] 121 | } 122 | ], 123 | ["ShaderNodeTexWave", { 124 | "only_subtypes": true, 125 | "subtypes": [ 126 | {"name": "rings_direction", "only_include": ["X", "Y", "Z", "Spherical"]}, 127 | "wave_profile", 128 | {"name": "wave_type", "only_include": "Rings"} 129 | ] 130 | } 131 | ] 132 | ] 133 | }, 134 | "group_nodes": { 135 | "poll": "in_nodegroup", 136 | "entries": [ 137 | "NodeGroupInput", 138 | "NodeGroupOutput" 139 | ] 140 | }, 141 | "mix_color": { 142 | "poll": "check_mix_color_alias", 143 | "poll_args": {"valid_options": ["DEFAULT", "MIX_COLOR", "BOTH"]}, 144 | "entries": [ 145 | ["ShaderNodeMix", { 146 | "label": "Mix Color", 147 | "settings": {"data_type": "RGBA"}, 148 | "subtypes": ["blend_type"] 149 | } 150 | ] 151 | ] 152 | }, 153 | "mix_rgb": { 154 | "poll": "check_mix_color_alias", 155 | "poll_args": { "valid_options": ["MIX_RGB", "BOTH"]}, 156 | "entries": [ 157 | ["ShaderNodeMix", { 158 | "label": "Mix RGB", 159 | "settings": {"data_type": "RGBA"}, 160 | "subtypes": ["blend_type"] 161 | } 162 | ] 163 | ] 164 | }, 165 | "world_shader_nodes": { 166 | "poll": "engine_and_shader_type_poll", 167 | "poll_args": {"shader_types": "WORLD"}, 168 | "entries": [ 169 | "ShaderNodeOutputWorld", 170 | "ShaderNodeBackground" 171 | ] 172 | }, 173 | "line_style_shader_nodes": { 174 | "poll": "engine_and_shader_type_poll", 175 | "poll_args": {"shader_types": "LINESTYLE"}, 176 | "entries": [ 177 | "ShaderNodeUVAlongStroke", 178 | "ShaderNodeOutputLineStyle" 179 | ] 180 | }, 181 | "object_not_eevee_shader_nodes": { 182 | "poll": "engine_and_shader_type_poll", 183 | "poll_args": {"shader_types": "OBJECT", "exclude_engines": "BLENDER_EEVEE_NEXT"}, 184 | "entries": [ 185 | "ShaderNodeOutputLight", 186 | "ShaderNodeBsdfHair", 187 | "ShaderNodeBsdfHairPrincipled", 188 | ["ShaderNodeBsdfSheen", {"subtypes": ["distribution"]}], 189 | ["ShaderNodeBsdfToon", {"subtypes": ["component"]}], 190 | "ShaderNodeBsdfRayPortal" 191 | ] 192 | }, 193 | "object_eevee_shader_nodes": { 194 | "poll": "engine_and_shader_type_poll", 195 | "poll_args": {"shader_types": "OBJECT", "engines": "BLENDER_EEVEE_NEXT"}, 196 | "entries": [ 197 | "ShaderNodeShaderToRGB", 198 | "ShaderNodeEeveeSpecular" 199 | ] 200 | }, 201 | "object_shader_nodes": { 202 | "poll": "engine_and_shader_type_poll", 203 | "poll_args": {"shader_types": "OBJECT"}, 204 | "entries": [ 205 | "ShaderNodeOutputMaterial", 206 | "ShaderNodeBsdfDiffuse", 207 | ["ShaderNodeBsdfGlass", {"subtypes": ["distribution"]}], 208 | ["ShaderNodeBsdfAnisotropic", {"subtypes": ["distribution"]}], 209 | "ShaderNodeHoldout", 210 | "ShaderNodeBsdfPrincipled", 211 | ["ShaderNodeBsdfRefraction", {"subtypes": ["distribution"]}], 212 | ["ShaderNodeSubsurfaceScattering", {"subtypes": ["falloff"]}], 213 | "ShaderNodeBsdfTranslucent", 214 | "ShaderNodeBsdfTransparent" 215 | ] 216 | }, 217 | "frame_and_reroute": { 218 | "entries": [ 219 | "NodeFrame", 220 | "NodeReroute" 221 | ] 222 | } 223 | } -------------------------------------------------------------------------------- /source/nodelists/4.2/TextureNodeTree.json: -------------------------------------------------------------------------------- 1 | { 2 | "items": { 3 | "entries": [ 4 | "TextureNodeCoordinates", 5 | "TextureNodeCurveTime", 6 | "TextureNodeImage", 7 | "TextureNodeTexture", 8 | "TextureNodeOutput", 9 | "TextureNodeViewer", 10 | "TextureNodeHueSaturation", 11 | "TextureNodeInvert", 12 | "TextureNodeCurveRGB", 13 | "TextureNodeValToRGB", 14 | "TextureNodeDistance", 15 | "TextureNodeRGBToBW", 16 | "TextureNodeValToNor", 17 | "TextureNodeAt", 18 | "TextureNodeRotate", 19 | "TextureNodeScale", 20 | "TextureNodeTranslate", 21 | "TextureNodeBricks", 22 | "TextureNodeChecker", 23 | "TextureNodeTexBlend", 24 | "TextureNodeTexClouds", 25 | "TextureNodeTexDistNoise", 26 | "TextureNodeTexMagic", 27 | "TextureNodeTexMarble", 28 | "TextureNodeTexMusgrave", 29 | "TextureNodeTexNoise", 30 | "TextureNodeTexStucci", 31 | "TextureNodeTexVoronoi", 32 | "TextureNodeTexWood" 33 | ] 34 | }, 35 | "basic_subtypes": { 36 | "entries": [ 37 | ["TextureNodeMath", {"subtypes": ["operation"]}], 38 | ["TextureNodeCombineColor", {"subtypes": ["mode"]}], 39 | ["TextureNodeSeparateColor", {"subtypes": ["mode"]}] 40 | ] 41 | }, 42 | "mix_color": { 43 | "poll": "check_mix_color_alias", 44 | "poll_args": { 45 | "valid_options": ["MIX_COLOR", "BOTH"] 46 | }, 47 | "entries": [ 48 | ["TextureNodeMixRGB", {"label": "Mix Color", "subtypes": ["blend_type"]}] 49 | ] 50 | }, 51 | "mix_rgb": { 52 | "poll": "check_mix_color_alias", 53 | "poll_args": { 54 | "valid_options": ["DEFAULT", "MIX_RGB", "BOTH"] 55 | }, 56 | "entries": [ 57 | ["TextureNodeMixRGB", {"subtypes": ["blend_type"]}] 58 | ] 59 | }, 60 | "group_nodes": { 61 | "poll": "in_nodegroup", 62 | "entries": [ 63 | "NodeGroupInput", 64 | "NodeGroupOutput" 65 | ] 66 | }, 67 | "frame_and_reroute": { 68 | "entries": [ 69 | "NodeFrame", 70 | "NodeReroute" 71 | ] 72 | } 73 | } -------------------------------------------------------------------------------- /source/nodelists/4.3/CompositorNodeTree.json: -------------------------------------------------------------------------------- 1 | { 2 | "items": { 3 | "entries": [ 4 | "CompositorNodeBokehImage", 5 | "CompositorNodeImage", 6 | "CompositorNodeMask", 7 | "CompositorNodeMovieClip", 8 | "CompositorNodeTexture", 9 | "CompositorNodeRGB", 10 | "CompositorNodeValue", 11 | "CompositorNodeRLayers", 12 | "CompositorNodeSceneTime", 13 | "CompositorNodeTime", 14 | "CompositorNodeComposite", 15 | "CompositorNodeViewer", 16 | "CompositorNodeOutputFile", 17 | "CompositorNodeValToRGB", 18 | "CompositorNodeConvertColorSpace", 19 | "CompositorNodeInvert", 20 | "CompositorNodeRGBToBW", 21 | "CompositorNodeBrightContrast", 22 | "CompositorNodeColorCorrection", 23 | "CompositorNodeExposure", 24 | "CompositorNodeGamma", 25 | "CompositorNodeHueCorrect", 26 | "CompositorNodeHueSat", 27 | "CompositorNodeCurveRGB", 28 | "CompositorNodeAlphaOver", 29 | "CompositorNodeZcombine", 30 | "CompositorNodeAntiAliasing", 31 | "CompositorNodeDespeckle", 32 | "CompositorNodeInpaint", 33 | "CompositorNodePixelate", 34 | "CompositorNodePosterize", 35 | "CompositorNodeSunBeams", 36 | "CompositorNodeBilateralblur", 37 | "CompositorNodeBokehBlur", 38 | "CompositorNodeDBlur", 39 | "CompositorNodeVecBlur", 40 | "CompositorNodeChannelMatte", 41 | "CompositorNodeChromaMatte", 42 | "CompositorNodeColorMatte", 43 | "CompositorNodeColorSpill", 44 | "CompositorNodeDiffMatte", 45 | "CompositorNodeKeying", 46 | "CompositorNodeKeyingScreen", 47 | "CompositorNodeLumaMatte", 48 | "CompositorNodeCryptomatte", 49 | "CompositorNodeBoxMask", 50 | "CompositorNodeEllipseMask", 51 | "CompositorNodeDoubleEdgeMask", 52 | "CompositorNodeIDMask", 53 | "CompositorNodePlaneTrackDeform", 54 | "CompositorNodeStabilize", 55 | "CompositorNodeTrackPos", 56 | "CompositorNodeCornerPin", 57 | "CompositorNodeCrop", 58 | "CompositorNodeDisplace", 59 | "CompositorNodeMapUV", 60 | "CompositorNodeLensdist", 61 | "CompositorNodeMapRange", 62 | "CompositorNodeMapValue", 63 | "CompositorNodeNormalize", 64 | "CompositorNodeSwitch", 65 | "CompositorNodeCombineXYZ", 66 | "CompositorNodeSeparateXYZ", 67 | "CompositorNodeNormal", 68 | "CompositorNodeCurveVec" 69 | ] 70 | }, 71 | "combine_and_separate_color": { 72 | "entries": [ 73 | ["CompositorNodeCombineColor", {"subtypes": ["mode"]}], 74 | ["CompositorNodeCombineColor", { 75 | "only_subtypes" : true, 76 | "subtypes": [ 77 | {"name": "mode", "only_include": ["YCbCr"]}, 78 | "ycc_mode" 79 | ] 80 | } 81 | ], 82 | ["CompositorNodeSeparateColor", {"subtypes": ["mode"]}], 83 | ["CompositorNodeSeparateColor", { 84 | "only_subtypes" : true, 85 | "subtypes": [ 86 | {"name": "mode", "only_include": ["YCbCr"]}, 87 | "ycc_mode" 88 | ] 89 | } 90 | ] 91 | ] 92 | }, 93 | "specific_types": { 94 | "entries": [ 95 | ["CompositorNodeSwitchView", {"label": "Switch Stereo View"}] 96 | ] 97 | }, 98 | "basic_subtypes": { 99 | "entries": [ 100 | ["CompositorNodePremulKey", {"subtypes": ["mapping"]}], 101 | ["CompositorNodeColorBalance", {"subtypes": ["correction_method"]}], 102 | ["CompositorNodeCryptomatteV2", {"subtypes": ["source"]}], 103 | ["CompositorNodeDistanceMatte", {"subtypes": ["channel"]}], 104 | ["CompositorNodeMovieDistortion", {"subtypes": ["distortion_type"]}], 105 | ["CompositorNodeSetAlpha", {"subtypes": ["mode"]}], 106 | ["CompositorNodeDefocus", {"subtypes": ["bokeh"]}], 107 | ["CompositorNodeDenoise", {"subtypes": ["prefilter"]}], 108 | ["CompositorNodeDilateErode", {"subtypes": ["mode"]}], 109 | ["CompositorNodeDilateErode", { 110 | "only_subtypes": true, 111 | "subtypes": [ 112 | {"name": "mode", "only_include": ["Feather"]}, 113 | "falloff" 114 | ] 115 | } 116 | ], 117 | ["CompositorNodeGlare", {"subtypes": ["glare_type"]}], 118 | ["CompositorNodeRotate", {"subtypes": ["filter_type"]}], 119 | ["CompositorNodeScale", {"subtypes": ["space"]}], 120 | ["CompositorNodeScale", { 121 | "only_subtypes": true, 122 | "subtypes": [ 123 | {"name": "space", "only_include": ["Render Size"]}, 124 | "frame_method" 125 | ] 126 | } 127 | ], 128 | ["CompositorNodeTransform", {"subtypes": ["filter_type"]}], 129 | ["CompositorNodeTranslate", {"subtypes": ["wrap_axis"]}], 130 | ["CompositorNodeFlip", {"subtypes": ["axis"]}], 131 | ["CompositorNodeBlur", {"subtypes": ["filter_type"]}], 132 | ["CompositorNodeKuwahara", {"subtypes": ["variation"]}], 133 | ["CompositorNodeLevels", {"subtypes": ["channel"]}], 134 | ["CompositorNodeMath", {"subtypes": ["operation"]}], 135 | ["CompositorNodeFilter", {"subtypes": ["filter_type"]}], 136 | ["CompositorNodeSplit", {"subtypes": ["axis"]}], 137 | ["CompositorNodeTonemap", {"subtypes": ["tonemap_type"]}] 138 | ] 139 | }, 140 | "mix_color": { 141 | "poll": "check_mix_color_alias", 142 | "poll_args": {"valid_options": ["DEFAULT", "MIX_COLOR", "BOTH"]}, 143 | "entries": [ 144 | ["CompositorNodeMixRGB", {"label": "Mix Color", "subtypes": ["blend_type"]}] 145 | ] 146 | }, 147 | "mix_rgb": { 148 | "poll": "check_mix_color_alias", 149 | "poll_args": { "valid_options": ["MIX_RGB", "BOTH"]}, 150 | "entries": [ 151 | ["CompositorNodeMixRGB", {"label": "Mix RGB", "subtypes": ["blend_type"]}] 152 | ] 153 | }, 154 | "group_nodes": { 155 | "poll": "in_nodegroup", 156 | "entries": [ 157 | "NodeGroupInput", 158 | "NodeGroupOutput" 159 | ] 160 | }, 161 | "frame_and_reroute": { 162 | "entries": [ 163 | "NodeFrame", 164 | "NodeReroute" 165 | ] 166 | } 167 | } -------------------------------------------------------------------------------- /source/nodelists/4.3/ShaderNodeTree.json: -------------------------------------------------------------------------------- 1 | { 2 | "items": { 3 | "entries": [ 4 | "ShaderNodeAddShader", 5 | "ShaderNodeEmission", 6 | "ShaderNodeMixShader", 7 | "ShaderNodeAmbientOcclusion", 8 | "ShaderNodeAttribute", 9 | "ShaderNodeBevel", 10 | "ShaderNodeCameraData", 11 | "ShaderNodeVertexColor", 12 | "ShaderNodeHairInfo", 13 | "ShaderNodeFresnel", 14 | "ShaderNodeNewGeometry", 15 | "ShaderNodeLayerWeight", 16 | "ShaderNodeLightPath", 17 | "ShaderNodeObjectInfo", 18 | "ShaderNodeParticleInfo", 19 | "ShaderNodePointInfo", 20 | "ShaderNodeRGB", 21 | "ShaderNodeTangent", 22 | "ShaderNodeTexCoord", 23 | "ShaderNodeUVMap", 24 | "ShaderNodeValue", 25 | "ShaderNodeVolumeInfo", 26 | "ShaderNodeWireframe", 27 | "ShaderNodeOutputAOV", 28 | "ShaderNodeVolumePrincipled", 29 | "ShaderNodeBrightContrast", 30 | "ShaderNodeGamma", 31 | "ShaderNodeHueSaturation", 32 | "ShaderNodeInvert", 33 | "ShaderNodeLightFalloff", 34 | "ShaderNodeRGBCurve", 35 | "ShaderNodeBlackbody", 36 | "ShaderNodeValToRGB", 37 | "ShaderNodeCombineXYZ", 38 | "ShaderNodeFloatCurve", 39 | "ShaderNodeRGBToBW", 40 | "ShaderNodeSeparateXYZ", 41 | "ShaderNodeWavelength", 42 | "ShaderNodeTexBrick", 43 | "ShaderNodeTexChecker", 44 | "ShaderNodeTexEnvironment", 45 | "ShaderNodeTexImage", 46 | "ShaderNodeTexMagic", 47 | "ShaderNodeTexPointDensity", 48 | "ShaderNodeBump", 49 | "ShaderNodeNormal", 50 | "ShaderNodeVectorCurve", 51 | "ShaderNodeVectorTransform", 52 | "ShaderNodeVolumeAbsorption" 53 | ] 54 | }, 55 | "specific_types": { 56 | "entries": [ 57 | "ShaderNodeMix", 58 | ["ShaderNodeMix", {"label": "Mix Vector", "settings": {"data_type": "VECTOR"}, "subtypes": ["factor_mode"]}], 59 | "ShaderNodeMapRange", 60 | ["ShaderNodeMapRange", { 61 | "label": "Map Range - Float", 62 | "settings": {"data_type": "FLOAT"}, 63 | "subtypes": ["interpolation_type"] 64 | } 65 | ], 66 | ["ShaderNodeMapRange", { 67 | "label": "Map Range - Vector", 68 | "settings": {"data_type": "FLOAT_VECTOR"}, 69 | "subtypes": ["interpolation_type"] 70 | } 71 | ] 72 | ] 73 | }, 74 | "basic_subtypes": { 75 | "entries": [ 76 | ["ShaderNodeClamp", {"subtypes": ["clamp_type"]}], 77 | ["ShaderNodeMath", {"subtypes": ["operation"]}], 78 | ["ShaderNodeVectorMath", {"subtypes": ["operation"]}], 79 | ["ShaderNodeVectorRotate", {"subtypes": ["rotation_type"]}], 80 | ["ShaderNodeCombineColor", {"subtypes": ["mode"]}], 81 | ["ShaderNodeSeparateColor", {"subtypes": ["mode"]}], 82 | ["ShaderNodeNormalMap", {"subtypes": ["space"]}], 83 | ["ShaderNodeDisplacement", {"subtypes": ["space"]}], 84 | ["ShaderNodeVectorDisplacement", {"subtypes": ["space"]}], 85 | ["ShaderNodeScript", {"subtypes": ["mode"]}], 86 | ["ShaderNodeMapping", {"subtypes": ["vector_type"]}], 87 | ["ShaderNodeVolumeScatter", {"subtypes": ["phase"]}] 88 | ] 89 | }, 90 | "texture_subtypes": { 91 | "entries": [ 92 | ["ShaderNodeTexSky", {"subtypes": ["sky_type"]}], 93 | ["ShaderNodeTexIES", {"subtypes": ["mode"]}], 94 | ["ShaderNodeTexGradient", {"subtypes": ["gradient_type"]}], 95 | "ShaderNodeTexVoronoi", 96 | ["ShaderNodeTexVoronoi", { 97 | "only_subtypes": true, 98 | "subtypes": [ 99 | {"name": "voronoi_dimensions", "only_include": ["1D"]} 100 | ] 101 | } 102 | ], 103 | ["ShaderNodeTexVoronoi", { 104 | "only_subtypes": true, 105 | "subtypes": [ 106 | "distance", {"name": "voronoi_dimensions", "only_include": ["2D", "3D", "4D"]} 107 | ] 108 | } 109 | ], 110 | ["ShaderNodeTexNoise", {"subtypes": ["noise_dimensions"]}], 111 | ["ShaderNodeTexNoise", {"only_subtypes": true, "subtypes": ["noise_dimensions", "noise_type"]}], 112 | ["ShaderNodeTexWhiteNoise", {"subtypes": ["noise_dimensions"]}], 113 | "ShaderNodeTexWave", 114 | ["ShaderNodeTexWave", { 115 | "only_subtypes": true, 116 | "subtypes": [ 117 | {"name": "bands_direction", "only_include": ["X", "Y", "Z", "Diagonal"]}, 118 | "wave_profile", 119 | {"name": "wave_type", "only_include": "Bands"} 120 | ] 121 | } 122 | ], 123 | ["ShaderNodeTexWave", { 124 | "only_subtypes": true, 125 | "subtypes": [ 126 | {"name": "rings_direction", "only_include": ["X", "Y", "Z", "Spherical"]}, 127 | "wave_profile", 128 | {"name": "wave_type", "only_include": "Rings"} 129 | ] 130 | } 131 | ], 132 | ["ShaderNodeTexGabor", {"subtypes": ["gabor_type"]}] 133 | ] 134 | }, 135 | "group_nodes": { 136 | "poll": "in_nodegroup", 137 | "entries": [ 138 | "NodeGroupInput", 139 | "NodeGroupOutput" 140 | ] 141 | }, 142 | "mix_color": { 143 | "poll": "check_mix_color_alias", 144 | "poll_args": {"valid_options": ["DEFAULT", "MIX_COLOR", "BOTH"]}, 145 | "entries": [ 146 | ["ShaderNodeMix", { 147 | "label": "Mix Color", 148 | "settings": {"data_type": "RGBA"}, 149 | "subtypes": ["blend_type"] 150 | } 151 | ] 152 | ] 153 | }, 154 | "mix_rgb": { 155 | "poll": "check_mix_color_alias", 156 | "poll_args": { "valid_options": ["MIX_RGB", "BOTH"]}, 157 | "entries": [ 158 | ["ShaderNodeMix", { 159 | "label": "Mix RGB", 160 | "settings": {"data_type": "RGBA"}, 161 | "subtypes": ["blend_type"] 162 | } 163 | ] 164 | ] 165 | }, 166 | "world_shader_nodes": { 167 | "poll": "engine_and_shader_type_poll", 168 | "poll_args": {"shader_types": "WORLD"}, 169 | "entries": [ 170 | "ShaderNodeOutputWorld", 171 | "ShaderNodeBackground" 172 | ] 173 | }, 174 | "line_style_shader_nodes": { 175 | "poll": "engine_and_shader_type_poll", 176 | "poll_args": {"shader_types": "LINESTYLE"}, 177 | "entries": [ 178 | "ShaderNodeUVAlongStroke", 179 | "ShaderNodeOutputLineStyle" 180 | ] 181 | }, 182 | "object_not_eevee_shader_nodes": { 183 | "poll": "engine_and_shader_type_poll", 184 | "poll_args": {"shader_types": "OBJECT", "exclude_engines": "BLENDER_EEVEE_NEXT"}, 185 | "entries": [ 186 | "ShaderNodeOutputLight", 187 | "ShaderNodeBsdfHair", 188 | "ShaderNodeBsdfHairPrincipled", 189 | ["ShaderNodeBsdfSheen", {"subtypes": ["distribution"]}], 190 | ["ShaderNodeBsdfToon", {"subtypes": ["component"]}], 191 | "ShaderNodeBsdfRayPortal" 192 | ] 193 | }, 194 | "object_eevee_shader_nodes": { 195 | "poll": "engine_and_shader_type_poll", 196 | "poll_args": {"shader_types": "OBJECT", "engines": "BLENDER_EEVEE_NEXT"}, 197 | "entries": [ 198 | "ShaderNodeShaderToRGB", 199 | "ShaderNodeEeveeSpecular" 200 | ] 201 | }, 202 | "object_shader_nodes": { 203 | "poll": "engine_and_shader_type_poll", 204 | "poll_args": {"shader_types": "OBJECT"}, 205 | "entries": [ 206 | "ShaderNodeOutputMaterial", 207 | "ShaderNodeBsdfDiffuse", 208 | ["ShaderNodeBsdfGlass", {"subtypes": ["distribution"]}], 209 | ["ShaderNodeBsdfAnisotropic", {"subtypes": ["distribution"]}], 210 | "ShaderNodeHoldout", 211 | "ShaderNodeBsdfPrincipled", 212 | ["ShaderNodeBsdfRefraction", {"subtypes": ["distribution"]}], 213 | ["ShaderNodeSubsurfaceScattering", {"subtypes": ["falloff"]}], 214 | "ShaderNodeBsdfTranslucent", 215 | "ShaderNodeBsdfTransparent", 216 | ["ShaderNodeBsdfMetallic", {"subtypes": ["distribution", "fresnel_type"]}] 217 | ] 218 | }, 219 | "frame_and_reroute": { 220 | "entries": [ 221 | "NodeFrame", 222 | "NodeReroute" 223 | ] 224 | } 225 | } -------------------------------------------------------------------------------- /source/nodelists/4.3/TextureNodeTree.json: -------------------------------------------------------------------------------- 1 | { 2 | "items": { 3 | "entries": [ 4 | "TextureNodeCoordinates", 5 | "TextureNodeCurveTime", 6 | "TextureNodeImage", 7 | "TextureNodeTexture", 8 | "TextureNodeOutput", 9 | "TextureNodeViewer", 10 | "TextureNodeHueSaturation", 11 | "TextureNodeInvert", 12 | "TextureNodeCurveRGB", 13 | "TextureNodeValToRGB", 14 | "TextureNodeDistance", 15 | "TextureNodeRGBToBW", 16 | "TextureNodeValToNor", 17 | "TextureNodeAt", 18 | "TextureNodeRotate", 19 | "TextureNodeScale", 20 | "TextureNodeTranslate", 21 | "TextureNodeBricks", 22 | "TextureNodeChecker", 23 | "TextureNodeTexBlend", 24 | "TextureNodeTexClouds", 25 | "TextureNodeTexDistNoise", 26 | "TextureNodeTexMagic", 27 | "TextureNodeTexMarble", 28 | "TextureNodeTexMusgrave", 29 | "TextureNodeTexNoise", 30 | "TextureNodeTexStucci", 31 | "TextureNodeTexVoronoi", 32 | "TextureNodeTexWood" 33 | ] 34 | }, 35 | "basic_subtypes": { 36 | "entries": [ 37 | ["TextureNodeMath", {"subtypes": ["operation"]}], 38 | ["TextureNodeCombineColor", {"subtypes": ["mode"]}], 39 | ["TextureNodeSeparateColor", {"subtypes": ["mode"]}] 40 | ] 41 | }, 42 | "mix_color": { 43 | "poll": "check_mix_color_alias", 44 | "poll_args": { 45 | "valid_options": ["MIX_COLOR", "BOTH"] 46 | }, 47 | "entries": [ 48 | ["TextureNodeMixRGB", {"label": "Mix Color", "subtypes": ["blend_type"]}] 49 | ] 50 | }, 51 | "mix_rgb": { 52 | "poll": "check_mix_color_alias", 53 | "poll_args": { 54 | "valid_options": ["DEFAULT", "MIX_RGB", "BOTH"] 55 | }, 56 | "entries": [ 57 | ["TextureNodeMixRGB", {"subtypes": ["blend_type"]}] 58 | ] 59 | }, 60 | "group_nodes": { 61 | "poll": "in_nodegroup", 62 | "entries": [ 63 | "NodeGroupInput", 64 | "NodeGroupOutput" 65 | ] 66 | }, 67 | "frame_and_reroute": { 68 | "entries": [ 69 | "NodeFrame", 70 | "NodeReroute" 71 | ] 72 | } 73 | } -------------------------------------------------------------------------------- /source/nodelists/4.4/CompositorNodeTree.json: -------------------------------------------------------------------------------- 1 | { 2 | "items": { 3 | "entries": [ 4 | "CompositorNodeBokehImage", 5 | "CompositorNodeImage", 6 | "CompositorNodeMask", 7 | "CompositorNodeMovieClip", 8 | "CompositorNodeTexture", 9 | "CompositorNodeRGB", 10 | "CompositorNodeValue", 11 | "CompositorNodeRLayers", 12 | "CompositorNodeSceneTime", 13 | "CompositorNodeTime", 14 | "CompositorNodeComposite", 15 | "CompositorNodeViewer", 16 | "CompositorNodeOutputFile", 17 | "CompositorNodeValToRGB", 18 | "CompositorNodeConvertColorSpace", 19 | "CompositorNodeInvert", 20 | "CompositorNodeRGBToBW", 21 | "CompositorNodeBrightContrast", 22 | "CompositorNodeColorCorrection", 23 | "CompositorNodeExposure", 24 | "CompositorNodeGamma", 25 | "CompositorNodeHueCorrect", 26 | "CompositorNodeHueSat", 27 | "CompositorNodeCurveRGB", 28 | "CompositorNodeAlphaOver", 29 | "CompositorNodeZcombine", 30 | "CompositorNodeAntiAliasing", 31 | "CompositorNodeDespeckle", 32 | "CompositorNodeInpaint", 33 | "CompositorNodePixelate", 34 | "CompositorNodePosterize", 35 | "CompositorNodeSunBeams", 36 | "CompositorNodeBilateralblur", 37 | "CompositorNodeBokehBlur", 38 | "CompositorNodeDBlur", 39 | "CompositorNodeVecBlur", 40 | "CompositorNodeChannelMatte", 41 | "CompositorNodeChromaMatte", 42 | "CompositorNodeColorMatte", 43 | "CompositorNodeColorSpill", 44 | "CompositorNodeDiffMatte", 45 | "CompositorNodeKeying", 46 | "CompositorNodeKeyingScreen", 47 | "CompositorNodeLumaMatte", 48 | "CompositorNodeCryptomatte", 49 | "CompositorNodeBoxMask", 50 | "CompositorNodeEllipseMask", 51 | "CompositorNodeDoubleEdgeMask", 52 | "CompositorNodeIDMask", 53 | "CompositorNodePlaneTrackDeform", 54 | "CompositorNodeStabilize", 55 | "CompositorNodeTrackPos", 56 | "CompositorNodeCornerPin", 57 | "CompositorNodeCrop", 58 | "CompositorNodeDisplace", 59 | "CompositorNodeMapUV", 60 | "CompositorNodeLensdist", 61 | "CompositorNodeMapRange", 62 | "CompositorNodeMapValue", 63 | "CompositorNodeNormalize", 64 | "CompositorNodeSwitch", 65 | "CompositorNodeCombineXYZ", 66 | "CompositorNodeSeparateXYZ", 67 | "CompositorNodeNormal", 68 | "CompositorNodeCurveVec" 69 | ] 70 | }, 71 | "combine_and_separate_color": { 72 | "entries": [ 73 | ["CompositorNodeCombineColor", {"subtypes": ["mode"]}], 74 | ["CompositorNodeCombineColor", { 75 | "only_subtypes" : true, 76 | "subtypes": [ 77 | {"name": "mode", "only_include": ["YCbCr"]}, 78 | "ycc_mode" 79 | ] 80 | } 81 | ], 82 | ["CompositorNodeSeparateColor", {"subtypes": ["mode"]}], 83 | ["CompositorNodeSeparateColor", { 84 | "only_subtypes" : true, 85 | "subtypes": [ 86 | {"name": "mode", "only_include": ["YCbCr"]}, 87 | "ycc_mode" 88 | ] 89 | } 90 | ] 91 | ] 92 | }, 93 | "specific_types": { 94 | "entries": [ 95 | ["CompositorNodeSwitchView", {"label": "Switch Stereo View"}] 96 | ] 97 | }, 98 | "basic_subtypes": { 99 | "entries": [ 100 | ["CompositorNodePremulKey", {"subtypes": ["mapping"]}], 101 | ["CompositorNodeColorBalance", {"subtypes": ["correction_method"]}], 102 | ["CompositorNodeCryptomatteV2", {"subtypes": ["source"]}], 103 | ["CompositorNodeDistanceMatte", {"subtypes": ["channel"]}], 104 | ["CompositorNodeMovieDistortion", {"subtypes": ["distortion_type"]}], 105 | ["CompositorNodeSetAlpha", {"subtypes": ["mode"]}], 106 | ["CompositorNodeDefocus", {"subtypes": ["bokeh"]}], 107 | ["CompositorNodeDenoise", {"subtypes": ["prefilter"]}], 108 | ["CompositorNodeDilateErode", {"subtypes": ["mode"]}], 109 | ["CompositorNodeDilateErode", { 110 | "only_subtypes": true, 111 | "subtypes": [ 112 | {"name": "mode", "only_include": ["Feather"]}, 113 | "falloff" 114 | ] 115 | } 116 | ], 117 | ["CompositorNodeGlare", {"subtypes": ["glare_type"]}], 118 | ["CompositorNodeRotate", {"subtypes": ["filter_type"]}], 119 | ["CompositorNodeScale", {"subtypes": ["space"]}], 120 | ["CompositorNodeScale", { 121 | "only_subtypes": true, 122 | "subtypes": [ 123 | {"name": "space", "only_include": ["Render Size"]}, 124 | "frame_method" 125 | ] 126 | } 127 | ], 128 | ["CompositorNodeTransform", {"subtypes": ["filter_type"]}], 129 | ["CompositorNodeTranslate", {"subtypes": ["wrap_axis"]}], 130 | ["CompositorNodeFlip", {"subtypes": ["axis"]}], 131 | ["CompositorNodeBlur", {"subtypes": ["filter_type"]}], 132 | ["CompositorNodeKuwahara", {"subtypes": ["variation"]}], 133 | ["CompositorNodeLevels", {"subtypes": ["channel"]}], 134 | ["CompositorNodeMath", {"subtypes": ["operation"]}], 135 | ["CompositorNodeFilter", {"subtypes": ["filter_type"]}], 136 | ["CompositorNodeSplit", {"subtypes": ["axis"]}], 137 | ["CompositorNodeTonemap", {"subtypes": ["tonemap_type"]}] 138 | ] 139 | }, 140 | "mix_color": { 141 | "poll": "check_mix_color_alias", 142 | "poll_args": {"valid_options": ["DEFAULT", "MIX_COLOR", "BOTH"]}, 143 | "entries": [ 144 | ["CompositorNodeMixRGB", {"label": "Mix Color", "subtypes": ["blend_type"]}] 145 | ] 146 | }, 147 | "mix_rgb": { 148 | "poll": "check_mix_color_alias", 149 | "poll_args": { "valid_options": ["MIX_RGB", "BOTH"]}, 150 | "entries": [ 151 | ["CompositorNodeMixRGB", {"label": "Mix RGB", "subtypes": ["blend_type"]}] 152 | ] 153 | }, 154 | "group_nodes": { 155 | "poll": "in_nodegroup", 156 | "entries": [ 157 | "NodeGroupInput", 158 | "NodeGroupOutput" 159 | ] 160 | }, 161 | "frame_and_reroute": { 162 | "entries": [ 163 | "NodeFrame", 164 | "NodeReroute" 165 | ] 166 | } 167 | } -------------------------------------------------------------------------------- /source/nodelists/4.4/ShaderNodeTree.json: -------------------------------------------------------------------------------- 1 | { 2 | "items": { 3 | "entries": [ 4 | "ShaderNodeAddShader", 5 | "ShaderNodeEmission", 6 | "ShaderNodeMixShader", 7 | "ShaderNodeAmbientOcclusion", 8 | "ShaderNodeAttribute", 9 | "ShaderNodeBevel", 10 | "ShaderNodeCameraData", 11 | "ShaderNodeVertexColor", 12 | "ShaderNodeHairInfo", 13 | "ShaderNodeFresnel", 14 | "ShaderNodeNewGeometry", 15 | "ShaderNodeLayerWeight", 16 | "ShaderNodeLightPath", 17 | "ShaderNodeObjectInfo", 18 | "ShaderNodeParticleInfo", 19 | "ShaderNodePointInfo", 20 | "ShaderNodeRGB", 21 | "ShaderNodeTangent", 22 | "ShaderNodeTexCoord", 23 | "ShaderNodeUVMap", 24 | "ShaderNodeValue", 25 | "ShaderNodeVolumeInfo", 26 | "ShaderNodeWireframe", 27 | "ShaderNodeOutputAOV", 28 | "ShaderNodeVolumePrincipled", 29 | "ShaderNodeBrightContrast", 30 | "ShaderNodeGamma", 31 | "ShaderNodeHueSaturation", 32 | "ShaderNodeInvert", 33 | "ShaderNodeLightFalloff", 34 | "ShaderNodeRGBCurve", 35 | "ShaderNodeBlackbody", 36 | "ShaderNodeValToRGB", 37 | "ShaderNodeCombineXYZ", 38 | "ShaderNodeFloatCurve", 39 | "ShaderNodeRGBToBW", 40 | "ShaderNodeSeparateXYZ", 41 | "ShaderNodeWavelength", 42 | "ShaderNodeTexBrick", 43 | "ShaderNodeTexChecker", 44 | "ShaderNodeTexEnvironment", 45 | "ShaderNodeTexImage", 46 | "ShaderNodeTexMagic", 47 | "ShaderNodeTexPointDensity", 48 | "ShaderNodeBump", 49 | "ShaderNodeNormal", 50 | "ShaderNodeVectorCurve", 51 | "ShaderNodeVectorTransform", 52 | "ShaderNodeVolumeAbsorption" 53 | ] 54 | }, 55 | "specific_types": { 56 | "entries": [ 57 | "ShaderNodeMix", 58 | ["ShaderNodeMix", {"label": "Mix Vector", "settings": {"data_type": "VECTOR"}, "subtypes": ["factor_mode"]}], 59 | "ShaderNodeMapRange", 60 | ["ShaderNodeMapRange", { 61 | "label": "Map Range - Float", 62 | "settings": {"data_type": "FLOAT"}, 63 | "subtypes": ["interpolation_type"] 64 | } 65 | ], 66 | ["ShaderNodeMapRange", { 67 | "label": "Map Range - Vector", 68 | "settings": {"data_type": "FLOAT_VECTOR"}, 69 | "subtypes": ["interpolation_type"] 70 | } 71 | ] 72 | ] 73 | }, 74 | "basic_subtypes": { 75 | "entries": [ 76 | ["ShaderNodeClamp", {"subtypes": ["clamp_type"]}], 77 | ["ShaderNodeMath", {"subtypes": ["operation"]}], 78 | ["ShaderNodeVectorMath", {"subtypes": ["operation"]}], 79 | ["ShaderNodeVectorRotate", {"subtypes": ["rotation_type"]}], 80 | ["ShaderNodeCombineColor", {"subtypes": ["mode"]}], 81 | ["ShaderNodeSeparateColor", {"subtypes": ["mode"]}], 82 | ["ShaderNodeNormalMap", {"subtypes": ["space"]}], 83 | ["ShaderNodeDisplacement", {"subtypes": ["space"]}], 84 | ["ShaderNodeVectorDisplacement", {"subtypes": ["space"]}], 85 | ["ShaderNodeScript", {"subtypes": ["mode"]}], 86 | ["ShaderNodeMapping", {"subtypes": ["vector_type"]}], 87 | ["ShaderNodeVolumeScatter", {"subtypes": ["phase"]}] 88 | ] 89 | }, 90 | "texture_subtypes": { 91 | "entries": [ 92 | ["ShaderNodeTexSky", {"subtypes": ["sky_type"]}], 93 | ["ShaderNodeTexIES", {"subtypes": ["mode"]}], 94 | ["ShaderNodeTexGradient", {"subtypes": ["gradient_type"]}], 95 | "ShaderNodeTexVoronoi", 96 | ["ShaderNodeTexVoronoi", { 97 | "only_subtypes": true, 98 | "subtypes": [ 99 | {"name": "voronoi_dimensions", "only_include": ["1D"]} 100 | ] 101 | } 102 | ], 103 | ["ShaderNodeTexVoronoi", { 104 | "only_subtypes": true, 105 | "subtypes": [ 106 | "distance", {"name": "voronoi_dimensions", "only_include": ["2D", "3D", "4D"]} 107 | ] 108 | } 109 | ], 110 | ["ShaderNodeTexNoise", {"subtypes": ["noise_dimensions"]}], 111 | ["ShaderNodeTexNoise", {"only_subtypes": true, "subtypes": ["noise_dimensions", "noise_type"]}], 112 | ["ShaderNodeTexWhiteNoise", {"subtypes": ["noise_dimensions"]}], 113 | "ShaderNodeTexWave", 114 | ["ShaderNodeTexWave", { 115 | "only_subtypes": true, 116 | "subtypes": [ 117 | {"name": "bands_direction", "only_include": ["X", "Y", "Z", "Diagonal"]}, 118 | "wave_profile", 119 | {"name": "wave_type", "only_include": "Bands"} 120 | ] 121 | } 122 | ], 123 | ["ShaderNodeTexWave", { 124 | "only_subtypes": true, 125 | "subtypes": [ 126 | {"name": "rings_direction", "only_include": ["X", "Y", "Z", "Spherical"]}, 127 | "wave_profile", 128 | {"name": "wave_type", "only_include": "Rings"} 129 | ] 130 | } 131 | ], 132 | ["ShaderNodeTexGabor", {"subtypes": ["gabor_type"]}] 133 | ] 134 | }, 135 | "group_nodes": { 136 | "poll": "in_nodegroup", 137 | "entries": [ 138 | "NodeGroupInput", 139 | "NodeGroupOutput" 140 | ] 141 | }, 142 | "mix_color": { 143 | "poll": "check_mix_color_alias", 144 | "poll_args": {"valid_options": ["DEFAULT", "MIX_COLOR", "BOTH"]}, 145 | "entries": [ 146 | ["ShaderNodeMix", { 147 | "label": "Mix Color", 148 | "settings": {"data_type": "RGBA"}, 149 | "subtypes": ["blend_type"] 150 | } 151 | ] 152 | ] 153 | }, 154 | "mix_rgb": { 155 | "poll": "check_mix_color_alias", 156 | "poll_args": { "valid_options": ["MIX_RGB", "BOTH"]}, 157 | "entries": [ 158 | ["ShaderNodeMix", { 159 | "label": "Mix RGB", 160 | "settings": {"data_type": "RGBA"}, 161 | "subtypes": ["blend_type"] 162 | } 163 | ] 164 | ] 165 | }, 166 | "world_shader_nodes": { 167 | "poll": "engine_and_shader_type_poll", 168 | "poll_args": {"shader_types": "WORLD"}, 169 | "entries": [ 170 | "ShaderNodeOutputWorld", 171 | "ShaderNodeBackground" 172 | ] 173 | }, 174 | "line_style_shader_nodes": { 175 | "poll": "engine_and_shader_type_poll", 176 | "poll_args": {"shader_types": "LINESTYLE"}, 177 | "entries": [ 178 | "ShaderNodeUVAlongStroke", 179 | "ShaderNodeOutputLineStyle" 180 | ] 181 | }, 182 | "object_not_eevee_shader_nodes": { 183 | "poll": "engine_and_shader_type_poll", 184 | "poll_args": {"shader_types": "OBJECT", "exclude_engines": "BLENDER_EEVEE_NEXT"}, 185 | "entries": [ 186 | "ShaderNodeOutputLight", 187 | "ShaderNodeBsdfHair", 188 | "ShaderNodeBsdfHairPrincipled", 189 | ["ShaderNodeBsdfSheen", {"subtypes": ["distribution"]}], 190 | ["ShaderNodeBsdfToon", {"subtypes": ["component"]}], 191 | "ShaderNodeBsdfRayPortal" 192 | ] 193 | }, 194 | "object_eevee_shader_nodes": { 195 | "poll": "engine_and_shader_type_poll", 196 | "poll_args": {"shader_types": "OBJECT", "engines": "BLENDER_EEVEE_NEXT"}, 197 | "entries": [ 198 | "ShaderNodeShaderToRGB", 199 | "ShaderNodeEeveeSpecular" 200 | ] 201 | }, 202 | "object_shader_nodes": { 203 | "poll": "engine_and_shader_type_poll", 204 | "poll_args": {"shader_types": "OBJECT"}, 205 | "entries": [ 206 | "ShaderNodeOutputMaterial", 207 | "ShaderNodeBsdfDiffuse", 208 | ["ShaderNodeBsdfGlass", {"subtypes": ["distribution"]}], 209 | ["ShaderNodeBsdfAnisotropic", {"subtypes": ["distribution"]}], 210 | "ShaderNodeHoldout", 211 | "ShaderNodeBsdfPrincipled", 212 | ["ShaderNodeBsdfRefraction", {"subtypes": ["distribution"]}], 213 | ["ShaderNodeSubsurfaceScattering", {"subtypes": ["falloff"]}], 214 | "ShaderNodeBsdfTranslucent", 215 | "ShaderNodeBsdfTransparent", 216 | ["ShaderNodeBsdfMetallic", {"subtypes": ["distribution", "fresnel_type"]}] 217 | ] 218 | }, 219 | "frame_and_reroute": { 220 | "entries": [ 221 | "NodeFrame", 222 | "NodeReroute" 223 | ] 224 | } 225 | } -------------------------------------------------------------------------------- /source/nodelists/4.4/TextureNodeTree.json: -------------------------------------------------------------------------------- 1 | { 2 | "items": { 3 | "entries": [ 4 | "TextureNodeCoordinates", 5 | "TextureNodeCurveTime", 6 | "TextureNodeImage", 7 | "TextureNodeTexture", 8 | "TextureNodeOutput", 9 | "TextureNodeViewer", 10 | "TextureNodeHueSaturation", 11 | "TextureNodeInvert", 12 | "TextureNodeCurveRGB", 13 | "TextureNodeValToRGB", 14 | "TextureNodeDistance", 15 | "TextureNodeRGBToBW", 16 | "TextureNodeValToNor", 17 | "TextureNodeAt", 18 | "TextureNodeRotate", 19 | "TextureNodeScale", 20 | "TextureNodeTranslate", 21 | "TextureNodeBricks", 22 | "TextureNodeChecker", 23 | "TextureNodeTexBlend", 24 | "TextureNodeTexClouds", 25 | "TextureNodeTexDistNoise", 26 | "TextureNodeTexMagic", 27 | "TextureNodeTexMarble", 28 | "TextureNodeTexMusgrave", 29 | "TextureNodeTexNoise", 30 | "TextureNodeTexStucci", 31 | "TextureNodeTexVoronoi", 32 | "TextureNodeTexWood" 33 | ] 34 | }, 35 | "basic_subtypes": { 36 | "entries": [ 37 | ["TextureNodeMath", {"subtypes": ["operation"]}], 38 | ["TextureNodeCombineColor", {"subtypes": ["mode"]}], 39 | ["TextureNodeSeparateColor", {"subtypes": ["mode"]}] 40 | ] 41 | }, 42 | "mix_color": { 43 | "poll": "check_mix_color_alias", 44 | "poll_args": { 45 | "valid_options": ["MIX_COLOR", "BOTH"] 46 | }, 47 | "entries": [ 48 | ["TextureNodeMixRGB", {"label": "Mix Color", "subtypes": ["blend_type"]}] 49 | ] 50 | }, 51 | "mix_rgb": { 52 | "poll": "check_mix_color_alias", 53 | "poll_args": { 54 | "valid_options": ["DEFAULT", "MIX_RGB", "BOTH"] 55 | }, 56 | "entries": [ 57 | ["TextureNodeMixRGB", {"subtypes": ["blend_type"]}] 58 | ] 59 | }, 60 | "group_nodes": { 61 | "poll": "in_nodegroup", 62 | "entries": [ 63 | "NodeGroupInput", 64 | "NodeGroupOutput" 65 | ] 66 | }, 67 | "frame_and_reroute": { 68 | "entries": [ 69 | "NodeFrame", 70 | "NodeReroute" 71 | ] 72 | } 73 | } -------------------------------------------------------------------------------- /source/nodelists/4.5/CompositorNodeTree.json: -------------------------------------------------------------------------------- 1 | { 2 | "items": { 3 | "entries": [ 4 | "CompositorNodeBokehImage", 5 | "CompositorNodeImage", 6 | "CompositorNodeMask", 7 | "CompositorNodeMovieClip", 8 | "CompositorNodeTexture", 9 | "CompositorNodeRGB", 10 | "ShaderNodeValue", 11 | "CompositorNodeRLayers", 12 | "CompositorNodeSceneTime", 13 | "CompositorNodeTime", 14 | "CompositorNodeComposite", 15 | "CompositorNodeViewer", 16 | "CompositorNodeOutputFile", 17 | "ShaderNodeValToRGB", 18 | "CompositorNodeConvertColorSpace", 19 | "CompositorNodeInvert", 20 | "CompositorNodeRGBToBW", 21 | "CompositorNodeBrightContrast", 22 | "CompositorNodeColorCorrection", 23 | "CompositorNodeExposure", 24 | "CompositorNodeGamma", 25 | "CompositorNodeHueCorrect", 26 | "CompositorNodeHueSat", 27 | "CompositorNodeCurveRGB", 28 | "CompositorNodeAlphaOver", 29 | "CompositorNodeZcombine", 30 | "CompositorNodeAntiAliasing", 31 | "CompositorNodeDespeckle", 32 | "CompositorNodeInpaint", 33 | "CompositorNodePixelate", 34 | "CompositorNodePosterize", 35 | "CompositorNodeSunBeams", 36 | "CompositorNodeBilateralblur", 37 | "CompositorNodeBokehBlur", 38 | "CompositorNodeDBlur", 39 | "CompositorNodeVecBlur", 40 | "CompositorNodeChannelMatte", 41 | "CompositorNodeChromaMatte", 42 | "CompositorNodeColorMatte", 43 | "CompositorNodeColorSpill", 44 | "CompositorNodeDiffMatte", 45 | "CompositorNodeKeying", 46 | "CompositorNodeKeyingScreen", 47 | "CompositorNodeLumaMatte", 48 | "CompositorNodeCryptomatte", 49 | "CompositorNodeBoxMask", 50 | "CompositorNodeEllipseMask", 51 | "CompositorNodeDoubleEdgeMask", 52 | "CompositorNodeIDMask", 53 | "CompositorNodePlaneTrackDeform", 54 | "CompositorNodeStabilize", 55 | "CompositorNodeTrackPos", 56 | "CompositorNodeCrop", 57 | "CompositorNodeDisplace", 58 | "CompositorNodeMapUV", 59 | "CompositorNodeLensdist", 60 | "CompositorNodeNormalize", 61 | "CompositorNodeSwitch", 62 | "ShaderNodeCombineXYZ", 63 | "ShaderNodeSeparateXYZ", 64 | "CompositorNodeNormal", 65 | "ShaderNodeVectorCurve", 66 | "CompositorNodeImageInfo", 67 | "ShaderNodeFloatCurve", 68 | "ShaderNodeBlackbody", 69 | "ShaderNodeTexBrick", 70 | "ShaderNodeTexChecker", 71 | "ShaderNodeTexMagic", 72 | "CompositorNodeImageCoordinates" 73 | ] 74 | }, 75 | "combine_and_separate_color": { 76 | "entries": [ 77 | ["CompositorNodeCombineColor", {"subtypes": ["mode"]}], 78 | ["CompositorNodeCombineColor", { 79 | "only_subtypes" : true, 80 | "subtypes": [ 81 | {"name": "mode", "only_include": ["YCbCr"]}, 82 | "ycc_mode" 83 | ] 84 | } 85 | ], 86 | ["CompositorNodeSeparateColor", {"subtypes": ["mode"]}], 87 | ["CompositorNodeSeparateColor", { 88 | "only_subtypes" : true, 89 | "subtypes": [ 90 | {"name": "mode", "only_include": ["YCbCr"]}, 91 | "ycc_mode" 92 | ] 93 | } 94 | ] 95 | ] 96 | }, 97 | "specific_types": { 98 | "entries": [ 99 | ["CompositorNodeSwitchView", {"label": "Switch Stereo View"}], 100 | ["ShaderNodeClamp", {"subtypes": ["clamp_type"]}], 101 | "ShaderNodeMix", 102 | ["ShaderNodeMix", {"label": "Mix Vector", "settings": {"data_type": "VECTOR"}, "subtypes": ["factor_mode"]}], 103 | "ShaderNodeMapRange", 104 | ["ShaderNodeMapRange", { 105 | "label": "Map Range - Float", 106 | "settings": {"data_type": "FLOAT"}, 107 | "subtypes": ["interpolation_type"] 108 | } 109 | ], 110 | ["ShaderNodeMapRange", { 111 | "label": "Map Range - Vector", 112 | "settings": {"data_type": "FLOAT_VECTOR"}, 113 | "subtypes": ["interpolation_type"] 114 | } 115 | ], 116 | ["ShaderNodeVectorMath", {"subtypes": ["operation"]}], 117 | ["ShaderNodeVectorRotate", {"subtypes": ["rotation_type"]}], 118 | ["CompositorNodeRelativeToPixel", {"subtypes": ["data_type", "reference_dimension"]}] 119 | ] 120 | }, 121 | "basic_subtypes": { 122 | "entries": [ 123 | ["CompositorNodePremulKey", {"subtypes": ["mapping"]}], 124 | ["CompositorNodeColorBalance", {"subtypes": ["correction_method"]}], 125 | ["CompositorNodeCryptomatteV2", {"subtypes": ["source"]}], 126 | ["CompositorNodeDistanceMatte", {"subtypes": ["channel"]}], 127 | ["CompositorNodeMovieDistortion", {"subtypes": ["distortion_type"]}], 128 | ["CompositorNodeSetAlpha", {"subtypes": ["mode"]}], 129 | ["CompositorNodeDefocus", {"subtypes": ["bokeh"]}], 130 | ["CompositorNodeDenoise", {"subtypes": ["prefilter"]}], 131 | ["CompositorNodeDilateErode", {"subtypes": ["mode"]}], 132 | ["CompositorNodeDilateErode", { 133 | "only_subtypes": true, 134 | "subtypes": [ 135 | {"name": "mode", "only_include": ["Feather"]}, 136 | "falloff" 137 | ] 138 | } 139 | ], 140 | ["CompositorNodeGlare", {"subtypes": ["glare_type"]}], 141 | ["CompositorNodeRotate", {"subtypes": ["filter_type"]}], 142 | ["CompositorNodeScale", {"subtypes": ["interpolation", "space"]}], 143 | ["CompositorNodeScale", { 144 | "only_subtypes": true, 145 | "subtypes": [ 146 | {"name": "space", "only_include": ["Render Size"]}, 147 | "frame_method" 148 | ] 149 | } 150 | ], 151 | ["CompositorNodeTransform", {"subtypes": ["filter_type"]}], 152 | ["CompositorNodeTranslate", {"subtypes": ["wrap_axis"]}], 153 | ["CompositorNodeFlip", {"subtypes": ["axis"]}], 154 | ["CompositorNodeBlur", {"subtypes": ["filter_type"]}], 155 | ["CompositorNodeKuwahara", {"subtypes": ["variation"]}], 156 | ["CompositorNodeLevels", {"subtypes": ["channel"]}], 157 | ["ShaderNodeMath", {"subtypes": ["operation"]}], 158 | ["CompositorNodeFilter", {"subtypes": ["filter_type"]}], 159 | ["CompositorNodeSplit", {"subtypes": ["axis"]}], 160 | ["CompositorNodeTonemap", {"subtypes": ["tonemap_type"]}], 161 | ["CompositorNodeCornerPin", {"subtypes": ["interpolation"]}] 162 | ] 163 | }, 164 | "texture_subtypes": { 165 | "entries": [ 166 | ["ShaderNodeTexGradient", {"subtypes": ["gradient_type"]}], 167 | "ShaderNodeTexVoronoi", 168 | ["ShaderNodeTexVoronoi", { 169 | "only_subtypes": true, 170 | "subtypes": [ 171 | {"name": "voronoi_dimensions", "only_include": ["1D"]} 172 | ] 173 | } 174 | ], 175 | ["ShaderNodeTexVoronoi", { 176 | "only_subtypes": true, 177 | "subtypes": [ 178 | "distance", {"name": "voronoi_dimensions", "only_include": ["2D", "3D", "4D"]} 179 | ] 180 | } 181 | ], 182 | ["ShaderNodeTexNoise", {"subtypes": ["noise_dimensions"]}], 183 | ["ShaderNodeTexNoise", {"only_subtypes": true, "subtypes": ["noise_dimensions", "noise_type"]}], 184 | ["ShaderNodeTexWhiteNoise", {"subtypes": ["noise_dimensions"]}], 185 | "ShaderNodeTexWave", 186 | ["ShaderNodeTexWave", { 187 | "only_subtypes": true, 188 | "subtypes": [ 189 | {"name": "bands_direction", "only_include": ["X", "Y", "Z", "Diagonal"]}, 190 | "wave_profile", 191 | {"name": "wave_type", "only_include": "Bands"} 192 | ] 193 | } 194 | ], 195 | ["ShaderNodeTexWave", { 196 | "only_subtypes": true, 197 | "subtypes": [ 198 | {"name": "rings_direction", "only_include": ["X", "Y", "Z", "Spherical"]}, 199 | "wave_profile", 200 | {"name": "wave_type", "only_include": "Rings"} 201 | ] 202 | } 203 | ], 204 | ["ShaderNodeTexGabor", {"subtypes": ["gabor_type"]}] 205 | ] 206 | }, 207 | "mix_color": { 208 | "poll": "check_mix_color_alias", 209 | "poll_args": {"valid_options": ["DEFAULT", "MIX_COLOR", "BOTH"]}, 210 | "entries": [ 211 | ["ShaderNodeMix", { 212 | "label": "Mix Color", 213 | "settings": {"data_type": "RGBA"}, 214 | "subtypes": ["blend_type"] 215 | } 216 | ] 217 | ] 218 | }, 219 | "mix_rgb": { 220 | "poll": "check_mix_color_alias", 221 | "poll_args": { "valid_options": ["MIX_RGB", "BOTH"]}, 222 | "entries": [ 223 | ["ShaderNodeMix", { 224 | "label": "Mix RGB", 225 | "settings": {"data_type": "RGBA"}, 226 | "subtypes": ["blend_type"] 227 | } 228 | ] 229 | ] 230 | }, 231 | "group_nodes": { 232 | "poll": "in_nodegroup", 233 | "entries": [ 234 | "NodeGroupInput", 235 | "NodeGroupOutput" 236 | ] 237 | }, 238 | "frame_and_reroute": { 239 | "entries": [ 240 | "NodeFrame", 241 | "NodeReroute" 242 | ] 243 | } 244 | } -------------------------------------------------------------------------------- /source/nodelists/4.5/ShaderNodeTree.json: -------------------------------------------------------------------------------- 1 | { 2 | "items": { 3 | "entries": [ 4 | "ShaderNodeAddShader", 5 | "ShaderNodeEmission", 6 | "ShaderNodeMixShader", 7 | "ShaderNodeAmbientOcclusion", 8 | "ShaderNodeAttribute", 9 | "ShaderNodeBevel", 10 | "ShaderNodeCameraData", 11 | "ShaderNodeVertexColor", 12 | "ShaderNodeHairInfo", 13 | "ShaderNodeFresnel", 14 | "ShaderNodeNewGeometry", 15 | "ShaderNodeLayerWeight", 16 | "ShaderNodeLightPath", 17 | "ShaderNodeObjectInfo", 18 | "ShaderNodeParticleInfo", 19 | "ShaderNodePointInfo", 20 | "ShaderNodeRGB", 21 | "ShaderNodeTangent", 22 | "ShaderNodeTexCoord", 23 | "ShaderNodeUVMap", 24 | "ShaderNodeValue", 25 | "ShaderNodeVolumeInfo", 26 | "ShaderNodeWireframe", 27 | "ShaderNodeOutputAOV", 28 | "ShaderNodeVolumePrincipled", 29 | "ShaderNodeBrightContrast", 30 | "ShaderNodeGamma", 31 | "ShaderNodeHueSaturation", 32 | "ShaderNodeInvert", 33 | "ShaderNodeLightFalloff", 34 | "ShaderNodeRGBCurve", 35 | "ShaderNodeBlackbody", 36 | "ShaderNodeValToRGB", 37 | "ShaderNodeCombineXYZ", 38 | "ShaderNodeFloatCurve", 39 | "ShaderNodeRGBToBW", 40 | "ShaderNodeSeparateXYZ", 41 | "ShaderNodeWavelength", 42 | "ShaderNodeTexBrick", 43 | "ShaderNodeTexChecker", 44 | "ShaderNodeTexEnvironment", 45 | "ShaderNodeTexImage", 46 | "ShaderNodeTexMagic", 47 | "ShaderNodeTexPointDensity", 48 | "ShaderNodeBump", 49 | "ShaderNodeNormal", 50 | "ShaderNodeVectorCurve", 51 | "ShaderNodeVectorTransform", 52 | "ShaderNodeVolumeAbsorption" 53 | ] 54 | }, 55 | "specific_types": { 56 | "entries": [ 57 | "ShaderNodeMix", 58 | ["ShaderNodeMix", {"label": "Mix Vector", "settings": {"data_type": "VECTOR"}, "subtypes": ["factor_mode"]}], 59 | "ShaderNodeMapRange", 60 | ["ShaderNodeMapRange", { 61 | "label": "Map Range - Float", 62 | "settings": {"data_type": "FLOAT"}, 63 | "subtypes": ["interpolation_type"] 64 | } 65 | ], 66 | ["ShaderNodeMapRange", { 67 | "label": "Map Range - Vector", 68 | "settings": {"data_type": "FLOAT_VECTOR"}, 69 | "subtypes": ["interpolation_type"] 70 | } 71 | ] 72 | ] 73 | }, 74 | "basic_subtypes": { 75 | "entries": [ 76 | ["ShaderNodeClamp", {"subtypes": ["clamp_type"]}], 77 | ["ShaderNodeMath", {"subtypes": ["operation"]}], 78 | ["ShaderNodeVectorMath", {"subtypes": ["operation"]}], 79 | ["ShaderNodeVectorRotate", {"subtypes": ["rotation_type"]}], 80 | ["ShaderNodeCombineColor", {"subtypes": ["mode"]}], 81 | ["ShaderNodeSeparateColor", {"subtypes": ["mode"]}], 82 | ["ShaderNodeNormalMap", {"subtypes": ["space"]}], 83 | ["ShaderNodeDisplacement", {"subtypes": ["space"]}], 84 | ["ShaderNodeVectorDisplacement", {"subtypes": ["space"]}], 85 | ["ShaderNodeScript", {"subtypes": ["mode"]}], 86 | ["ShaderNodeMapping", {"subtypes": ["vector_type"]}], 87 | ["ShaderNodeVolumeScatter", {"subtypes": ["phase"]}], 88 | ["ShaderNodeVolumeCoefficients", {"subtypes": ["phase"]}] 89 | ] 90 | }, 91 | "texture_subtypes": { 92 | "entries": [ 93 | ["ShaderNodeTexSky", {"subtypes": ["sky_type"]}], 94 | ["ShaderNodeTexIES", {"subtypes": ["mode"]}], 95 | ["ShaderNodeTexGradient", {"subtypes": ["gradient_type"]}], 96 | "ShaderNodeTexVoronoi", 97 | ["ShaderNodeTexVoronoi", { 98 | "only_subtypes": true, 99 | "subtypes": [ 100 | {"name": "voronoi_dimensions", "only_include": ["1D"]} 101 | ] 102 | } 103 | ], 104 | ["ShaderNodeTexVoronoi", { 105 | "only_subtypes": true, 106 | "subtypes": [ 107 | "distance", {"name": "voronoi_dimensions", "only_include": ["2D", "3D", "4D"]} 108 | ] 109 | } 110 | ], 111 | ["ShaderNodeTexNoise", {"subtypes": ["noise_dimensions"]}], 112 | ["ShaderNodeTexNoise", {"only_subtypes": true, "subtypes": ["noise_dimensions", "noise_type"]}], 113 | ["ShaderNodeTexWhiteNoise", {"subtypes": ["noise_dimensions"]}], 114 | "ShaderNodeTexWave", 115 | ["ShaderNodeTexWave", { 116 | "only_subtypes": true, 117 | "subtypes": [ 118 | {"name": "bands_direction", "only_include": ["X", "Y", "Z", "Diagonal"]}, 119 | "wave_profile", 120 | {"name": "wave_type", "only_include": "Bands"} 121 | ] 122 | } 123 | ], 124 | ["ShaderNodeTexWave", { 125 | "only_subtypes": true, 126 | "subtypes": [ 127 | {"name": "rings_direction", "only_include": ["X", "Y", "Z", "Spherical"]}, 128 | "wave_profile", 129 | {"name": "wave_type", "only_include": "Rings"} 130 | ] 131 | } 132 | ], 133 | ["ShaderNodeTexGabor", {"subtypes": ["gabor_type"]}] 134 | ] 135 | }, 136 | "group_nodes": { 137 | "poll": "in_nodegroup", 138 | "entries": [ 139 | "NodeGroupInput", 140 | "NodeGroupOutput" 141 | ] 142 | }, 143 | "mix_color": { 144 | "poll": "check_mix_color_alias", 145 | "poll_args": {"valid_options": ["DEFAULT", "MIX_COLOR", "BOTH"]}, 146 | "entries": [ 147 | ["ShaderNodeMix", { 148 | "label": "Mix Color", 149 | "settings": {"data_type": "RGBA"}, 150 | "subtypes": ["blend_type"] 151 | } 152 | ] 153 | ] 154 | }, 155 | "mix_rgb": { 156 | "poll": "check_mix_color_alias", 157 | "poll_args": { "valid_options": ["MIX_RGB", "BOTH"]}, 158 | "entries": [ 159 | ["ShaderNodeMix", { 160 | "label": "Mix RGB", 161 | "settings": {"data_type": "RGBA"}, 162 | "subtypes": ["blend_type"] 163 | } 164 | ] 165 | ] 166 | }, 167 | "world_shader_nodes": { 168 | "poll": "engine_and_shader_type_poll", 169 | "poll_args": {"shader_types": "WORLD"}, 170 | "entries": [ 171 | "ShaderNodeOutputWorld", 172 | "ShaderNodeBackground" 173 | ] 174 | }, 175 | "line_style_shader_nodes": { 176 | "poll": "engine_and_shader_type_poll", 177 | "poll_args": {"shader_types": "LINESTYLE"}, 178 | "entries": [ 179 | "ShaderNodeUVAlongStroke", 180 | "ShaderNodeOutputLineStyle" 181 | ] 182 | }, 183 | "object_not_eevee_shader_nodes": { 184 | "poll": "engine_and_shader_type_poll", 185 | "poll_args": {"shader_types": "OBJECT", "exclude_engines": "BLENDER_EEVEE_NEXT"}, 186 | "entries": [ 187 | "ShaderNodeOutputLight", 188 | "ShaderNodeBsdfHair", 189 | "ShaderNodeBsdfHairPrincipled", 190 | ["ShaderNodeBsdfSheen", {"subtypes": ["distribution"]}], 191 | ["ShaderNodeBsdfToon", {"subtypes": ["component"]}], 192 | "ShaderNodeBsdfRayPortal" 193 | ] 194 | }, 195 | "object_eevee_shader_nodes": { 196 | "poll": "engine_and_shader_type_poll", 197 | "poll_args": {"shader_types": "OBJECT", "engines": "BLENDER_EEVEE_NEXT"}, 198 | "entries": [ 199 | "ShaderNodeShaderToRGB", 200 | "ShaderNodeEeveeSpecular" 201 | ] 202 | }, 203 | "object_shader_nodes": { 204 | "poll": "engine_and_shader_type_poll", 205 | "poll_args": {"shader_types": "OBJECT"}, 206 | "entries": [ 207 | "ShaderNodeOutputMaterial", 208 | "ShaderNodeBsdfDiffuse", 209 | ["ShaderNodeBsdfGlass", {"subtypes": ["distribution"]}], 210 | ["ShaderNodeBsdfAnisotropic", {"subtypes": ["distribution"]}], 211 | "ShaderNodeHoldout", 212 | "ShaderNodeBsdfPrincipled", 213 | ["ShaderNodeBsdfRefraction", {"subtypes": ["distribution"]}], 214 | ["ShaderNodeSubsurfaceScattering", {"subtypes": ["falloff"]}], 215 | "ShaderNodeBsdfTranslucent", 216 | "ShaderNodeBsdfTransparent", 217 | ["ShaderNodeBsdfMetallic", {"subtypes": ["distribution", "fresnel_type"]}] 218 | ] 219 | }, 220 | "frame_and_reroute": { 221 | "entries": [ 222 | "NodeFrame", 223 | "NodeReroute" 224 | ] 225 | } 226 | } -------------------------------------------------------------------------------- /source/nodelists/4.5/TextureNodeTree.json: -------------------------------------------------------------------------------- 1 | { 2 | "items": { 3 | "entries": [ 4 | "TextureNodeCoordinates", 5 | "TextureNodeCurveTime", 6 | "TextureNodeImage", 7 | "TextureNodeTexture", 8 | "TextureNodeOutput", 9 | "TextureNodeViewer", 10 | "TextureNodeHueSaturation", 11 | "TextureNodeInvert", 12 | "TextureNodeCurveRGB", 13 | "TextureNodeValToRGB", 14 | "TextureNodeDistance", 15 | "TextureNodeRGBToBW", 16 | "TextureNodeValToNor", 17 | "TextureNodeAt", 18 | "TextureNodeRotate", 19 | "TextureNodeScale", 20 | "TextureNodeTranslate", 21 | "TextureNodeBricks", 22 | "TextureNodeChecker", 23 | "TextureNodeTexBlend", 24 | "TextureNodeTexClouds", 25 | "TextureNodeTexDistNoise", 26 | "TextureNodeTexMagic", 27 | "TextureNodeTexMarble", 28 | "TextureNodeTexMusgrave", 29 | "TextureNodeTexNoise", 30 | "TextureNodeTexStucci", 31 | "TextureNodeTexVoronoi", 32 | "TextureNodeTexWood" 33 | ] 34 | }, 35 | "basic_subtypes": { 36 | "entries": [ 37 | ["TextureNodeMath", {"subtypes": ["operation"]}], 38 | ["TextureNodeCombineColor", {"subtypes": ["mode"]}], 39 | ["TextureNodeSeparateColor", {"subtypes": ["mode"]}] 40 | ] 41 | }, 42 | "mix_color": { 43 | "poll": "check_mix_color_alias", 44 | "poll_args": { 45 | "valid_options": ["MIX_COLOR", "BOTH"] 46 | }, 47 | "entries": [ 48 | ["TextureNodeMixRGB", {"label": "Mix Color", "subtypes": ["blend_type"]}] 49 | ] 50 | }, 51 | "mix_rgb": { 52 | "poll": "check_mix_color_alias", 53 | "poll_args": { 54 | "valid_options": ["DEFAULT", "MIX_RGB", "BOTH"] 55 | }, 56 | "entries": [ 57 | ["TextureNodeMixRGB", {"subtypes": ["blend_type"]}] 58 | ] 59 | }, 60 | "group_nodes": { 61 | "poll": "in_nodegroup", 62 | "entries": [ 63 | "NodeGroupInput", 64 | "NodeGroupOutput" 65 | ] 66 | }, 67 | "frame_and_reroute": { 68 | "entries": [ 69 | "NodeFrame", 70 | "NodeReroute" 71 | ] 72 | } 73 | } -------------------------------------------------------------------------------- /source/nodelists/__init__.py: -------------------------------------------------------------------------------- 1 | import itertools 2 | 3 | from . import __poll_functions__ as poll_funcs 4 | from .. import utils 5 | 6 | from bpy.types import Node 7 | from bpy.app.translations import ( 8 | pgettext_iface as iface_, 9 | contexts as i18n_contexts, 10 | ) 11 | 12 | from bpy.app import version as app_version 13 | from nodeitems_utils import node_items_iter, NodeItemCustom 14 | 15 | import bpy 16 | import json 17 | from pathlib import Path 18 | 19 | NODELIST_PATH = Path(__file__).parent 20 | 21 | settings_dict = {} 22 | vanilla_nodelist = [] 23 | vanilla_labels = set() 24 | 25 | 26 | if app_version[:2] > (3, 4): 27 | def contains_group(parent, group): 28 | return parent.contains_tree(group) 29 | else: 30 | def contains_group(parent, group): 31 | node_tree_group_type = { 32 | "CompositorNodeTree": "CompositorNodeGroup", 33 | "ShaderNodeTree": "ShaderNodeGroup", 34 | "TextureNodeTree": "TextureNodeGroup", 35 | "GeometryNodeTree": "GeometryNodeGroup", 36 | } 37 | 38 | if parent == group: 39 | return True 40 | for node in parent.nodes: 41 | if node.bl_idname in node_tree_group_type.values() and node.node_tree is not None: 42 | if contains_group(node.node_tree, group): 43 | return True 44 | return False 45 | 46 | if bpy.app.version > (4, 3): 47 | def nodegroup_settings(group): 48 | return { 49 | "node_tree": group.name, 50 | "width" : group.default_group_node_width, 51 | } 52 | else: 53 | def nodegroup_settings(group): 54 | return {"node_tree": group.name} 55 | 56 | 57 | def generate_nodegroup_entries(context): 58 | active_tree = utils.fetch_active_nodetree(context) 59 | node_groups = context.blend_data.node_groups 60 | 61 | valid_groups = ( 62 | group for group in node_groups 63 | if ( 64 | group.bl_idname == active_tree.bl_idname 65 | and group.name != active_tree.name 66 | and not contains_group(parent=group, group=active_tree) 67 | and not group.name.startswith(".") 68 | ) 69 | ) 70 | 71 | # Note - Function for converting strings like 'ShaderNodeTree' to 'ShaderNodeGroup' 72 | nodegroup_id = lambda group: group.bl_idname.removesuffix("Tree").__add__("Group") 73 | 74 | group_entries = [ 75 | generate_entry_item(nodegroup_id(group), label=group.name, settings=nodegroup_settings(group), can_cause_name_collision=True) 76 | for group in valid_groups 77 | ] 78 | 79 | return group_entries 80 | 81 | 82 | def generate_custom_node_entries(context): 83 | builtin_nodes = set(vanilla_nodelist) 84 | 85 | try: 86 | custom_node_entries = [ 87 | generate_entry_item(item.nodetype, label=item.label, settings=item.settings, can_cause_name_collision=True) 88 | for item in node_items_iter(context) if not (isinstance(item, NodeItemCustom) or item.nodetype in builtin_nodes) 89 | ] 90 | 91 | return custom_node_entries 92 | 93 | except Exception as exc: 94 | print(exc) 95 | return [] 96 | 97 | 98 | def abbreviation(label): 99 | # Note - Remove symbols like "-" "_" "()" "[]" 100 | stripped_label = label 101 | for char in ("/", "\\", "-", "_"): 102 | stripped_label = stripped_label.replace(char, " ") 103 | 104 | for char in ("*", "#"): 105 | stripped_label = stripped_label.replace(char, "") 106 | 107 | for parens in ("()", "[]", "{}"): 108 | for char in parens: 109 | stripped_label = stripped_label.replace(char, "") 110 | 111 | abbr = "".join(word[0] for word in stripped_label.split()) 112 | return f"({abbr})" 113 | 114 | 115 | def generate_label(idname=None, label=None, subtype_labels=None, can_cause_name_collision=False, is_deprecated=False): 116 | prefs = utils.fetch_user_prefs() 117 | 118 | if (label is None) and (idname is None): 119 | raise ValueError("Both idname and label inputs are None.") 120 | 121 | if label is None: 122 | bl_rna = Node.bl_rna_get_subclass(idname) 123 | if bl_rna is not None: 124 | label = bl_rna.name 125 | # label = idname #Note - Temporary for easier debugging, should change back to label 126 | else: 127 | raise ValueError(f"'{idname}' is not a valid node type.") 128 | 129 | if prefs.use_op_symbols and (subtype_labels is not None) and (idname in utils.nodes_with_op_symbols): 130 | subtype_labels = (utils.add_op_symbols(label) for label in subtype_labels) 131 | 132 | label = iface_(label) 133 | if subtype_labels is not None: 134 | subtype_string = " ".join(subtype_labels) + " > " 135 | else: 136 | subtype_string = "" 137 | 138 | if can_cause_name_collision: 139 | if label in vanilla_labels and prefs.denote_name_collisions: 140 | label = f"#{label}" 141 | else: 142 | vanilla_labels.add(label) 143 | 144 | if is_deprecated and prefs.show_deprecated == 'SHOW_AND_INDICATE': 145 | return f"[Deprecated] {subtype_string}{label} {abbreviation(label)}" 146 | else: 147 | return f"{subtype_string}{label} {abbreviation(label)}" 148 | 149 | 150 | def fetch_subtypes_from_bl_rna(node_id, name, only_include=None, exclude=None): 151 | enum_list = Node.bl_rna_get_subclass(node_id).properties[name].enum_items.values() 152 | if only_include is not None: 153 | enum_list = (item for item in enum_list if (item.name in only_include)) 154 | 155 | if exclude is not None: 156 | enum_list = (item for item in enum_list if (item.name not in exclude)) 157 | 158 | return enum_list 159 | 160 | 161 | def merge_settings(settings, subtype_settings): 162 | all_settings = {} 163 | for i in (settings, subtype_settings): 164 | if i is not None: 165 | all_settings.update(i) 166 | 167 | return all_settings 168 | 169 | 170 | def generate_entry_item( 171 | idname, label=None, function="create_node", settings=None, subtype_labels=None, subtype_settings=None, can_cause_name_collision=False, is_deprecated=False, **kwargs 172 | ): 173 | enum_label = generate_label(idname, label, subtype_labels, can_cause_name_collision, is_deprecated) 174 | identifier = str((idname, enum_label)) 175 | all_settings = merge_settings(settings, subtype_settings) 176 | 177 | settings_dict[identifier] = (idname, function, all_settings) 178 | if not can_cause_name_collision: 179 | vanilla_nodelist.append(idname) 180 | 181 | return (identifier, enum_label, "") 182 | 183 | 184 | def process_entries(context, entries, *, poll=None, poll_args=None): 185 | if poll is None: 186 | return entries, True 187 | else: 188 | if poll_args is None: 189 | poll_args = {} 190 | 191 | poll = getattr(poll_funcs, poll) 192 | return entries, poll(context, **poll_args) 193 | 194 | 195 | def filter_by_poll(context, entries): 196 | for entry in entries: 197 | entries, include = process_entries(context, **entry) 198 | if include: 199 | yield entries 200 | 201 | 202 | def is_entry_invalid(entry, properties): 203 | if properties.get("function") != "create_zone": 204 | node_data = Node.bl_rna_get_subclass(entry) 205 | 206 | if node_data is not None: 207 | settings = properties.get("settings") 208 | if settings is not None: 209 | invalid = False 210 | for prop_name, value in settings.items(): 211 | props = (prop.identifier for prop in fetch_subtypes_from_bl_rna(entry, prop_name)) 212 | if value not in props: 213 | invalid = True 214 | 215 | if invalid: 216 | print(f"Node Tabber: {entry} - {properties} is not a valid node type, entry not included in search.") 217 | return True 218 | else: 219 | print(f"Node Tabber: {entry} is not a valid node type, entry not included in search.") 220 | return True 221 | else: 222 | settings = properties["settings"] 223 | input_node_exists = Node.bl_rna_get_subclass(settings["input_type"]) is None 224 | output_node_exists = Node.bl_rna_get_subclass(settings["output_type"]) is None 225 | 226 | if input_node_exists and output_node_exists: 227 | print(f"Node Tabber: {entry} is not a valid node type, entry not included in search.") 228 | return True 229 | 230 | 231 | def get_data_from_filepath(editor_type): 232 | version_number = ".".join(map(str, app_version[:2])) 233 | filepath = NODELIST_PATH / version_number / f"{editor_type}.json" 234 | 235 | if not filepath.exists(): 236 | versions = [ 237 | tuple(map(int, f.name.split("."))) 238 | for f in NODELIST_PATH.iterdir() 239 | if f.is_dir() and f.name != "__pycache__" 240 | ] 241 | fallback_version = min(max(min(versions), app_version), max(versions)) 242 | fallback_version = ".".join(map(str, fallback_version[:2])) 243 | 244 | filepath = NODELIST_PATH / fallback_version / f"{editor_type}.json" 245 | 246 | if not filepath.exists(): 247 | raise FileNotFoundError(f"This instance of Node Tabber does not support Blender version {version_number}") 248 | else: 249 | print(f"WARNING : Node Tabber does not support editor type '{editor_type}' for Blender {version_number}'") 250 | print(f"WARNING : Using entries for version {fallback_version} instead.") 251 | 252 | with open(filepath, "r") as f: 253 | json_data = json.load(f) 254 | 255 | return json_data 256 | 257 | 258 | def generate_entries(context, editor_type): 259 | entries = [] 260 | settings_dict.clear() 261 | vanilla_nodelist.clear() 262 | vanilla_labels.clear() 263 | prefs = utils.fetch_user_prefs() 264 | 265 | json_data = get_data_from_filepath(editor_type) 266 | 267 | for item in itertools.chain(*filter_by_poll(context, json_data.values())): 268 | if isinstance(item, (tuple, list)): 269 | idname, properties, *_ = item 270 | else: 271 | idname, properties = item, {} 272 | 273 | is_deprecated = properties.get("is_deprecated", False) and bpy.app.version >= (4, 1) 274 | 275 | # Add check for skipping invalid entries to prevent the function from short-circuiting 276 | if is_entry_invalid(idname, properties) or (is_deprecated and prefs.show_deprecated == 'HIDE'): 277 | continue 278 | 279 | subtypes = properties.get("subtypes", None) 280 | only_subtypes = properties.get("only_subtypes", False) 281 | properties["is_deprecated"] = is_deprecated 282 | 283 | if not only_subtypes: 284 | entries.append(generate_entry_item(idname, **properties)) 285 | 286 | if prefs.include_subtypes and subtypes is not None: 287 | enum_list, name_list = [], [] 288 | for subtype in subtypes: 289 | if isinstance(subtype, dict): 290 | enum_list.append(fetch_subtypes_from_bl_rna(idname, **subtype)) 291 | name_list.append(subtype.get("name")) 292 | else: 293 | enum_list.append(fetch_subtypes_from_bl_rna(idname, subtype)) 294 | name_list.append(subtype) 295 | 296 | for props in itertools.product(*enum_list): 297 | subtype_labels = [iface_(prop.name) for prop in props] 298 | subtype_settings = {name: prop.identifier for (name, prop) in zip(name_list, props)} 299 | entries.append( 300 | generate_entry_item( 301 | idname, subtype_labels=subtype_labels, subtype_settings=subtype_settings, **properties 302 | ) 303 | ) 304 | 305 | entries.extend(generate_nodegroup_entries(context)) 306 | 307 | if prefs.include_external_nodes: 308 | entries.extend(generate_custom_node_entries(context)) 309 | 310 | return entries 311 | -------------------------------------------------------------------------------- /source/nodelists/__poll_functions__.py: -------------------------------------------------------------------------------- 1 | from ..utils import fetch_user_prefs 2 | 3 | ## === GENERAL POLL FUNCTIONS === 4 | def check_mix_color_alias(_context, valid_options): 5 | current_pref = fetch_user_prefs("mix_color_alias") 6 | return current_pref in valid_options 7 | 8 | 9 | def in_nodegroup(context): 10 | current_tree = context.space_data.edit_tree 11 | node_groups = context.blend_data.node_groups 12 | 13 | return current_tree in node_groups.values() 14 | 15 | 16 | ## === SHADER NODES === 17 | def engine_and_shader_type_poll(context, engines=None, exclude_engines=None, shader_types=None): 18 | current_engine = context.engine 19 | current_shader_type = context.space_data.shader_type 20 | 21 | if engines is None: 22 | engine_poll = True 23 | elif isinstance(engines, str): 24 | engine_poll = (current_engine == engines) 25 | else: 26 | engine_poll = current_engine in engines 27 | 28 | if exclude_engines is not None: 29 | if isinstance(exclude_engines, str): 30 | not_engine_poll = (current_engine != exclude_engines) 31 | else: 32 | not_engine_poll = (current_engine not in exclude_engines) 33 | 34 | engine_poll = engine_poll and not_engine_poll 35 | 36 | if shader_types is None: 37 | shader_type_poll = True 38 | elif isinstance(shader_types, str): 39 | shader_type_poll = (current_shader_type == shader_types) 40 | else: 41 | shader_type_poll = current_shader_type in shader_types 42 | 43 | return (engine_poll and shader_type_poll) 44 | 45 | 46 | ## === GEOMETRY NODES === 47 | def is_tool(context): 48 | return getattr(context.space_data, "geometry_nodes_type", None) == "TOOL" 49 | 50 | 51 | def use_experimental_volume_nodes(context): 52 | return getattr(context.preferences.experimental, "use_new_volume_nodes", False) 53 | 54 | 55 | def use_new_file_import_nodes(context): 56 | return getattr(context.preferences.experimental, "use_new_file_import_nodes", False) 57 | 58 | 59 | def use_experimental_grease_pencil_v3(context): 60 | return getattr(context.preferences.experimental, "use_grease_pencil_version3", False) 61 | 62 | 63 | def use_bundle_and_closure_nodes(context): 64 | return getattr(context.preferences.experimental, "use_bundle_and_closure_nodes", False) -------------------------------------------------------------------------------- /source/operators.py: -------------------------------------------------------------------------------- 1 | import bpy 2 | 3 | from . import nodelists, utils 4 | from bpy.types import Operator 5 | from bpy.props import EnumProperty 6 | from ..debug import profile_code 7 | 8 | # EnumProperties that are generated dynamically tend to misbehave as Python tends to clean up memory 9 | # Caching the results forces Python to keep track of the data while the operator is in use 10 | enum_callback_cache = [] 11 | 12 | 13 | def cache_enum_results(function): 14 | def wrapped_func(self, context): 15 | enum_callback_cache.clear() 16 | output = function(self, context) 17 | enum_callback_cache.extend(output) 18 | return output 19 | 20 | return wrapped_func 21 | 22 | 23 | class NODE_OT_add_tabber_search(Operator): 24 | """Add a node to the active tree""" 25 | 26 | bl_idname = "node.add_tabber_search" 27 | bl_label = "Search and Add Node" 28 | bl_options = {"REGISTER", "UNDO"} 29 | bl_property = "search_entry" 30 | 31 | @classmethod 32 | def poll(self, context): 33 | try: 34 | space = context.space_data 35 | has_tree = space.node_tree is not None 36 | is_node_editor = (space.type == "NODE_EDITOR") 37 | return has_tree and is_node_editor 38 | 39 | except AttributeError: 40 | return False 41 | 42 | @staticmethod 43 | def store_mouse_cursor(context, event): 44 | space = context.space_data 45 | if context.region.type == 'WINDOW': 46 | space.cursor_location_from_region(event.mouse_region_x, event.mouse_region_y) 47 | 48 | @cache_enum_results 49 | def define_items(self, context): 50 | prefs = utils.fetch_user_prefs() 51 | tree_type = context.space_data.tree_type 52 | 53 | items = nodelists.generate_entries(context, editor_type=tree_type) 54 | use_recent_searches = getattr(context.preferences, "use_recent_searches", False) 55 | 56 | if prefs.sort_by_tally and (not use_recent_searches): 57 | utils.sort_enum_items(tree_type, items) 58 | 59 | return items 60 | 61 | def enum(self, context): 62 | return enum_callback_cache 63 | 64 | search_entry: EnumProperty(items=enum, name="Search Entry", default=None) 65 | 66 | def modal(self, context, event): 67 | self.store_mouse_cursor(context, event) 68 | 69 | prefs = utils.fetch_user_prefs() 70 | node_type, function_name, settings = nodelists.settings_dict.get(self.search_entry) 71 | if settings is None: 72 | settings = {} 73 | 74 | self.report({"INFO"}, f"Selected: {self.search_entry} - {settings}") 75 | function = getattr(utils, function_name) 76 | nodes = function(context, node_type, **settings) 77 | 78 | if not prefs.quick_place: 79 | bpy.ops.node.translate_attach_remove_on_cancel("INVOKE_DEFAULT") 80 | 81 | utils.update_tally(context, entry=self.search_entry) 82 | return {"FINISHED"} 83 | 84 | def execute(self, context): 85 | context.window_manager.modal_handler_add(self) 86 | return {'RUNNING_MODAL'} 87 | 88 | def invoke(self, context, event): 89 | self.define_items(context) 90 | context.window_manager.invoke_search_popup(self) 91 | return {"CANCELLED"} 92 | 93 | 94 | class NODE_OT_reset_tallies(Operator): 95 | """Reset the tally count""" 96 | 97 | bl_idname = "node.reset_tallies" 98 | bl_label = "Reset Tallies" 99 | 100 | def execute(self, context): 101 | tally_path = utils.TALLY_FOLDER 102 | tally_files = tuple(tally_path.glob("*.json")) 103 | 104 | if len(tally_files) <= 0: 105 | self.report({"INFO"}, "No tallies to reset.") 106 | return {"CANCELLED"} 107 | 108 | for tally_file in tally_files: 109 | tally_file.unlink() 110 | 111 | self.report({"INFO"}, "Successfully reset tallies.") 112 | 113 | return {"FINISHED"} 114 | 115 | 116 | classes = ( 117 | NODE_OT_add_tabber_search, 118 | NODE_OT_reset_tallies 119 | ) 120 | 121 | 122 | def register(): 123 | for cls in classes: 124 | bpy.utils.register_class(cls) 125 | 126 | 127 | def unregister(): 128 | for cls in classes: 129 | bpy.utils.unregister_class(cls) 130 | -------------------------------------------------------------------------------- /source/prefs.py: -------------------------------------------------------------------------------- 1 | import bpy 2 | from bpy.types import AddonPreferences 3 | from bpy.props import BoolProperty, IntProperty, EnumProperty 4 | 5 | from .keymaps import keymap_layout 6 | 7 | 8 | class NodeTabberPreferences(AddonPreferences): 9 | bl_idname = "Node Tabber" 10 | 11 | show_keymaps : BoolProperty( 12 | name="Show Keymaps", 13 | default=False, 14 | description="When enabled, displays keymap list" 15 | ) 16 | 17 | include_subtypes: BoolProperty( 18 | name="Include Subtypes", 19 | default=True, 20 | description="Include node subtypes in search entries. Ex: Math node will include operations such as Add, Subtract, etc.", 21 | ) 22 | 23 | quick_place: BoolProperty( 24 | name='Enable "Quick Place"', 25 | default=False, 26 | description="Once a node entry is selected, immediately place it on the nodetree", 27 | ) 28 | 29 | use_op_symbols: BoolProperty( 30 | name="Use Operation Symbols", 31 | default=True, 32 | description='Add a symbol for specific math operations. Ex: "Add > Math (M)" becomes "Add (+) > Math (M)"', 33 | ) 34 | 35 | sort_by_tally: BoolProperty( 36 | name="Enable Sort By Tally", 37 | default=True, 38 | description="When enabled, more frequently used entries get place higher on search results", 39 | ) 40 | 41 | hide_group_selector: BoolProperty( 42 | name="Hide Group Selector", 43 | default=True, 44 | description="When enabled, more frequently used entries get place higher on search results", 45 | ) 46 | 47 | tally_max: IntProperty( 48 | name="Tally Max", 49 | default=35, 50 | description='Sets the maximum cap for tallies, which affects their ranking when "Sort By Tally" is enabled', 51 | min=0, 52 | soft_max=9999, 53 | ) 54 | 55 | mix_color_alias: EnumProperty( 56 | name="Mix Color Alias", 57 | items=( 58 | ("DEFAULT","Use Default Names","Keep the node names as-is. \n('Mix Color' for shaders, geometry, and compositor. 'Mix RGB for texture node editor')",), 59 | ("MIX_COLOR", "Use 'Mix Color'", "Use the label 'Mix Color' for both Mix Color and Mix RGB nodes"), 60 | ("MIX_RGB", "Use 'Mix RGB'", "Use the label 'Mix RGB' for both Mix Color and Mix RGB nodes"), 61 | ("BOTH", "Use Both Aliases", "Use both 'Mix Color' and 'Mix RGB' as valid search entries"), 62 | ), 63 | default="DEFAULT", 64 | description="Specifies how the Mix Color/Mix RGB nodes would be called across editors", 65 | ) 66 | 67 | show_deprecated: EnumProperty( 68 | name="Display Deprecated Nodes", 69 | items=( 70 | ("SHOW_AND_INDICATE", "Show and Indicate", "Show deprecated nodes, but add a mark indicating they're deprecated",), 71 | ("SHOW_ONLY", "Show Only", "Show deprecated nodes as-is, without extra indication"), 72 | ("HIDE", "Hide", "Don't display nodes if they're marked as deprecated"), 73 | ), 74 | default="SHOW_AND_INDICATE", 75 | description="Specifies how nodes that are marked as deprecated will be handled", 76 | ) 77 | 78 | include_external_nodes: BoolProperty( 79 | name="Include External Nodes", 80 | default=True, 81 | description="Include custom nodes by created by other addons in search entries. \n(Note: Only includes custom nodes that are registered as NodeItems)", 82 | ) 83 | 84 | denote_name_collisions: BoolProperty( 85 | name="Denote Name Collisions", 86 | default=True, 87 | description="Prepend a hash symbol (#) to custom external nodes that share the same name as a built-in node", 88 | ) 89 | 90 | def display_enum_prop(self, layout, prop_name): 91 | split = layout.split(factor=0.4) 92 | split.label(text=f"{self.get_prop_name(prop_name)}:") 93 | split.prop(self, prop_name, text="") 94 | 95 | def get_prop_name(self, prop_name): 96 | return self.__annotations__[prop_name].keywords["name"] 97 | 98 | def draw(self, context): 99 | layout = self.layout 100 | row = layout.split(factor=0.31) 101 | col1 = row.column(align=True) 102 | col1.label(text="Node Options:") 103 | col1.prop(self, "quick_place") 104 | col1.prop(self, "hide_group_selector") 105 | 106 | col1.separator() 107 | col1.label(text="Search Options:") 108 | col1.prop(self, "include_subtypes") 109 | if self.include_subtypes: 110 | col1.prop(self, "use_op_symbols") 111 | 112 | col1.separator() 113 | col1.prop(self, "include_external_nodes") 114 | if self.include_external_nodes: 115 | col1.prop(self, "denote_name_collisions") 116 | 117 | col2 = row.column() 118 | col2.label(text="Tally Options:") 119 | 120 | use_recent_searches = getattr(context.preferences, "use_recent_searches", False) 121 | if use_recent_searches: 122 | box = col2.box().column(align=True) 123 | box.label(icon="ERROR", text="'Sort by Most Recent' is enabled.") 124 | box.separator(factor=1) 125 | box.label(text="To enable Node Tabber's own sorting, please turn the") 126 | box.label(text="aforementioned setting off under Preferences > Interface > Display.") 127 | else: 128 | subrow = col2.row(align=True) 129 | subrow.prop(self, "sort_by_tally") 130 | subrow.prop(self, "tally_max") 131 | col2.operator("node.reset_tallies") 132 | 133 | col2.separator() 134 | subcol = col2.column() 135 | subcol.label(text="Other Options:") 136 | self.display_enum_prop(subcol, "mix_color_alias") 137 | 138 | if bpy.app.version >= (4, 1): 139 | self.display_enum_prop(subcol, "show_deprecated") 140 | 141 | keymap_layout.draw_keyboard_shorcuts(self, layout, context) 142 | 143 | 144 | keymap_layout.register_properties(preferences=NodeTabberPreferences) 145 | 146 | 147 | def register(): 148 | bpy.utils.register_class(NodeTabberPreferences) 149 | 150 | 151 | def unregister(): 152 | bpy.utils.unregister_class(NodeTabberPreferences) 153 | -------------------------------------------------------------------------------- /source/utils.py: -------------------------------------------------------------------------------- 1 | import json 2 | 3 | from bpy import context 4 | from pathlib import Path 5 | from ..debug import profile_code 6 | 7 | ADDON_FOLDER = Path(__file__).parent 8 | TALLY_FOLDER = ADDON_FOLDER / "tally_cache" 9 | 10 | # Create Folder for caching node tallies 11 | if not TALLY_FOLDER.exists(): 12 | TALLY_FOLDER.mkdir() 13 | 14 | 15 | nodes_with_op_symbols = [ 16 | "ShaderNodeMath", 17 | "CompositorNodeMath", 18 | "TextureNodeMath", 19 | "ShaderNodeVectorMath", 20 | "FunctionNodeBooleanMath", 21 | "FunctionNodeIntegerMath", 22 | "FunctionNodeCompare", 23 | ] 24 | 25 | op_symbol_dict = { 26 | "Add": "+", 27 | "Subtract": "-", 28 | "Multiply": "*", 29 | "Divide": "/", 30 | "Multiply Add": "*+", 31 | "Power": "^", 32 | "Exponent": "e^", 33 | "Less Than": "<", 34 | "Less Than or Equal": "<=", 35 | "Greater Than": ">", 36 | "Greater Than or Equal": ">=", 37 | "Scale": "*", 38 | "Cross Product": "x", 39 | "And": "^", 40 | "Or": "v", 41 | "Not": "!", 42 | "Not And": "!^", 43 | "Nor": "!v", 44 | "Equal": "=", 45 | "Not Equal": "!=", 46 | "Imply": "->", 47 | } 48 | 49 | 50 | def add_op_symbols(operation): 51 | op_symbol = op_symbol_dict.get(operation) 52 | if op_symbol is not None: 53 | return f"{operation} ({op_symbol})" 54 | 55 | return operation 56 | 57 | 58 | def fetch_tally_path(tree_type): 59 | return Path(TALLY_FOLDER, f"{tree_type}.json") 60 | 61 | 62 | def fetch_user_prefs(attr_id=None): 63 | prefs = context.preferences.addons["Node Tabber"].preferences 64 | if attr_id is None: 65 | return prefs 66 | else: 67 | return getattr(prefs, attr_id) 68 | 69 | 70 | def sort_enum_items(tree_type, items): 71 | path = fetch_tally_path(tree_type) 72 | if path.exists(): 73 | with open(path, "r") as f: 74 | tally_dict = json.load(f) 75 | 76 | items.sort(key=lambda x: tally_dict.get(x[0], 0), reverse=True) 77 | 78 | 79 | def update_tally(context, entry): 80 | prefs = fetch_user_prefs() 81 | tree_type = context.space_data.tree_type 82 | 83 | path = fetch_tally_path(tree_type) 84 | if path.exists(): 85 | with open(path, "r") as f: 86 | tally_dict = json.load(f) 87 | else: 88 | tally_dict = {} 89 | 90 | tally_dict[entry] = min(tally_dict.get(entry, 0) + 1, prefs.tally_max) 91 | 92 | with open(path, "w") as f: 93 | json.dump(tally_dict, f, indent=4) 94 | 95 | 96 | def fetch_active_nodetree(context): 97 | edit_tree = context.space_data.edit_tree 98 | node_tree = context.space_data.node_tree 99 | 100 | if edit_tree is not None: 101 | return edit_tree 102 | else: 103 | return node_tree 104 | 105 | 106 | def create_node(context, node_type=None, *_, node_tree=None, **settings): 107 | tree = fetch_active_nodetree(context) 108 | node = tree.nodes.new(type=node_type) 109 | prefs = fetch_user_prefs() 110 | 111 | try: 112 | if settings is not None: 113 | for key, value in settings.items(): 114 | setattr(node, key, value) 115 | 116 | if node_tree is not None: 117 | node.node_tree = context.blend_data.node_groups.get(node_tree) 118 | node.show_options = not prefs.hide_group_selector 119 | 120 | node.location = context.space_data.cursor_location 121 | return make_selection(context, nodes=(node,)) 122 | 123 | except Exception as error: 124 | tree.nodes.remove(node) 125 | raise error 126 | 127 | 128 | def create_zone(context, *_, input_type=None, output_type=None, offset=(150, 0), **settings,): 129 | tree = fetch_active_nodetree(context) 130 | input_node = tree.nodes.new(type=input_type) 131 | output_node = tree.nodes.new(type=output_type) 132 | link_geo_socket = settings.get("link_geo_socket", True) 133 | 134 | try: 135 | # Simulation input must be paired with the output. 136 | input_node.pair_with_output(output_node) 137 | 138 | for node in (input_node, output_node): 139 | node.location = context.space_data.cursor_location 140 | 141 | x_offset, y_offset = offset 142 | input_node.location.x -= x_offset 143 | input_node.location.y -= y_offset 144 | output_node.location.x += x_offset 145 | output_node.location.y += y_offset 146 | 147 | # Connect geometry sockets by default. 148 | # Get the sockets by their types, because the name is not guaranteed due to i18n. 149 | if link_geo_socket: 150 | from_socket = next(s for s in input_node.outputs if s.type == "GEOMETRY") 151 | to_socket = next(s for s in output_node.inputs if s.type == "GEOMETRY") 152 | tree.links.new(to_socket, from_socket) 153 | 154 | return make_selection(context, nodes=(input_node, output_node)) 155 | 156 | except Exception as error: 157 | tree.nodes.remove(input_node) 158 | tree.nodes.remove(output_node) 159 | raise error 160 | 161 | 162 | def make_selection(context, nodes): 163 | tree = fetch_active_nodetree(context) 164 | # select only the new node 165 | for n in tree.nodes: 166 | n.select = False 167 | 168 | for n in nodes: 169 | n.select = True 170 | 171 | tree.nodes.active = nodes[-1] 172 | return nodes 173 | --------------------------------------------------------------------------------