├── .gitignore ├── tstA ├── 1.0.0 │ ├── platform-windows │ │ └── arch-AMD64 │ │ │ ├── bin │ │ │ └── tstA │ │ │ └── package.py │ └── package.py └── 2.0.1 │ ├── platform-windows │ └── arch-AMD64 │ │ ├── bin │ │ └── tstA │ │ └── package.py │ └── package.py ├── tstB ├── 1.0.0 │ ├── platform-windows │ │ └── arch-AMD64 │ │ │ ├── bin │ │ │ └── tstB │ │ │ └── package.py │ └── package.py ├── 1.5.3 │ ├── platform-windows │ │ └── arch-AMD64 │ │ │ ├── bin │ │ │ └── tstB │ │ │ └── package.py │ └── package.py └── 2.1.1 │ ├── platform-windows │ └── arch-AMD64 │ │ ├── bin │ │ └── tstB │ │ └── package.py │ └── package.py ├── tstC └── 1.0.0 │ ├── platform-windows │ └── arch-AMD64 │ │ ├── bin │ │ └── tstC │ │ └── package.py │ └── package.py ├── tstD └── 1.0.0 │ ├── platform-windows │ └── arch-AMD64 │ │ ├── bin │ │ └── tstD │ │ └── package.py │ └── package.py ├── tstE └── 1.0.0 │ ├── platform-windows │ └── arch-AMD64 │ │ ├── bin │ │ └── tstE │ │ └── package.py │ └── package.py ├── vs ├── 2017 │ └── package.py ├── 2019 │ └── package.py └── 2022 │ └── package.py ├── cuda └── 11.7.0 │ ├── package.py │ └── platform-windows │ └── arch-AMD64 │ └── package.py ├── cfg ├── debug │ └── package.py └── release │ └── package.py ├── cxx11abi ├── 0 │ ├── package.py │ └── platform-linux │ │ └── arch-x86_64 │ │ └── package.py └── 1 │ ├── package.py │ └── platform-linux │ └── arch-x86_64 │ └── package.py ├── pylint └── 3.0.3 │ └── package.py ├── colour └── 0.4.3 │ └── package.py ├── numpy ├── 1.19.5 │ └── package.py ├── 1.20.3 │ └── package.py ├── 1.21.6 │ └── package.py ├── 1.22.4 │ └── package.py ├── 1.23.5 │ └── package.py └── 1.24.3 │ └── package.py ├── pyopengl ├── 3.1.6 │ └── package.py └── 3.1.7 │ └── package.py ├── markupsafe └── 2.1.1 │ └── package.py ├── jinja2 ├── 3.1.2 │ └── package.py └── 3.1.3 │ └── package.py ├── pyside2 └── 5.15.2.1 │ └── package.py ├── pyside6 └── 6.7.2 │ └── package.py ├── pyqt5 └── 5.15.7 │ └── package.py ├── vfxrp ├── 2021 │ └── package.py ├── 2022 │ └── package.py ├── 2023 │ └── package.py └── 2024 │ └── package.py ├── glew ├── 2.1.0 │ └── package.py └── 2.2.0 │ └── package.py ├── README.md ├── maya └── 2024 │ └── package.py ├── cmake ├── 3.15.6 │ └── package.py ├── 3.23.2 │ └── package.py └── 3.31.8 │ └── package.py ├── lua └── 5.4.7 │ └── package.py ├── gif └── 5.2.1 │ └── package.py ├── alembic ├── 1.8.3 │ └── package.py └── 1.7.16 │ └── package.py ├── blosc ├── 1.21.1 │ └── package.py └── 1.5.0 │ └── package.py ├── zlib └── 1.2.12 │ └── package.py ├── glut └── 3.4.0 │ └── package.py ├── devil └── 1.8.0 │ └── package.py ├── assimp └── 5.2.5 │ └── package.py ├── ffmpeg └── 5.0.1 │ └── package.py ├── glfw └── 3.3.8 │ └── package.py ├── jpegturbo └── 2.0.6 │ └── package.py ├── openjpeg └── 2.4.0 │ └── package.py ├── imath ├── 3.1.5 │ └── package.py ├── 3.0.5 │ └── package.py ├── 3.1.9 │ └── package.py └── 3.1.12 │ └── package.py ├── png └── 1.6.35 │ └── package.py ├── pybind11 ├── 2.11.1 │ └── package.py ├── 2.8.1 │ └── package.py └── 2.13.1 │ └── package.py ├── pugixml └── 1.14 │ └── package.py ├── openexr ├── 3.0.5 │ └── package.py ├── 3.2.1 │ └── package.py ├── 3.3.2 │ └── package.py ├── 3.1.5 │ └── package.py └── 2.4.2 │ └── package.py ├── tiff └── 4.3.0 │ └── package.py ├── partio └── 1.17.3 │ └── package.py ├── raw └── 0.21.0 │ └── package.py ├── materialx └── 1.38.10 │ └── package.py ├── openvdb ├── 8.2.0 │ └── package.py ├── 9.1.0 │ └── package.py ├── 10.1.0 │ └── package.py └── 11.0.0 │ └── package.py ├── boost ├── 1.82.0 │ └── package.py ├── 1.79.0 │ └── package.py ├── 1.80.0 │ └── package.py ├── 1.70.0 │ └── package.py ├── 1.73.0 │ └── package.py └── 1.76.0 │ └── package.py ├── ptex └── 2.4.2 │ └── package.py ├── neovim ├── _0.8.0 │ └── package.py └── 0.7.2 │ └── package.py ├── cgstubs └── 1.0.0 │ └── package.py ├── tbb └── 2020.3 │ └── package.py ├── osd ├── 3.4.4 │ └── package.py ├── 3.5.1 │ └── package.py └── 3.6.0 │ └── package.py ├── ocio ├── 2.2.1 │ └── package.py └── 2.3.1 │ └── package.py ├── otio └── 0.15 │ └── package.py ├── osl └── 1.13.8.0 │ └── package.py ├── python ├── 3.11.9 │ └── package.py ├── 3.10.5 │ └── package.py ├── 3.9.12 │ └── package.py └── 3.7.9 │ └── package.py ├── dusd ├── 20.08 │ └── package.py ├── 21.08 │ └── package.py └── 22.08 │ └── package.py ├── usd ├── 20.08 │ └── package.py ├── 21.08 │ └── package.py ├── 22.08 │ └── package.py ├── 22.11 │ └── package.py ├── 0-dev │ └── package.py └── 0-release │ └── package.py ├── oiio ├── 2.2.21.0 │ └── package.py ├── 2.5.7.0 │ └── package.py ├── 3.0.5.0 │ └── package.py ├── 2.1.18.0 │ └── package.py └── 2.3.16.0 │ └── package.py └── webp └── 1.1.0 └── package.py /.gitignore: -------------------------------------------------------------------------------- 1 | .vscode -------------------------------------------------------------------------------- /tstA/1.0.0/platform-windows/arch-AMD64/bin/tstA: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /tstA/2.0.1/platform-windows/arch-AMD64/bin/tstA: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /tstB/1.0.0/platform-windows/arch-AMD64/bin/tstB: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /tstB/1.5.3/platform-windows/arch-AMD64/bin/tstB: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /tstB/2.1.1/platform-windows/arch-AMD64/bin/tstB: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /tstC/1.0.0/platform-windows/arch-AMD64/bin/tstC: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /tstD/1.0.0/platform-windows/arch-AMD64/bin/tstD: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /tstE/1.0.0/platform-windows/arch-AMD64/bin/tstE: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /vs/2017/package.py: -------------------------------------------------------------------------------- 1 | name = 'vs' 2 | version = '2017' 3 | 4 | variants = [['platform-windows', 'arch-AMD64']] -------------------------------------------------------------------------------- /vs/2019/package.py: -------------------------------------------------------------------------------- 1 | name = 'vs' 2 | version = '2019' 3 | 4 | variants = [['platform-windows', 'arch-AMD64']] -------------------------------------------------------------------------------- /vs/2022/package.py: -------------------------------------------------------------------------------- 1 | name = 'vs' 2 | version = '2022' 3 | 4 | variants = [['platform-windows', 'arch-AMD64']] -------------------------------------------------------------------------------- /cuda/11.7.0/package.py: -------------------------------------------------------------------------------- 1 | name = "cuda" 2 | version = "11.7.0" 3 | 4 | build_requires = [] 5 | 6 | variants = [["platform-windows", "arch-AMD64"]] -------------------------------------------------------------------------------- /tstA/1.0.0/package.py: -------------------------------------------------------------------------------- 1 | name='tstA' 2 | version='1.0.0' 3 | 4 | variants = [["platform-linux", "arch-x86_64"], ["platform-windows", "arch-AMD64"]] -------------------------------------------------------------------------------- /tstA/2.0.1/package.py: -------------------------------------------------------------------------------- 1 | name = "tstA" 2 | version = "2.0.1" 3 | 4 | variants = [["platform-linux", "arch-x86_64"], ["platform-windows", "arch-AMD64"]] 5 | -------------------------------------------------------------------------------- /cfg/debug/package.py: -------------------------------------------------------------------------------- 1 | name = "cfg" 2 | version = "debug" 3 | 4 | build_command = False 5 | 6 | def commands(): 7 | env.REZ_BUILD_CONFIG = "debug" 8 | -------------------------------------------------------------------------------- /cfg/release/package.py: -------------------------------------------------------------------------------- 1 | name = "cfg" 2 | version = "release" 3 | 4 | build_command = False 5 | 6 | def commands(): 7 | env.REZ_BUILD_CONFIG = "release" -------------------------------------------------------------------------------- /tstB/1.0.0/package.py: -------------------------------------------------------------------------------- 1 | name = "tstB" 2 | version = "1.0.0" 3 | 4 | requires = ["tstA-1"] 5 | 6 | variants = [["platform-linux", "arch-x86_64"], ["platform-windows", "arch-AMD64"]] 7 | -------------------------------------------------------------------------------- /tstB/1.5.3/package.py: -------------------------------------------------------------------------------- 1 | name = "tstB" 2 | version = "1.5.3" 3 | 4 | requires = ["tstA-1"] 5 | 6 | variants = [["platform-linux", "arch-x86_64"], ["platform-windows", "arch-AMD64"]] 7 | -------------------------------------------------------------------------------- /tstC/1.0.0/package.py: -------------------------------------------------------------------------------- 1 | name = "tstC" 2 | version = "1.0.0" 3 | 4 | requires = ['tstB-2.1'] 5 | 6 | variants = [["platform-linux", "arch-x86_64"], ["platform-windows", "arch-AMD64"]] 7 | -------------------------------------------------------------------------------- /tstB/2.1.1/package.py: -------------------------------------------------------------------------------- 1 | name = "tstB" 2 | version = "2.1.1" 3 | 4 | requires = ["tstA-2.0.1+<2.1"] 5 | 6 | variants = [["platform-linux", "arch-x86_64"], ["platform-windows", "arch-AMD64"]] 7 | -------------------------------------------------------------------------------- /tstD/1.0.0/package.py: -------------------------------------------------------------------------------- 1 | name = "tstD" 2 | version = "1.0.0" 3 | 4 | requires = ['tstB-1.5+<2'] 5 | 6 | variants = [["platform-linux", "arch-x86_64"], ["platform-windows", "arch-AMD64"]] 7 | -------------------------------------------------------------------------------- /tstE/1.0.0/package.py: -------------------------------------------------------------------------------- 1 | name = "tstE" 2 | version = "1.0.0" 3 | 4 | requires = ['tstD-1', 'tstC'] 5 | 6 | variants = [["platform-linux", "arch-x86_64"], ["platform-windows", "arch-AMD64"]] 7 | -------------------------------------------------------------------------------- /cxx11abi/0/package.py: -------------------------------------------------------------------------------- 1 | name = "cxx11abi" 2 | version = "0" 3 | 4 | variants = [["platform-linux", "arch-x86_64"]] 5 | 6 | build_command = False 7 | 8 | def commands(): 9 | env.CXXFLAGS = "-D_GLIBCXX_USE_CXX11_ABI=0" 10 | -------------------------------------------------------------------------------- /cxx11abi/1/package.py: -------------------------------------------------------------------------------- 1 | name = "cxx11abi" 2 | version = "1" 3 | 4 | variants = [["platform-linux", "arch-x86_64"]] 5 | 6 | build_command = False 7 | 8 | def commands(): 9 | env.CXXFLAGS = "-D_GLIBCXX_USE_CXX11_ABI=1" 10 | -------------------------------------------------------------------------------- /cxx11abi/1/platform-linux/arch-x86_64/package.py: -------------------------------------------------------------------------------- 1 | name = "cxx11abi" 2 | version = "1" 3 | 4 | variants = [["platform-linux", "arch-x86_64"]] 5 | 6 | def commands(): 7 | env.CXXFLAGS = "-D_GLIBCXX_USE_CXX11_ABI=1" 8 | 9 | build_command = False -------------------------------------------------------------------------------- /cxx11abi/0/platform-linux/arch-x86_64/package.py: -------------------------------------------------------------------------------- 1 | name = "cxx11abi" 2 | version = "0" 3 | 4 | variants = [["platform-linux", "arch-x86_64"]] 5 | 6 | def commands(): 7 | env.CXXFLAGS = "-D_GLIBCXX_USE_CXX11_ABI=0" 8 | 9 | build_command = False 10 | -------------------------------------------------------------------------------- /tstB/1.5.3/platform-windows/arch-AMD64/package.py: -------------------------------------------------------------------------------- 1 | name = "tstB" 2 | version = "1.5.3" 3 | 4 | variants = [["platform-windows", "arch-AMD64"]] 5 | 6 | def cook(): 7 | import os, shutil 8 | 9 | os.makedirs(f'{root}/bin', exist_ok=True) 10 | with open(f"{root}/bin/tstB.bat", "w") as f: 11 | f.write("cmd /C echo Hello B!") 12 | 13 | shutil.copytree(f"{root}/bin", f"{install_path}/bin") 14 | shutil.copyfile(f"{root}/package.py", f"{install_root}/package.py") 15 | 16 | def commands(): 17 | env.PATH.append("{root}/bin") -------------------------------------------------------------------------------- /tstA/2.0.1/platform-windows/arch-AMD64/package.py: -------------------------------------------------------------------------------- 1 | name = "tstA" 2 | version = "2.0.1" 3 | 4 | variants = [["platform-windows", "arch-AMD64"]] 5 | 6 | def cook(): 7 | import os, shutil 8 | 9 | os.makedirs(f'{root}/bin', exist_ok=True) 10 | with open(f"{root}/bin/tstA.bat", "w") as f: 11 | f.write("cmd /C echo Hello A!") 12 | 13 | shutil.copytree(f"{root}/bin", f"{install_path}/bin") 14 | shutil.copyfile(f"{root}/package.py", f"{install_root}/package.py") 15 | 16 | 17 | def commands(): 18 | env.PATH.append("{root}/bin") -------------------------------------------------------------------------------- /tstB/1.0.0/platform-windows/arch-AMD64/package.py: -------------------------------------------------------------------------------- 1 | name = "tstB" 2 | version = "1.0.0" 3 | 4 | variants = [["platform-windows", "arch-AMD64"]] 5 | 6 | def cook(): 7 | import os, shutil 8 | 9 | os.makedirs(f'{root}/bin', exist_ok=True) 10 | with open(f"{root}/bin/tstB.bat", "w") as f: 11 | f.write("cmd /C echo Hello B!") 12 | 13 | shutil.copytree(f"{root}/bin", f"{install_path}/bin") 14 | shutil.copyfile(f"{root}/package.py", f"{install_root}/package.py") 15 | 16 | 17 | 18 | def commands(): 19 | env.PATH.append("{root}/bin") -------------------------------------------------------------------------------- /tstA/1.0.0/platform-windows/arch-AMD64/package.py: -------------------------------------------------------------------------------- 1 | from re import I 2 | 3 | 4 | name = "tstA" 5 | version = "1.0.0" 6 | 7 | variants = [["platform-windows", "arch-AMD64"]] 8 | 9 | def cook(): 10 | import os, shutil 11 | 12 | os.makedirs(f'{root}/bin', exist_ok=True) 13 | with open(f"{root}/bin/tstA.bat", "w") as f: 14 | f.write("cmd /C echo Hello A!") 15 | 16 | shutil.copytree(f"{root}/bin", f"{install_path}/bin") 17 | shutil.copyfile(f"{root}/package.py", f"{install_root}/package.py") 18 | 19 | 20 | def commands(): 21 | env.PATH.append("{root}/bin") -------------------------------------------------------------------------------- /tstC/1.0.0/platform-windows/arch-AMD64/package.py: -------------------------------------------------------------------------------- 1 | name = "tstC" 2 | version = "1.0.0" 3 | 4 | requires = ['tstB-2.1'] 5 | 6 | variants = [["platform-windows", "arch-AMD64"]] 7 | 8 | def cook(): 9 | import os, shutil 10 | 11 | os.makedirs(f'{root}/bin', exist_ok=True) 12 | with open(f"{root}/bin/tstC.bat", "w") as f: 13 | f.write("cmd /C echo Hello C!") 14 | 15 | shutil.copytree(f"{root}/bin", f"{install_path}/bin") 16 | shutil.copyfile(f"{root}/package.py", f"{install_root}/package.py") 17 | 18 | 19 | def commands(): 20 | env.PATH.append("{root}/bin") -------------------------------------------------------------------------------- /tstB/2.1.1/platform-windows/arch-AMD64/package.py: -------------------------------------------------------------------------------- 1 | name = "tstB" 2 | version = "2.1.1" 3 | 4 | requires = ["tstA-2.0.1+<2.1"] 5 | 6 | variants = [["platform-windows", "arch-AMD64"]] 7 | 8 | def cook(): 9 | import os, shutil 10 | 11 | os.makedirs(f'{root}/bin', exist_ok=True) 12 | with open(f"{root}/bin/tstB.bat", "w") as f: 13 | f.write("cmd /C echo Hello B!") 14 | 15 | shutil.copytree(f"{root}/bin", f"{install_path}/bin") 16 | shutil.copyfile(f"{root}/package.py", f"{install_root}/package.py") 17 | 18 | 19 | def commands(): 20 | env.PATH.append("{root}/bin") -------------------------------------------------------------------------------- /tstD/1.0.0/platform-windows/arch-AMD64/package.py: -------------------------------------------------------------------------------- 1 | name = "tstD" 2 | version = "1.0.0" 3 | 4 | requires = ['tstB-1.5+<2'] 5 | 6 | variants = [["platform-windows", "arch-AMD64"]] 7 | 8 | def cook(): 9 | import os, shutil 10 | 11 | os.makedirs(f'{root}/bin', exist_ok=True) 12 | with open(f"{root}/bin/tstD.bat", "w") as f: 13 | f.write("cmd /C echo Hello D!") 14 | 15 | shutil.copytree(f"{root}/bin", f"{install_path}/bin") 16 | shutil.copyfile(f"{root}/package.py", f"{install_root}/package.py") 17 | 18 | 19 | def commands(): 20 | env.PATH.append("{root}/bin") 21 | -------------------------------------------------------------------------------- /tstE/1.0.0/platform-windows/arch-AMD64/package.py: -------------------------------------------------------------------------------- 1 | name = "tstE" 2 | version = "1.0.0" 3 | 4 | requires = ['tstD-1', 'tstC'] 5 | 6 | variants = [["platform-windows", "arch-AMD64"]] 7 | 8 | def cook(): 9 | import os, shutil 10 | 11 | os.makedirs(f'{root}/bin', exist_ok=True) 12 | with open(f"{root}/bin/tstE.bat", "w") as f: 13 | f.write("cmd /C echo Hello E!") 14 | 15 | shutil.copytree(f"{root}/bin", f"{install_path}/bin") 16 | shutil.copyfile(f"{root}/package.py", f"{install_root}/package.py") 17 | 18 | 19 | def commands(): 20 | env.PATH.append("{root}/bin") 21 | -------------------------------------------------------------------------------- /pylint/3.0.3/package.py: -------------------------------------------------------------------------------- 1 | name = "pylint" 2 | version = "3.0.3" 3 | 4 | requires = [] 5 | 6 | 7 | @early() 8 | def variants(): 9 | import os, ast 10 | 11 | cook_variant = os.getenv("REZ_COOK_VARIANT") 12 | if cook_variant: 13 | # If we're building the package, we want to use the variant supplied to us 14 | return [ast.literal_eval(cook_variant)] 15 | else: 16 | # Otherwise tell rez-cook what variants we are capable of building 17 | return [ 18 | ["platform-linux", "arch-x86_64", "python"], 19 | ["platform-windows", "arch-AMD64", "python"], 20 | ] 21 | 22 | 23 | def env(var: str): 24 | import platform 25 | 26 | if platform.system() == "Windows": 27 | return f"$env:{var}" 28 | else: 29 | return f"${var}" 30 | 31 | 32 | build_command = f""" 33 | rez-env python-{env('PYTHON_VERSION')} -- python -m pip install {name}=={version} --target="{{install_path}}" --no-deps --use-pep517 34 | """ 35 | 36 | 37 | def commands(): 38 | env.PYTHONPATH.prepend("{root}") 39 | -------------------------------------------------------------------------------- /colour/0.4.3/package.py: -------------------------------------------------------------------------------- 1 | name = "colour" 2 | version = "0.4.3" 3 | 4 | requires = ["python", "numpy"] 5 | 6 | 7 | @early() 8 | def variants(): 9 | import os, ast 10 | 11 | cook_variant = os.getenv("REZ_COOK_VARIANT") 12 | if cook_variant: 13 | # If we're building the package, we want to use the variant supplied to us 14 | return [ast.literal_eval(cook_variant)] 15 | else: 16 | # Otherwise tell rez-cook what variants we are capable of building 17 | return [ 18 | ["platform-linux", "arch-x86_64", "cxx11abi", "python"], 19 | ["platform-windows", "arch-AMD64", "vs", "python"], 20 | ] 21 | 22 | 23 | def env(var: str): 24 | import platform 25 | 26 | if platform.system() == "Windows": 27 | return f"$env:{var}" 28 | else: 29 | return f"${var}" 30 | 31 | 32 | build_command = f""" 33 | rez-env python-{env('PYTHON_VERSION')} -- python -m pip install colour-science=={version} --target="{{install_path}}" --use-pep517 34 | """ 35 | 36 | 37 | def commands(): 38 | env.PYTHONPATH.prepend("{root}") 39 | -------------------------------------------------------------------------------- /numpy/1.19.5/package.py: -------------------------------------------------------------------------------- 1 | name = "numpy" 2 | version = "1.19.5" 3 | 4 | requires = ["python-3.7+"] 5 | 6 | 7 | @early() 8 | def variants(): 9 | import os, ast 10 | 11 | cook_variant = os.getenv("REZ_COOK_VARIANT") 12 | if cook_variant: 13 | # If we're building the package, we want to use the variant supplied to us 14 | return [ast.literal_eval(cook_variant)] 15 | else: 16 | # Otherwise tell rez-cook what variants we are capable of building 17 | return [ 18 | ["platform-linux", "arch-x86_64", "cxx11abi", "python"], 19 | ["platform-windows", "arch-AMD64", "vs", "python"], 20 | ] 21 | 22 | 23 | def env(var: str): 24 | import platform 25 | 26 | if platform.system() == "Windows": 27 | return f"$env:{var}" 28 | else: 29 | return f"${var}" 30 | 31 | 32 | build_command = f""" 33 | rez-env python-{env('PYTHON_VERSION')} -- python -m pip install {name}=={version} --target="{{install_path}}" --no-deps --use-pep517 34 | """ 35 | 36 | 37 | def commands(): 38 | env.PYTHONPATH.prepend("{root}") 39 | -------------------------------------------------------------------------------- /numpy/1.20.3/package.py: -------------------------------------------------------------------------------- 1 | name = "numpy" 2 | version = "1.20.3" 3 | 4 | requires = ["python-3.9+"] 5 | 6 | 7 | @early() 8 | def variants(): 9 | import os, ast 10 | 11 | cook_variant = os.getenv("REZ_COOK_VARIANT") 12 | if cook_variant: 13 | # If we're building the package, we want to use the variant supplied to us 14 | return [ast.literal_eval(cook_variant)] 15 | else: 16 | # Otherwise tell rez-cook what variants we are capable of building 17 | return [ 18 | ["platform-linux", "arch-x86_64", "cxx11abi", "python"], 19 | ["platform-windows", "arch-AMD64", "vs", "python"], 20 | ] 21 | 22 | 23 | def env(var: str): 24 | import platform 25 | 26 | if platform.system() == "Windows": 27 | return f"$env:{var}" 28 | else: 29 | return f"${var}" 30 | 31 | 32 | build_command = f""" 33 | rez-env python-{env('PYTHON_VERSION')} -- python -m pip install {name}=={version} --target="{{install_path}}" --no-deps --use-pep517 34 | """ 35 | 36 | 37 | def commands(): 38 | env.PYTHONPATH.prepend("{root}") 39 | -------------------------------------------------------------------------------- /numpy/1.21.6/package.py: -------------------------------------------------------------------------------- 1 | name = "numpy" 2 | version = "1.21.6" 3 | 4 | requires = ["python-3.9+"] 5 | 6 | 7 | @early() 8 | def variants(): 9 | import os, ast 10 | 11 | cook_variant = os.getenv("REZ_COOK_VARIANT") 12 | if cook_variant: 13 | # If we're building the package, we want to use the variant supplied to us 14 | return [ast.literal_eval(cook_variant)] 15 | else: 16 | # Otherwise tell rez-cook what variants we are capable of building 17 | return [ 18 | ["platform-linux", "arch-x86_64", "cxx11abi", "python"], 19 | ["platform-windows", "arch-AMD64", "vs", "python"], 20 | ] 21 | 22 | 23 | def env(var: str): 24 | import platform 25 | 26 | if platform.system() == "Windows": 27 | return f"$env:{var}" 28 | else: 29 | return f"${var}" 30 | 31 | 32 | build_command = f""" 33 | rez-env python-{env('PYTHON_VERSION')} -- python -m pip install {name}=={version} --target="{{install_path}}" --no-deps --use-pep517 34 | """ 35 | 36 | 37 | def commands(): 38 | env.PYTHONPATH.prepend("{root}") 39 | -------------------------------------------------------------------------------- /numpy/1.22.4/package.py: -------------------------------------------------------------------------------- 1 | name = "numpy" 2 | version = "1.22.4" 3 | 4 | requires = ["python-3.9+"] 5 | 6 | 7 | @early() 8 | def variants(): 9 | import os, ast 10 | 11 | cook_variant = os.getenv("REZ_COOK_VARIANT") 12 | if cook_variant: 13 | # If we're building the package, we want to use the variant supplied to us 14 | return [ast.literal_eval(cook_variant)] 15 | else: 16 | # Otherwise tell rez-cook what variants we are capable of building 17 | return [ 18 | ["platform-linux", "arch-x86_64", "cxx11abi", "python"], 19 | ["platform-windows", "arch-AMD64", "vs", "python"], 20 | ] 21 | 22 | 23 | def env(var: str): 24 | import platform 25 | 26 | if platform.system() == "Windows": 27 | return f"$env:{var}" 28 | else: 29 | return f"${var}" 30 | 31 | 32 | build_command = f""" 33 | rez-env python-{env('PYTHON_VERSION')} -- python -m pip install {name}=={version} --target="{{install_path}}" --no-deps --use-pep517 34 | """ 35 | 36 | 37 | def commands(): 38 | env.PYTHONPATH.prepend("{root}") 39 | -------------------------------------------------------------------------------- /numpy/1.23.5/package.py: -------------------------------------------------------------------------------- 1 | name = "numpy" 2 | version = "1.23.5" 3 | 4 | requires = ["python-3.9+"] 5 | 6 | 7 | @early() 8 | def variants(): 9 | import os, ast 10 | 11 | cook_variant = os.getenv("REZ_COOK_VARIANT") 12 | if cook_variant: 13 | # If we're building the package, we want to use the variant supplied to us 14 | return [ast.literal_eval(cook_variant)] 15 | else: 16 | # Otherwise tell rez-cook what variants we are capable of building 17 | return [ 18 | ["platform-linux", "arch-x86_64", "cxx11abi", "python"], 19 | ["platform-windows", "arch-AMD64", "vs", "python"], 20 | ] 21 | 22 | 23 | def env(var: str): 24 | import platform 25 | 26 | if platform.system() == "Windows": 27 | return f"$env:{var}" 28 | else: 29 | return f"${var}" 30 | 31 | 32 | build_command = f""" 33 | rez-env python-{env('PYTHON_VERSION')} -- python -m pip install {name}=={version} --target="{{install_path}}" --no-deps --use-pep517 34 | """ 35 | 36 | 37 | def commands(): 38 | env.PYTHONPATH.prepend("{root}") 39 | -------------------------------------------------------------------------------- /numpy/1.24.3/package.py: -------------------------------------------------------------------------------- 1 | name = "numpy" 2 | version = "1.24.3" 3 | 4 | requires = ["python-3.9+"] 5 | 6 | 7 | @early() 8 | def variants(): 9 | import os, ast 10 | 11 | cook_variant = os.getenv("REZ_COOK_VARIANT") 12 | if cook_variant: 13 | # If we're building the package, we want to use the variant supplied to us 14 | return [ast.literal_eval(cook_variant)] 15 | else: 16 | # Otherwise tell rez-cook what variants we are capable of building 17 | return [ 18 | ["platform-linux", "arch-x86_64", "cxx11abi", "python"], 19 | ["platform-windows", "arch-AMD64", "vs", "python"], 20 | ] 21 | 22 | 23 | def env(var: str): 24 | import platform 25 | 26 | if platform.system() == "Windows": 27 | return f"$env:{var}" 28 | else: 29 | return f"${var}" 30 | 31 | 32 | build_command = f""" 33 | rez-env python-{env('PYTHON_VERSION')} -- python -m pip install {name}=={version} --target="{{install_path}}" --no-deps --use-pep517 34 | """ 35 | 36 | 37 | def commands(): 38 | env.PYTHONPATH.prepend("{root}") 39 | -------------------------------------------------------------------------------- /pyopengl/3.1.6/package.py: -------------------------------------------------------------------------------- 1 | name = "pyopengl" 2 | version = "3.1.6" 3 | 4 | requires = ["python-3.7+"] 5 | 6 | 7 | @early() 8 | def variants(): 9 | import os, ast 10 | 11 | cook_variant = os.getenv("REZ_COOK_VARIANT") 12 | if cook_variant: 13 | # If we're building the package, we want to use the variant supplied to us 14 | return [ast.literal_eval(cook_variant)] 15 | else: 16 | # Otherwise tell rez-cook what variants we are capable of building 17 | return [ 18 | ["platform-linux", "arch-x86_64", "cxx11abi", "python"], 19 | ["platform-windows", "arch-AMD64", "vs", "python"], 20 | ] 21 | 22 | 23 | def env(var: str): 24 | import platform 25 | 26 | if platform.system() == "Windows": 27 | return f"$env:{var}" 28 | else: 29 | return f"${var}" 30 | 31 | 32 | build_command = f""" 33 | rez-env python-{env('PYTHON_VERSION')} -- python -m pip install {name}=={version} --target="{{install_path}}" --no-deps --use-pep517 34 | """ 35 | 36 | 37 | def commands(): 38 | env.PYTHONPATH.prepend("{root}") 39 | -------------------------------------------------------------------------------- /pyopengl/3.1.7/package.py: -------------------------------------------------------------------------------- 1 | name = "pyopengl" 2 | version = "3.1.7" 3 | 4 | requires = ["python-3.7+"] 5 | 6 | 7 | @early() 8 | def variants(): 9 | import os, ast 10 | 11 | cook_variant = os.getenv("REZ_COOK_VARIANT") 12 | if cook_variant: 13 | # If we're building the package, we want to use the variant supplied to us 14 | return [ast.literal_eval(cook_variant)] 15 | else: 16 | # Otherwise tell rez-cook what variants we are capable of building 17 | return [ 18 | ["platform-linux", "arch-x86_64", "cxx11abi", "python"], 19 | ["platform-windows", "arch-AMD64", "vs", "python"], 20 | ] 21 | 22 | 23 | def env(var: str): 24 | import platform 25 | 26 | if platform.system() == "Windows": 27 | return f"$env:{var}" 28 | else: 29 | return f"${var}" 30 | 31 | 32 | build_command = f""" 33 | rez-env python-{env('PYTHON_VERSION')} -- python -m pip install {name}=={version} --target="{{install_path}}" --no-deps --use-pep517 34 | """ 35 | 36 | 37 | def commands(): 38 | env.PYTHONPATH.prepend("{root}") 39 | -------------------------------------------------------------------------------- /markupsafe/2.1.1/package.py: -------------------------------------------------------------------------------- 1 | name = "markupsafe" 2 | version = "2.1.1" 3 | 4 | requires = ["python-3.7+"] 5 | 6 | 7 | @early() 8 | def variants(): 9 | import os, ast 10 | 11 | cook_variant = os.getenv("REZ_COOK_VARIANT") 12 | if cook_variant: 13 | # If we're building the package, we want to use the variant supplied to us 14 | return [ast.literal_eval(cook_variant)] 15 | else: 16 | # Otherwise tell rez-cook what variants we are capable of building 17 | return [ 18 | ["platform-linux", "arch-x86_64", "cxx11abi", "python"], 19 | ["platform-windows", "arch-AMD64", "vs", "python"], 20 | ] 21 | 22 | 23 | def env(var: str): 24 | import platform 25 | 26 | if platform.system() == "Windows": 27 | return f"$env:{var}" 28 | else: 29 | return f"${var}" 30 | 31 | 32 | build_command = f""" 33 | rez-env python-{env('PYTHON_VERSION')} -- python -m pip install {name}=={version} --target="{{install_path}}" --no-deps --use-pep517 34 | """ 35 | 36 | 37 | def commands(): 38 | env.PYTHONPATH.prepend("{root}") 39 | -------------------------------------------------------------------------------- /jinja2/3.1.2/package.py: -------------------------------------------------------------------------------- 1 | name = "jinja2" 2 | version = "3.1.2" 3 | 4 | requires = ["python", "markupsafe-2.1"] 5 | 6 | 7 | @early() 8 | def variants(): 9 | import os, ast 10 | 11 | cook_variant = os.getenv("REZ_COOK_VARIANT") 12 | if cook_variant: 13 | # If we're building the package, we want to use the variant supplied to us 14 | return [ast.literal_eval(cook_variant)] 15 | else: 16 | # Otherwise tell rez-cook what variants we are capable of building 17 | return [ 18 | ["platform-linux", "arch-x86_64", "cxx11abi", "python"], 19 | ["platform-windows", "arch-AMD64", "vs", "python"], 20 | ] 21 | 22 | 23 | def env(var: str): 24 | import platform 25 | 26 | if platform.system() == "Windows": 27 | return f"$env:{var}" 28 | else: 29 | return f"${var}" 30 | 31 | 32 | build_command = f""" 33 | rez-env python-{env('PYTHON_VERSION')} -- python -m pip install {name}=={version} --target="{{install_path}}" --no-deps --use-pep517 34 | """ 35 | 36 | 37 | def commands(): 38 | env.PYTHONPATH.prepend("{root}") 39 | -------------------------------------------------------------------------------- /jinja2/3.1.3/package.py: -------------------------------------------------------------------------------- 1 | name = "jinja2" 2 | version = "3.1.3" 3 | 4 | requires = ["python", "markupsafe-2.1"] 5 | 6 | 7 | @early() 8 | def variants(): 9 | import os, ast 10 | 11 | cook_variant = os.getenv("REZ_COOK_VARIANT") 12 | if cook_variant: 13 | # If we're building the package, we want to use the variant supplied to us 14 | return [ast.literal_eval(cook_variant)] 15 | else: 16 | # Otherwise tell rez-cook what variants we are capable of building 17 | return [ 18 | ["platform-linux", "arch-x86_64", "cxx11abi", "python"], 19 | ["platform-windows", "arch-AMD64", "vs", "python"], 20 | ] 21 | 22 | 23 | def env(var: str): 24 | import platform 25 | 26 | if platform.system() == "Windows": 27 | return f"$env:{var}" 28 | else: 29 | return f"${var}" 30 | 31 | 32 | build_command = f""" 33 | rez-env python-{env('PYTHON_VERSION')} -- python -m pip install {name}=={version} --target="{{install_path}}" --no-deps --use-pep517 34 | """ 35 | 36 | 37 | def commands(): 38 | env.PYTHONPATH.prepend("{root}") 39 | -------------------------------------------------------------------------------- /pyside2/5.15.2.1/package.py: -------------------------------------------------------------------------------- 1 | name = "pyside2" 2 | version = "5.15.2.1" 3 | 4 | requires = ["python-3.7+"] 5 | 6 | 7 | @early() 8 | def variants(): 9 | import os, ast 10 | 11 | cook_variant = os.getenv("REZ_COOK_VARIANT") 12 | if cook_variant: 13 | # If we're building the package, we want to use the variant supplied to us 14 | return [ast.literal_eval(cook_variant)] 15 | else: 16 | # Otherwise tell rez-cook what variants we are capable of building 17 | return [ 18 | ["platform-linux", "arch-x86_64", "cxx11abi", "python"], 19 | ["platform-windows", "arch-AMD64", "vs", "python"], 20 | ] 21 | 22 | 23 | def env(var: str): 24 | import platform 25 | 26 | if platform.system() == "Windows": 27 | return f"$env:{var}" 28 | else: 29 | return f"${var}" 30 | 31 | 32 | build_command = f""" 33 | rez-env python-{env('PYTHON_VERSION')} -- python -m pip install {name}=={version} --target="{{install_path}}" --use-pep517 34 | """ 35 | 36 | 37 | def commands(): 38 | env.PYTHONPATH.prepend("{root}") 39 | env.PATH.prepend("{root}/bin") 40 | -------------------------------------------------------------------------------- /pyside6/6.7.2/package.py: -------------------------------------------------------------------------------- 1 | name = "pyside6" 2 | version = "6.7.2" 3 | 4 | requires = ["python-3.9+<3.13"] 5 | 6 | 7 | @early() 8 | def variants(): 9 | import os, ast 10 | 11 | cook_variant = os.getenv("REZ_COOK_VARIANT") 12 | if cook_variant: 13 | # If we're building the package, we want to use the variant supplied to us 14 | return [ast.literal_eval(cook_variant)] 15 | else: 16 | # Otherwise tell rez-cook what variants we are capable of building 17 | return [ 18 | ["platform-linux", "arch-x86_64", "cxx11abi", "python"], 19 | ["platform-windows", "arch-AMD64", "vs", "python"], 20 | ] 21 | 22 | 23 | def env(var: str): 24 | import platform 25 | 26 | if platform.system() == "Windows": 27 | return f"$env:{var}" 28 | else: 29 | return f"${var}" 30 | 31 | 32 | build_command = f""" 33 | rez-env python-{env('PYTHON_VERSION')} -- python -m pip install {name}=={version} --target="{{install_path}}" --use-pep517 34 | """ 35 | 36 | 37 | def commands(): 38 | env.PYTHONPATH.prepend("{root}") 39 | env.PATH.prepend("{root}/bin") 40 | -------------------------------------------------------------------------------- /pyqt5/5.15.7/package.py: -------------------------------------------------------------------------------- 1 | name = "pyqt5" 2 | version = "5.15.7" 3 | 4 | requires = ["python-3.7+"] 5 | 6 | 7 | @early() 8 | def variants(): 9 | import os, ast 10 | 11 | cook_variant = os.getenv("REZ_COOK_VARIANT") 12 | if cook_variant: 13 | # If we're building the package, we want to use the variant supplied to us 14 | return [ast.literal_eval(cook_variant)] 15 | else: 16 | # Otherwise tell rez-cook what variants we are capable of building 17 | return [ 18 | ["platform-linux", "arch-x86_64", "cxx11abi", "python"], 19 | ["platform-windows", "arch-AMD64", "vs", "python"], 20 | ] 21 | 22 | 23 | def env(var: str): 24 | import platform 25 | 26 | if platform.system() == "Windows": 27 | return f"$env:{var}" 28 | else: 29 | return f"${var}" 30 | 31 | 32 | build_command = f""" 33 | rez-env python-{env('PYTHON_VERSION')} -- python -m pip install {name}=={version} --target="{{install_path}}" --no-deps --use-pep517 34 | """ 35 | 36 | 37 | def commands(): 38 | env.PYTHONPATH.prepend("{root}") 39 | env.PATH.prepend("{root}/bin") 40 | -------------------------------------------------------------------------------- /vfxrp/2022/package.py: -------------------------------------------------------------------------------- 1 | name = "vfxrp" 2 | version = "2022" 3 | 4 | 5 | @early() 6 | def requires(): 7 | req = [ 8 | "python-3.9", 9 | "pyqt5-5.15", 10 | "pyside2-5.15", 11 | "numpy-1.20", 12 | "openexr-3.1", 13 | "ptex-2.4", 14 | "osd-3.4", 15 | "openvdb-9", 16 | "alembic-1.8", 17 | "ocio-2.1", 18 | "boost-1.76", 19 | "tbb-2020.3", 20 | ] 21 | 22 | import platform 23 | if platform.system() == "Windows": 24 | req += ["vs-2019"] 25 | else: 26 | req += ["cxx11abi-0"] 27 | 28 | return req 29 | 30 | @early() 31 | def variants(): 32 | import os, ast 33 | 34 | cook_variant = os.getenv("REZ_COOK_VARIANT") 35 | if cook_variant: 36 | # If we're building the package, we want to use the variant supplied to us 37 | return [ast.literal_eval(cook_variant)] 38 | else: 39 | # Otherwise tell rez-cook what variants we are capable of building 40 | return [ 41 | ["platform-linux", "arch-x86_64", "cfg"], 42 | ["platform-windows", "arch-AMD64", "cfg"], 43 | ] 44 | 45 | -------------------------------------------------------------------------------- /vfxrp/2023/package.py: -------------------------------------------------------------------------------- 1 | name = "vfxrp" 2 | version = "2023" 3 | 4 | 5 | @early() 6 | def requires(): 7 | req = [ 8 | "python-3.10", 9 | "pyqt5-5.15", 10 | "pyside2-5.15", 11 | "numpy-1.23", 12 | "openexr-3.1", 13 | "ptex-2.4", 14 | "osd-3.5", 15 | "openvdb-10", 16 | "alembic-1.8", 17 | "ocio-2.2", 18 | "boost-1.80", 19 | "tbb-2020.3", 20 | ] 21 | 22 | import platform 23 | if platform.system() == "Windows": 24 | req += ["vs-2022"] 25 | else: 26 | req += ["cxx11abi-1"] 27 | 28 | return req 29 | 30 | 31 | @early() 32 | def variants(): 33 | import os, ast 34 | 35 | cook_variant = os.getenv("REZ_COOK_VARIANT") 36 | if cook_variant: 37 | # If we're building the package, we want to use the variant supplied to us 38 | return [ast.literal_eval(cook_variant)] 39 | else: 40 | # Otherwise tell rez-cook what variants we are capable of building 41 | return [ 42 | ["platform-linux", "arch-x86_64", "cfg"], 43 | ["platform-windows", "arch-AMD64", "cfg"], 44 | ] 45 | -------------------------------------------------------------------------------- /vfxrp/2024/package.py: -------------------------------------------------------------------------------- 1 | name = "vfxrp" 2 | version = "2024" 3 | 4 | 5 | @early() 6 | def requires(): 7 | req = [ 8 | "python-3.11", 9 | "pyqt5-6.5", 10 | "pyside2-6.5", 11 | "numpy-1.24", 12 | "openexr-3.2", 13 | "ptex-2.4", 14 | "osd-3.6", 15 | "openvdb-11", 16 | "alembic-1.8", 17 | "ocio-2.3", 18 | "boost-1.82", 19 | "tbb-2020.3", 20 | ] 21 | 22 | import platform 23 | if platform.system() == "Windows": 24 | req += ["vs-2022"] 25 | else: 26 | req += ["cxx11abi-1"] 27 | 28 | return req 29 | 30 | 31 | @early() 32 | def variants(): 33 | import os, ast 34 | 35 | cook_variant = os.getenv("REZ_COOK_VARIANT") 36 | if cook_variant: 37 | # If we're building the package, we want to use the variant supplied to us 38 | return [ast.literal_eval(cook_variant)] 39 | else: 40 | # Otherwise tell rez-cook what variants we are capable of building 41 | return [ 42 | ["platform-linux", "arch-x86_64", "cfg"], 43 | ["platform-windows", "arch-AMD64", "cfg"], 44 | ] 45 | -------------------------------------------------------------------------------- /vfxrp/2021/package.py: -------------------------------------------------------------------------------- 1 | name = "vfxrp" 2 | version = "2021" 3 | 4 | 5 | @early() 6 | def requires(): 7 | req = [ 8 | "python-3.7", 9 | "pyqt5-5.15", 10 | "pyside2-5.15", 11 | "numpy-1.19", 12 | "openexr-3", # These aren't legit, but the whole 2->3 bifurcation is a PITA 13 | "imath-3", 14 | "ptex-2.3+", # should be 2.3 but building it on windows is a PITA 15 | "osd-3.4", 16 | "openvdb-8", 17 | "alembic-1.8", # Neither is this legit 18 | "ocio-2.0", 19 | "boost-1.73", 20 | "tbb-2020.2+", 21 | ] 22 | 23 | import platform 24 | if platform.system() == "Windows": 25 | req += ["vs-2017", "platform-windows", "arch-AMD64"] 26 | else: 27 | req += ["cxx11abi-0", "platform-linux", "arch-x86_64"] 28 | 29 | return req 30 | 31 | @early() 32 | def variants(): 33 | import os, ast 34 | 35 | cook_variant = os.getenv("REZ_COOK_VARIANT") 36 | if cook_variant: 37 | # If we're building the package, we want to use the variant supplied to us 38 | return [ast.literal_eval(cook_variant)] 39 | else: 40 | # Otherwise tell rez-cook what variants we are capable of building 41 | return [ 42 | ["platform-linux", "arch-x86_64", "cfg"], 43 | ["platform-windows", "arch-AMD64", "cfg"], 44 | ] 45 | 46 | -------------------------------------------------------------------------------- /glew/2.1.0/package.py: -------------------------------------------------------------------------------- 1 | name = "glew" 2 | version = "2.1.0" 3 | 4 | @early() 5 | def build_requires(): 6 | import platform 7 | 8 | if platform.system() == "Windows": 9 | return ["cmake", "vs"] 10 | else: 11 | return ["cmake"] 12 | 13 | 14 | @early() 15 | def variants(): 16 | import os, ast 17 | 18 | cook_variant = os.getenv("REZ_COOK_VARIANT") 19 | if cook_variant: 20 | # If we're building the package, we want to use the variant supplied to us 21 | return [ast.literal_eval(cook_variant)] 22 | else: 23 | # Otherwise tell rez-cook what variants we are capable of building 24 | return [ 25 | ["platform-linux", "arch-x86_64", "cxx11abi", "cfg"], 26 | ["platform-windows", "arch-AMD64", "vs", "cfg"], 27 | ] 28 | 29 | def commands(): 30 | env.GLEW_ROOT = "{root}" 31 | env.CMAKE_PREFIX_PATH.prepend("{root}") 32 | env.PATH.prepend("{root}/bin") 33 | 34 | import platform 35 | if platform.system() == "Linux": 36 | env.LD_LIBRARY_PATH.prepend("{root}/lib") 37 | 38 | 39 | build_command = """ 40 | cd {root}/build 41 | mkdir build && cd build 42 | cmake ../cmake -GNinja -DCMAKE_INSTALL_PREFIX={install_path} -DCMAKE_BUILD_TYPE=Release && ninja install 43 | """ 44 | 45 | 46 | def pre_cook(): 47 | download_and_unpack(f"https://github.com/nigels-com/glew/releases/download/glew-{version}/glew-{version}.zip") 48 | -------------------------------------------------------------------------------- /glew/2.2.0/package.py: -------------------------------------------------------------------------------- 1 | name = "glew" 2 | version = "2.2.0" 3 | 4 | @early() 5 | def build_requires(): 6 | import platform 7 | 8 | if platform.system() == "Windows": 9 | return ["cmake", "vs"] 10 | else: 11 | return ["cmake"] 12 | 13 | 14 | @early() 15 | def variants(): 16 | import os, ast 17 | 18 | cook_variant = os.getenv("REZ_COOK_VARIANT") 19 | if cook_variant: 20 | # If we're building the package, we want to use the variant supplied to us 21 | return [ast.literal_eval(cook_variant)] 22 | else: 23 | # Otherwise tell rez-cook what variants we are capable of building 24 | return [ 25 | ["platform-linux", "arch-x86_64", "cxx11abi", "cfg"], 26 | ["platform-windows", "arch-AMD64", "vs", "cfg"], 27 | ] 28 | 29 | def commands(): 30 | env.GLEW_ROOT = "{root}" 31 | env.CMAKE_PREFIX_PATH.prepend("{root}") 32 | env.PATH.prepend("{root}/bin") 33 | 34 | import platform 35 | if platform.system() == "Linux": 36 | env.LD_LIBRARY_PATH.prepend("{root}/lib") 37 | 38 | 39 | build_command = """ 40 | cd {root}/build 41 | mkdir build && cd build 42 | cmake ../cmake -GNinja -DCMAKE_INSTALL_PREFIX={install_path} -DCMAKE_BUILD_TYPE=Release && ninja install 43 | """ 44 | 45 | 46 | def pre_cook(): 47 | download_and_unpack(f"https://github.com/nigels-com/glew/releases/download/glew-{version}/glew-{version}.zip") 48 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | Ubuntu 20 pre-requisites: 2 | ```bash 3 | sudo apt install build-essential cmake automake autotools-dev libtool pkg-config libfreetype-dev ffmpeg libavcodec-dev libavdevice-dev libavfilter-dev libavformat-dev libavresample-dev libavutil-dev libheif-dev libdcmtk-dev xmlto ninja-build xrandr-dev xorg-dev ssl-dev libffi-dev libglu1-mesa-dev libosmesa6-dev freeglut3-dev libxcb-icccm4 libxcb-randr0-dev libxcb-xtest0-dev libxcb-xinerama0-dev libxcb-shape0-dev libxcb-xkb-dev libxkbcommon-x11-dev libxcb-xinput0 libxcb-xkb1l libxcb-screensaver0 libxcb-util0 libxcb-image0 libxcb-cursor0 libxcb-xinerama0 libffi-dev libgl1-mesa-dev ninja-build libxxf86vm-dev libxcb-cursor-dev libxcursor-dev libxinerama-dev libxi-dev libglu1-mesa-dev python3-dev ninja-build 4 | ``` 5 | 6 | Ubuntu 22 pre-requisites: 7 | ``` 8 | sudo apt install build-essential cmake automake autotools-dev libtool pkg-config libfreetype-dev ffmpeg libavcodec-dev libavdevice-dev libavfilter-dev libavformat-dev libavutil-dev libheif-dev libdcmtk-dev xmlto ninja-build xorg-dev libssl-dev libffi-dev libglu1-mesa-dev libosmesa6-dev freeglut3-dev libxcb-icccm4 libxcb-randr0-dev libxcb-xtest0-dev libxcb-xinerama0-dev libxcb-shape0-dev libxcb-xkb-dev libxkbcommon-x11-dev libxcb-xinput0 libxcb-xkb-dev libxcb-screensaver0 libxcb-util-dev libxcb-image0 libxcb-cursor0 libxcb-xinerama0 libffi-dev libgl1-mesa-dev ninja-build libxxf86vm-dev libxcb-cursor-dev libxcursor-dev libxinerama-dev libxi-dev libglu1-mesa-dev python3-dev libxrandr-dev ninja-build 9 | ``` 10 | -------------------------------------------------------------------------------- /maya/2024/package.py: -------------------------------------------------------------------------------- 1 | name = "maya" 2 | version = "2024" 3 | 4 | 5 | @early() 6 | def variants(): 7 | import os, ast 8 | 9 | cook_variant = os.getenv("REZ_COOK_VARIANT") 10 | if cook_variant: 11 | # If we're building the package, we want to use the variant supplied to us 12 | return [ast.literal_eval(cook_variant)] 13 | else: 14 | # Otherwise tell rez-cook what variants we are capable of building 15 | return [ 16 | ["platform-linux"], 17 | ["platform-windows"], 18 | ] 19 | 20 | 21 | def env(var: str): 22 | import platform 23 | 24 | if platform.system() == "Windows": 25 | return f"$env:{var}" 26 | else: 27 | return f"${var}" 28 | 29 | 30 | def pre_cook(): 31 | import os 32 | 33 | unpack( 34 | os.path.expanduser(f"~/Downloads/Autodesk_Maya_{version}-Linux_64bit.tgz"), 35 | extract_dir=build_path, 36 | ) 37 | 38 | 39 | build_command = ( 40 | "{build_path}/houdini.install " 41 | "--accept-EULA 2021-10-13 " 42 | "--no-install-menus " 43 | "--no-install-bin-symlink " 44 | "--no-install-hfs-symlink " 45 | "--no-install-license " 46 | "--no-install-hqueue-server " 47 | "--no-root-check " 48 | "--install-houdini " 49 | "--install-sidefxlabs " 50 | "--install-engine-maya " 51 | "--install-engine-unity " 52 | "--auto-install " 53 | "--make-dir " 54 | "{install_path}" 55 | ) 56 | 57 | 58 | def commands(): 59 | env.PYTHONPATH.prepend("{root}") 60 | env.PATH.prepend("{root}/bin") 61 | -------------------------------------------------------------------------------- /cmake/3.15.6/package.py: -------------------------------------------------------------------------------- 1 | name = "cmake" 2 | version = "3.15.6" 3 | 4 | @early() 5 | def build_requires(): 6 | import platform 7 | 8 | if platform.system() == "Windows": 9 | return ["vs"] 10 | else: 11 | return [] 12 | 13 | 14 | @early() 15 | def variants(): 16 | import os, ast 17 | 18 | cook_variant = os.getenv("REZ_COOK_VARIANT") 19 | if cook_variant: 20 | # If we're building the package, we want to use the variant supplied to us 21 | return [ast.literal_eval(cook_variant)] 22 | else: 23 | # Otherwise tell rez-cook what variants we are capable of building 24 | return [ 25 | ["platform-linux", "arch-x86_64"], 26 | ["platform-windows", "arch-AMD64"], 27 | ] 28 | 29 | 30 | def commands(): 31 | env.PATH.prepend("{root}/bin") 32 | 33 | 34 | def pre_cook(): 35 | import platform 36 | 37 | if platform.system() == "Windows": 38 | archive = f"cmake-{version}-win64-x64.zip" 39 | else: 40 | archive = f"cmake-{version}-Linux-x86_64.tar.gz" 41 | 42 | download_and_unpack( 43 | f"https://github.com/Kitware/CMake/releases/download/v{version}/{archive}", 44 | move_up=False, 45 | ) 46 | 47 | 48 | @early() 49 | def build_command(): 50 | import platform 51 | 52 | if platform.system() == "Windows": 53 | return f"Move-Item -Path $env:REZ_BUILD_SOURCE_PATH/cmake-{version}-win64-x64/* -Destination $env:REZ_BUILD_INSTALL_PATH" 54 | else: 55 | return f"mv $REZ_BUILD_SOURCE_PATH/cmake-{version}-Linux-x86_64/* $REZ_BUILD_INSTALL_PATH" 56 | -------------------------------------------------------------------------------- /lua/5.4.7/package.py: -------------------------------------------------------------------------------- 1 | name = "lua" 2 | version = "5.4.7" 3 | 4 | requires = [] 5 | 6 | 7 | @early() 8 | def build_requires(): 9 | import platform 10 | 11 | if platform.system() == "Windows": 12 | return ["cmake", "vs"] 13 | else: 14 | return ["cmake"] 15 | 16 | 17 | @early() 18 | def variants(): 19 | import os, ast 20 | 21 | cook_variant = os.getenv("REZ_COOK_VARIANT") 22 | if cook_variant: 23 | # If we're building the package, we want to use the variant supplied to us 24 | return [ast.literal_eval(cook_variant)] 25 | else: 26 | # Otherwise tell rez-cook what variants we are capable of building 27 | return [ 28 | ["platform-linux", "arch-x86_64", "cxx11abi", "cfg"], 29 | ["platform-windows", "arch-AMD64", "vs", "cfg"], 30 | ] 31 | 32 | 33 | def commands(): 34 | env.LUA_ROOT = "{root}" 35 | env.PATH.prepend("{root}/bin") 36 | env.CMAKE_PREFIX_PATH.append("{root}/bin") 37 | 38 | import platform 39 | 40 | if platform.system() == "Linux": 41 | env.LD_LIBRARY_PATH.prepend("{root}/lib") 42 | env.PKG_CONFIG_PATH.prepend("{root}/lib/pkgconfig") 43 | 44 | 45 | def env(var: str): 46 | import platform 47 | 48 | if platform.system() == "Windows": 49 | return f"$env:{var}" 50 | else: 51 | return f"${var}" 52 | 53 | 54 | build_command = ( 55 | "cd .. && make install INSTALL_TOP={install_path}" 56 | ) 57 | 58 | 59 | def pre_cook(): 60 | download_and_unpack( 61 | f"https://www.lua.org/ftp/lua-5.4.7.tar.gz" 62 | ) 63 | 64 | -------------------------------------------------------------------------------- /cmake/3.23.2/package.py: -------------------------------------------------------------------------------- 1 | name = "cmake" 2 | version = "3.23.2" 3 | 4 | 5 | @early() 6 | def build_requires(): 7 | import platform 8 | 9 | if platform.system() == "Windows": 10 | return ["vs"] 11 | else: 12 | return [] 13 | 14 | 15 | @early() 16 | def variants(): 17 | import os, ast 18 | 19 | cook_variant = os.getenv("REZ_COOK_VARIANT") 20 | if cook_variant: 21 | # If we're building the package, we want to use the variant supplied to us 22 | return [ast.literal_eval(cook_variant)] 23 | else: 24 | # Otherwise tell rez-cook what variants we are capable of building 25 | return [ 26 | ["platform-linux", "arch-x86_64"], 27 | ["platform-windows", "arch-AMD64"], 28 | ] 29 | 30 | 31 | def commands(): 32 | env.PATH.prepend("{root}/bin") 33 | 34 | 35 | def pre_cook(): 36 | import platform 37 | 38 | if platform.system() == "Windows": 39 | archive = f"cmake-{version}-windows-x86_64.zip" 40 | else: 41 | archive = f"cmake-{version}-linux-x86_64.tar.gz" 42 | 43 | download_and_unpack( 44 | f"https://github.com/Kitware/CMake/releases/download/v{version}/{archive}", 45 | move_up=False, 46 | ) 47 | 48 | 49 | @early() 50 | def build_command(): 51 | import platform 52 | 53 | if platform.system() == "Windows": 54 | return f"Move-Item -Path $env:REZ_BUILD_SOURCE_PATH/cmake-{version}-windows-x86_64/* -Destination $env:REZ_BUILD_INSTALL_PATH" 55 | else: 56 | return f"mv $REZ_BUILD_SOURCE_PATH/cmake-{version}-linux-x86_64/* $REZ_BUILD_INSTALL_PATH" 57 | -------------------------------------------------------------------------------- /cmake/3.31.8/package.py: -------------------------------------------------------------------------------- 1 | name = "cmake" 2 | version = "3.31.8" 3 | 4 | 5 | @early() 6 | def build_requires(): 7 | import platform 8 | 9 | if platform.system() == "Windows": 10 | return ["vs"] 11 | else: 12 | return [] 13 | 14 | 15 | @early() 16 | def variants(): 17 | import os, ast 18 | 19 | cook_variant = os.getenv("REZ_COOK_VARIANT") 20 | if cook_variant: 21 | # If we're building the package, we want to use the variant supplied to us 22 | return [ast.literal_eval(cook_variant)] 23 | else: 24 | # Otherwise tell rez-cook what variants we are capable of building 25 | return [ 26 | ["platform-linux", "arch-x86_64"], 27 | ["platform-windows", "arch-AMD64"], 28 | ] 29 | 30 | 31 | def commands(): 32 | env.PATH.prepend("{root}/bin") 33 | 34 | 35 | def pre_cook(): 36 | import platform 37 | 38 | if platform.system() == "Windows": 39 | archive = f"cmake-{version}-windows-x86_64.zip" 40 | else: 41 | archive = f"cmake-{version}-linux-x86_64.tar.gz" 42 | 43 | download_and_unpack( 44 | f"https://github.com/Kitware/CMake/releases/download/v{version}/{archive}", 45 | move_up=False, 46 | ) 47 | 48 | 49 | @early() 50 | def build_command(): 51 | import platform 52 | 53 | if platform.system() == "Windows": 54 | return f"Move-Item -Path $env:REZ_BUILD_SOURCE_PATH/cmake-{version}-windows-x86_64/* -Destination $env:REZ_BUILD_INSTALL_PATH" 55 | else: 56 | return f"mv $REZ_BUILD_SOURCE_PATH/cmake-{version}-linux-x86_64/* $REZ_BUILD_INSTALL_PATH" 57 | -------------------------------------------------------------------------------- /cuda/11.7.0/platform-windows/arch-AMD64/package.py: -------------------------------------------------------------------------------- 1 | name = "cuda" 2 | version = "11.7.0" 3 | 4 | 5 | @early() 6 | def variants(): 7 | import os, ast 8 | variant = ast.literal_eval(os.getenv("REZ_COOK_VARIANT")) 9 | return [variant] 10 | 11 | 12 | def commands(): 13 | env.PATH.prepend("{root}/bin") 14 | env.CUDA_PATH = "{root}" 15 | env.CUDA_DIR = "{root}" 16 | env.CUDA_TOOLKIT_PATH = "{root}" 17 | env.CUDA_TOOLKIT_DIR = "{root}" 18 | env.CUDA_TOOLKIT_ROOT = "{root}" 19 | 20 | 21 | build_command = """ 22 | echo 'Nothing to do' 23 | """ 24 | 25 | def pre_cook(): 26 | import os 27 | 28 | fn = download(f"https://developer.download.nvidia.com/compute/cuda/11.7.0/local_installers/cuda_11.7.0_516.01_windows.exe") 29 | print("") 30 | print("") 31 | print("================================================================================") 32 | print("={:^78s}=".format("WARNING")) 33 | print("= =") 34 | print("= Cannot automatically install CUDA on Windows, please use the downloaded =") 35 | print("= installer located at: =") 36 | print(f"={os.path.join(os.getcwd(), fn):^78s}=") 37 | print("= to install manually to the following path: =") 38 | print(f"={install_path:^78s}=") 39 | print("= =") 40 | print("================================================================================") 41 | print("") 42 | print("") 43 | 44 | 45 | -------------------------------------------------------------------------------- /gif/5.2.1/package.py: -------------------------------------------------------------------------------- 1 | name = "gif" 2 | version = "5.2.1" 3 | 4 | 5 | @early() 6 | def build_requires(): 7 | import platform 8 | 9 | if platform.system() == "Windows": 10 | return ["cmake", "vs"] 11 | else: 12 | return ["cmake"] 13 | 14 | 15 | @early() 16 | def variants(): 17 | import os, ast 18 | 19 | cook_variant = os.getenv("REZ_COOK_VARIANT") 20 | if cook_variant: 21 | # If we're building the package, we want to use the variant supplied to us 22 | return [ast.literal_eval(cook_variant)] 23 | else: 24 | # Otherwise tell rez-cook what variants we are capable of building 25 | return [ 26 | ["platform-linux", "arch-x86_64", "cxx11abi", "cfg"], 27 | ["platform-windows", "arch-AMD64", "vs", "cfg"], 28 | ] 29 | 30 | 31 | def commands(): 32 | import platform 33 | 34 | env.GIF_ROOT = "{root}" 35 | env.GIF_DIR = "{root}" 36 | env.PATH.prepend("{root}/bin") 37 | 38 | if platform.system() == "Linux": 39 | env.LD_LIBRARY_PATH.prepend("{root}/lib") 40 | 41 | 42 | def env(var: str): 43 | import platform 44 | if platform.system() == "Windows": 45 | return f"$env:{var}" 46 | else: 47 | return f"${var}" 48 | 49 | config_args = [ 50 | "cmake", 51 | "{root}", 52 | "-DCMAKE_INSTALL_PREFIX={install_path}", 53 | f'-DCMAKE_MODULE_PATH="{env("CMAKE_MODULE_PATH")}"', 54 | f'-DCMAKE_BUILD_TYPE="{env("REZ_BUILD_CONFIG")}"', 55 | " -G Ninja", 56 | ] 57 | 58 | build_command = ( 59 | " ".join(config_args) 60 | + f" && cmake --build . --target install --config {env('REZ_BUILD_CONFIG')}" 61 | ) 62 | 63 | 64 | def pre_cook(): 65 | fetch_repository("https://gitlab.com/anderslanglands/giflib.git") 66 | -------------------------------------------------------------------------------- /alembic/1.8.3/package.py: -------------------------------------------------------------------------------- 1 | name = "alembic" 2 | version = "1.8.3" 3 | 4 | requires = ["imath"] 5 | 6 | @early() 7 | def build_requires(): 8 | import platform 9 | 10 | if platform.system() == "Windows": 11 | return ["cmake", "vs"] 12 | else: 13 | return ["cmake"] 14 | 15 | 16 | @early() 17 | def variants(): 18 | import os, ast 19 | 20 | cook_variant = os.getenv("REZ_COOK_VARIANT") 21 | if cook_variant: 22 | # If we're building the package, we want to use the variant supplied to us 23 | return [ast.literal_eval(cook_variant)] 24 | else: 25 | # Otherwise tell rez-cook what variants we are capable of building 26 | req = ["cfg", "imath-3"] 27 | return [x + req for x in [ 28 | ["platform-linux", "arch-x86_64", "cxx11abi"], 29 | ["platform-windows", "arch-AMD64", "vs"], 30 | ] 31 | ] 32 | 33 | 34 | 35 | def commands(): 36 | import platform 37 | 38 | env.ALEMBIC_ROOT = "{root}" 39 | env.ALEMBIC_DIR = "{root}" 40 | env.CMAKE_PREFIX_PATH.prepend("{root}") 41 | env.PATH.prepend("{root}/bin") 42 | 43 | if platform.system() == "Linux": 44 | env.LD_LIBRARY_PATH.prepend("{root}/lib") 45 | 46 | 47 | config_args = [ 48 | "cmake", 49 | "{root}", 50 | "-DCMAKE_INSTALL_PREFIX={install_path}", 51 | "-DCMAKE_MODULE_PATH=$env:CMAKE_MODULE_PATH", 52 | "-DCMAKE_BUILD_TYPE=Release", 53 | "-DUSE_TESTS=OFF", 54 | "-DUSE_PYALEMBIC=OFF", 55 | " -G Ninja", 56 | ] 57 | 58 | build_command = ( 59 | " ".join(config_args) + " && cmake --build . --target install --config Release" 60 | ) 61 | 62 | 63 | def pre_cook(): 64 | download_and_unpack( 65 | f"https://github.com/alembic/alembic/archive/refs/tags/{version}.zip" 66 | ) 67 | -------------------------------------------------------------------------------- /alembic/1.7.16/package.py: -------------------------------------------------------------------------------- 1 | name = "alembic" 2 | version = "1.7.16" 3 | 4 | requires = ["openexr-2.4+<3"] 5 | 6 | @early() 7 | def build_requires(): 8 | import platform 9 | 10 | if platform.system() == "Windows": 11 | return ["cmake", "vs"] 12 | else: 13 | return ["cmake"] 14 | 15 | 16 | @early() 17 | def variants(): 18 | import os, ast 19 | 20 | cook_variant = os.getenv("REZ_COOK_VARIANT") 21 | if cook_variant: 22 | # If we're building the package, we want to use the variant supplied to us 23 | return [ast.literal_eval(cook_variant)] 24 | else: 25 | # Otherwise tell rez-cook what variants we are capable of building 26 | req = ["cfg", "openexr"] 27 | return [x + req for x in [ 28 | ["platform-linux", "arch-x86_64", "cxx11abi"], 29 | ["platform-windows", "arch-AMD64", "vs"], 30 | ] 31 | ] 32 | 33 | 34 | 35 | def commands(): 36 | import platform 37 | 38 | env.ALEMBIC_ROOT = "{root}" 39 | env.ALEMBIC_DIR = "{root}" 40 | env.CMAKE_PREFIX_PATH.prepend("{root}") 41 | env.PATH.prepend("{root}/bin") 42 | 43 | if platform.system() == "Linux": 44 | env.LD_LIBRARY_PATH.prepend("{root}/lib") 45 | 46 | 47 | config_args = [ 48 | "cmake", 49 | "{root}", 50 | "-DCMAKE_INSTALL_PREFIX={install_path}", 51 | "-DCMAKE_MODULE_PATH=$env:CMAKE_MODULE_PATH", 52 | "-DCMAKE_BUILD_TYPE=Release", 53 | "-DUSE_TESTS=OFF", 54 | "-DUSE_PYALEMBIC=OFF", 55 | " -G Ninja", 56 | ] 57 | 58 | build_command = ( 59 | " ".join(config_args) + " && cmake --build . --target install --config Release" 60 | ) 61 | 62 | 63 | def pre_cook(): 64 | download_and_unpack( 65 | f"https://github.com/alembic/alembic/archive/refs/tags/{version}.zip" 66 | ) 67 | -------------------------------------------------------------------------------- /blosc/1.21.1/package.py: -------------------------------------------------------------------------------- 1 | name = "blosc" 2 | version = "1.21.1" 3 | 4 | @early() 5 | def build_requires(): 6 | import platform 7 | 8 | if platform.system() == "Windows": 9 | return ["cmake", "vs"] 10 | else: 11 | return ["cmake"] 12 | 13 | 14 | @early() 15 | def variants(): 16 | import os, ast 17 | 18 | cook_variant = os.getenv("REZ_COOK_VARIANT") 19 | if cook_variant: 20 | # If we're building the package, we want to use the variant supplied to us 21 | return [ast.literal_eval(cook_variant)] 22 | else: 23 | # Otherwise tell rez-cook what variants we are capable of building 24 | return [ 25 | ["platform-linux", "arch-x86_64", "cxx11abi", "cfg"], 26 | ["platform-windows", "arch-AMD64", "vs", "cfg"], 27 | ] 28 | 29 | 30 | def commands(): 31 | import platform 32 | 33 | env.BLOSC_ROOT = "{root}" 34 | env.CMAKE_PREFIX_PATH.prepend("{root}") 35 | env.PATH.prepend("{root}/bin") 36 | 37 | if platform.system(): 38 | env.LD_LIBRARY_PATH.prepend("{root}/lib") 39 | 40 | 41 | def env(var: str): 42 | import platform 43 | if platform.system() == "Windows": 44 | return f"$env:{var}" 45 | else: 46 | return f"${var}" 47 | 48 | config_args = [ 49 | "cmake", 50 | "{root}", 51 | "-DCMAKE_INSTALL_PREFIX={install_path}", 52 | f'-DCMAKE_MODULE_PATH="{env("CMAKE_MODULE_PATH")}"', 53 | f'-DCMAKE_BUILD_TYPE="{env("REZ_BUILD_CONFIG")}"', 54 | " -G Ninja", 55 | ] 56 | 57 | build_command = ( 58 | " ".join(config_args) 59 | + f" && cmake --build . --target install --config {env('REZ_BUILD_CONFIG')}" 60 | ) 61 | 62 | 63 | def pre_cook(): 64 | download_and_unpack( 65 | f"https://github.com/Blosc/c-blosc/archive/refs/tags/v{version}.zip" 66 | ) 67 | -------------------------------------------------------------------------------- /blosc/1.5.0/package.py: -------------------------------------------------------------------------------- 1 | name = "blosc" 2 | version = "1.5.0" 3 | 4 | 5 | @early() 6 | def build_requires(): 7 | import platform 8 | 9 | if platform.system() == "Windows": 10 | return ["cmake", "vs"] 11 | else: 12 | return ["cmake"] 13 | 14 | 15 | @early() 16 | def variants(): 17 | import os, ast 18 | 19 | cook_variant = os.getenv("REZ_COOK_VARIANT") 20 | if cook_variant: 21 | # If we're building the package, we want to use the variant supplied to us 22 | return [ast.literal_eval(cook_variant)] 23 | else: 24 | # Otherwise tell rez-cook what variants we are capable of building 25 | return [ 26 | ["platform-linux", "arch-x86_64", "cxx11abi", "cfg"], 27 | ["platform-windows", "arch-AMD64", "vs", "cfg"], 28 | ] 29 | 30 | 31 | def commands(): 32 | import platform 33 | 34 | env.BLOSC_ROOT = "{root}" 35 | env.CMAKE_PREFIX_PATH.prepend("{root}") 36 | env.PATH.prepend("{root}/bin") 37 | 38 | if platform.system(): 39 | env.LD_LIBRARY_PATH.prepend("{root}/lib") 40 | 41 | 42 | def env(var: str): 43 | import platform 44 | if platform.system() == "Windows": 45 | return f"$env:{var}" 46 | else: 47 | return f"${var}" 48 | 49 | config_args = [ 50 | "cmake", 51 | "{root}", 52 | "-DCMAKE_INSTALL_PREFIX={install_path}", 53 | f'-DCMAKE_MODULE_PATH="{env("CMAKE_MODULE_PATH")}"', 54 | f'-DCMAKE_BUILD_TYPE="{env("REZ_BUILD_CONFIG")}"', 55 | " -G Ninja", 56 | ] 57 | 58 | build_command = ( 59 | " ".join(config_args) 60 | + f" && cmake --build . --target install --config {env('REZ_BUILD_CONFIG')}" 61 | ) 62 | 63 | 64 | def pre_cook(): 65 | download_and_unpack( 66 | f"https://github.com/Blosc/c-blosc/archive/refs/tags/v{version}.zip" 67 | ) 68 | -------------------------------------------------------------------------------- /zlib/1.2.12/package.py: -------------------------------------------------------------------------------- 1 | name = "zlib" 2 | version = "1.2.12" 3 | 4 | 5 | @early() 6 | def build_requires(): 7 | import platform 8 | 9 | if platform.system() == "Windows": 10 | return ["cmake", "vs"] 11 | else: 12 | return ["cmake"] 13 | 14 | 15 | @early() 16 | def variants(): 17 | import os, ast 18 | 19 | cook_variant = os.getenv("REZ_COOK_VARIANT") 20 | if cook_variant: 21 | # If we're building the package, we want to use the variant supplied to us 22 | return [ast.literal_eval(cook_variant)] 23 | else: 24 | # Otherwise tell rez-cook what variants we are capable of building 25 | return [ 26 | ["platform-linux", "arch-x86_64", "cxx11abi", "cfg"], 27 | ["platform-windows", "arch-AMD64", "vs", "cfg"], 28 | ] 29 | 30 | 31 | def commands(): 32 | import platform 33 | 34 | env.ZLIB_ROOT = "{root}" 35 | env.CMAKE_PREFIX_PATH.append("{root}") 36 | env.PATH.prepend("{root}/bin") 37 | 38 | if platform.system() == "Linux": 39 | env.LD_LIBRARY_PATH.prepend("{root}/lib") 40 | 41 | 42 | def env(var: str): 43 | import platform 44 | 45 | if platform.system() == "Windows": 46 | return f"$env:{var}" 47 | else: 48 | return f"${var}" 49 | 50 | 51 | config_args = [ 52 | "cmake", 53 | "{root}", 54 | "-DCMAKE_INSTALL_PREFIX={install_path}", 55 | f'-DCMAKE_MODULE_PATH="{env("CMAKE_MODULE_PATH")}"', 56 | f'-DCMAKE_BUILD_TYPE="{env("REZ_BUILD_CONFIG")}"', 57 | " -G Ninja", 58 | ] 59 | 60 | build_command = ( 61 | " ".join(config_args) 62 | + f" && cmake --build . --target install --config {env('REZ_BUILD_CONFIG')}" 63 | ) 64 | 65 | 66 | def pre_cook(): 67 | download_and_unpack( 68 | f"https://github.com/madler/zlib/archive/refs/tags/v{version}.tar.gz" 69 | ) 70 | -------------------------------------------------------------------------------- /glut/3.4.0/package.py: -------------------------------------------------------------------------------- 1 | name = "glut" 2 | version = "3.4.0" 3 | 4 | @early() 5 | def build_requires(): 6 | import platform 7 | 8 | if platform.system() == "Windows": 9 | return ["cmake", "vs"] 10 | else: 11 | return ["cmake"] 12 | 13 | 14 | @early() 15 | def variants(): 16 | import os, ast 17 | 18 | cook_variant = os.getenv("REZ_COOK_VARIANT") 19 | if cook_variant: 20 | # If we're building the package, we want to use the variant supplied to us 21 | return [ast.literal_eval(cook_variant)] 22 | else: 23 | # Otherwise tell rez-cook what variants we are capable of building 24 | return [ 25 | ["platform-linux", "arch-x86_64", "cxx11abi", "cfg"], 26 | ["platform-windows", "arch-AMD64", "vs", "cfg"], 27 | ] 28 | 29 | def commands(): 30 | env.GLUT_ROOT = "{root}" 31 | env.CMAKE_PREFIX_PATH.prepend("{root}") 32 | env.PATH.prepend("{root}/bin") 33 | 34 | import platform 35 | if platform.system() == "Linux": 36 | env.LD_LIBRARY_PATH.prepend("{root}/lib") 37 | 38 | def env(var: str): 39 | import platform 40 | if platform.system() == "Windows": 41 | return f"$env:{var}" 42 | else: 43 | return f"${var}" 44 | 45 | config_args = [ 46 | "cmake", 47 | "{root}", 48 | "-DCMAKE_INSTALL_PREFIX={install_path}", 49 | f'-DCMAKE_MODULE_PATH="{env("CMAKE_MODULE_PATH")}"', 50 | f'-DCMAKE_BUILD_TYPE="{env("REZ_BUILD_CONFIG")}"', 51 | "-DFREEGLUT_REPLACE_GLUT=ON", 52 | "-DFREEGLUT_BUILD_DEMOS=OFF", 53 | ] 54 | 55 | build_command = ( 56 | " ".join(config_args) 57 | + f" && cmake --build . --target install --config {env('REZ_BUILD_CONFIG')}" 58 | ) 59 | 60 | 61 | def pre_cook(): 62 | download_and_unpack(f"https://github.com/FreeGLUTProject/freeglut/archive/refs/tags/v{version}.zip") 63 | -------------------------------------------------------------------------------- /devil/1.8.0/package.py: -------------------------------------------------------------------------------- 1 | name = "devil" 2 | version = "1.8.0" 3 | 4 | requires = ["png", "tiff", "jpegturbo", "zlib", "glut"] 5 | 6 | @early() 7 | def build_requires(): 8 | import platform 9 | 10 | if platform.system() == "Windows": 11 | return ["cmake", "vs"] 12 | else: 13 | return ["cmake"] 14 | 15 | 16 | @early() 17 | def variants(): 18 | import os, ast 19 | 20 | cook_variant = os.getenv("REZ_COOK_VARIANT") 21 | if cook_variant: 22 | # If we're building the package, we want to use the variant supplied to us 23 | return [ast.literal_eval(cook_variant)] 24 | else: 25 | # Otherwise tell rez-cook what variants we are capable of building 26 | return [ 27 | ["platform-linux", "arch-x86_64", "cxx11abi", "cfg"], 28 | ["platform-windows", "arch-AMD64", "vs", "cfg"], 29 | ] 30 | 31 | def commands(): 32 | env.DEVIL_ROOT = "{root}" 33 | env.CMAKE_PREFIX_PATH.prepend("{root}") 34 | env.PATH.prepend("{root}/bin") 35 | 36 | import platform 37 | if platform.system() == "Linux": 38 | env.LD_LIBRARY_PATH.prepend("{root}/lib") 39 | 40 | def env(var: str): 41 | import platform 42 | if platform.system() == "Windows": 43 | return f"$env:{var}" 44 | else: 45 | return f"${var}" 46 | 47 | config_args = [ 48 | "cmake", 49 | "{root}/DevIL", 50 | "-DCMAKE_INSTALL_PREFIX={install_path}", 51 | f'-DCMAKE_MODULE_PATH="{env("CMAKE_MODULE_PATH")}"', 52 | f'-DCMAKE_BUILD_TYPE="{env("REZ_BUILD_CONFIG")}"', 53 | " -G Ninja", 54 | ] 55 | 56 | build_command = ( 57 | " ".join(config_args) 58 | + f" && cmake --build . --target install --config {env('REZ_BUILD_CONFIG')}" 59 | ) 60 | 61 | 62 | def pre_cook(): 63 | download_and_unpack(f"https://github.com/DentonW/DevIL/archive/refs/tags/v{version}.zip") 64 | -------------------------------------------------------------------------------- /assimp/5.2.5/package.py: -------------------------------------------------------------------------------- 1 | name = "assimp" 2 | version = "5.2.5" 3 | 4 | @early() 5 | def build_requires(): 6 | import platform 7 | 8 | if platform.system() == "Windows": 9 | return ["cmake", "vs"] 10 | else: 11 | return ["cmake"] 12 | 13 | 14 | @early() 15 | def variants(): 16 | import os, ast 17 | 18 | cook_variant = os.getenv("REZ_COOK_VARIANT") 19 | if cook_variant: 20 | # If we're building the package, we want to use the variant supplied to us 21 | return [ast.literal_eval(cook_variant)] 22 | else: 23 | # Otherwise tell rez-cook what variants we are capable of building 24 | return [ 25 | ["platform-linux", "arch-x86_64", "cxx11abi", "cfg"], 26 | ["platform-windows", "arch-AMD64", "vs", "cfg"], 27 | ] 28 | 29 | def commands(): 30 | env.ASSIMP_ROOT = "{root}" 31 | env.ASSIMP_PATH = "{root}" 32 | env.CMAKE_PREFIX_PATH.prepend("{root}") 33 | env.PATH.prepend("{root}/bin") 34 | 35 | import platform 36 | if platform.system() == "Linux": 37 | env.LD_LIBRARY_PATH.prepend("{root}/lib") 38 | 39 | 40 | def env(var: str): 41 | import platform 42 | if platform.system() == "Windows": 43 | return f"$env:{var}" 44 | else: 45 | return f"${var}" 46 | 47 | config_args = [ 48 | "cmake", 49 | "{root}", 50 | "-DCMAKE_INSTALL_PREFIX={install_path}", 51 | f'-DCMAKE_MODULE_PATH="{env("CMAKE_MODULE_PATH")}"', 52 | f'-DCMAKE_BUILD_TYPE="{env("REZ_BUILD_CONFIG")}"', 53 | "-DBUILD_SHARED_LIBS=ON", 54 | " -G Ninja", 55 | ] 56 | 57 | build_command = ( 58 | " ".join(config_args) 59 | + f" && cmake --build . --target install --config {env('REZ_BUILD_CONFIG')}" 60 | ) 61 | 62 | 63 | def pre_cook(): 64 | download_and_unpack(f"https://github.com/assimp/assimp/archive/refs/tags/v{version}.zip") 65 | -------------------------------------------------------------------------------- /ffmpeg/5.0.1/package.py: -------------------------------------------------------------------------------- 1 | name = "ffmpeg" 2 | version = "5.0.1" 3 | 4 | 5 | @early() 6 | def build_requires(): 7 | import platform 8 | 9 | if platform.system() == "Windows": 10 | return ["cmake", "vs"] 11 | else: 12 | return ["cmake"] 13 | 14 | 15 | @early() 16 | def variants(): 17 | import os, ast 18 | 19 | cook_variant = os.getenv("REZ_COOK_VARIANT") 20 | if cook_variant: 21 | # If we're building the package, we want to use the variant supplied to us 22 | return [ast.literal_eval(cook_variant)] 23 | else: 24 | # Otherwise tell rez-cook what variants we are capable of building 25 | return [ 26 | ["platform-linux", "arch-x86_64"], 27 | ["platform-windows", "arch-AMD64"], 28 | ] 29 | 30 | 31 | def commands(): 32 | import platform 33 | 34 | env.FFMPEG_ROOT = "{root}" 35 | env.CMAKE_PREFIX_PATH.prepend("{root}") 36 | env.PATH.prepend("{root}/bin") 37 | 38 | if platform.system() == "Linux": 39 | env.LD_LIBRARY_PATH.prepend("{root}/lib") 40 | 41 | 42 | @early() 43 | def build_command(): 44 | import platform 45 | 46 | if platform.system() == "Windows": 47 | return f'Move-Item -Path "$env:REZ_BUILD_SOURCE_PATH/ffmpeg-master-latest-win64-lgpl-shared/*" -Destination $env:REZ_BUILD_INSTALL_PATH' 48 | else: 49 | return f"mv $REZ_BUILD_SOURCE_PATH/ffmpeg-master-latest-linux64-lgpl-shared/* $REZ_BUILD_INSTALL_PATH" 50 | 51 | 52 | def pre_cook(): 53 | import platform 54 | 55 | if platform.system() == "Windows": 56 | fn = "ffmpeg-master-latest-win64-lgpl-shared.zip" 57 | else: 58 | fn = "ffmpeg-master-latest-linux64-lgpl-shared.tar.xz" 59 | 60 | download_and_unpack( 61 | f"https://github.com/BtbN/FFmpeg-Builds/releases/download/latest/{fn}", 62 | move_up=False, 63 | ) 64 | -------------------------------------------------------------------------------- /glfw/3.3.8/package.py: -------------------------------------------------------------------------------- 1 | name = "glfw" 2 | version = "3.3.8" 3 | 4 | @early() 5 | def build_requires(): 6 | import platform 7 | 8 | if platform.system() == "Windows": 9 | return ["cmake", "vs"] 10 | else: 11 | return ["cmake"] 12 | 13 | 14 | @early() 15 | def variants(): 16 | import os, ast 17 | 18 | cook_variant = os.getenv("REZ_COOK_VARIANT") 19 | if cook_variant: 20 | # If we're building the package, we want to use the variant supplied to us 21 | return [ast.literal_eval(cook_variant)] 22 | else: 23 | # Otherwise tell rez-cook what variants we are capable of building 24 | return [ 25 | ["platform-linux", "arch-x86_64", "cxx11abi", "cfg"], 26 | ["platform-windows", "arch-AMD64", "vs", "cfg"], 27 | ] 28 | 29 | def commands(): 30 | env.GLFW_ROOT = "{root}" 31 | env.CMAKE_PREFIX_PATH.prepend("{root}") 32 | env.PATH.prepend("{root}/bin") 33 | 34 | import platform 35 | if platform.system() == "Linux": 36 | env.LD_LIBRARY_PATH.prepend("{root}/lib") 37 | 38 | def env(var: str): 39 | import platform 40 | if platform.system() == "Windows": 41 | return f"$env:{var}" 42 | else: 43 | return f"${var}" 44 | 45 | config_args = [ 46 | "cmake", 47 | "{root}", 48 | "-DCMAKE_INSTALL_PREFIX={install_path}", 49 | f'-DCMAKE_MODULE_PATH="{env("CMAKE_MODULE_PATH")}"', 50 | f'-DCMAKE_BUILD_TYPE="{env("REZ_BUILD_CONFIG")}"', 51 | "-DGLFW_BUILD_EXAMPLES=OFF", 52 | "-DGLFW_BUILD_TESTS=OFF", 53 | "-DGLFW_BUILD_DOCS=OFF", 54 | " -G Ninja", 55 | ] 56 | 57 | build_command = ( 58 | " ".join(config_args) 59 | + f" && cmake --build . --target install --config {env('REZ_BUILD_CONFIG')}" 60 | ) 61 | 62 | 63 | def pre_cook(): 64 | download_and_unpack(f"https://github.com/glfw/glfw/releases/download/{version}/glfw-{version}.zip") 65 | -------------------------------------------------------------------------------- /jpegturbo/2.0.6/package.py: -------------------------------------------------------------------------------- 1 | name = "jpegturbo" 2 | version = "2.0.6" 3 | 4 | @early() 5 | def build_requires(): 6 | import platform 7 | 8 | if platform.system() == "Windows": 9 | return ["cmake", "vs"] 10 | else: 11 | return ["cmake"] 12 | 13 | 14 | @early() 15 | def variants(): 16 | import os, ast 17 | 18 | cook_variant = os.getenv("REZ_COOK_VARIANT") 19 | if cook_variant: 20 | # If we're building the package, we want to use the variant supplied to us 21 | return [ast.literal_eval(cook_variant)] 22 | else: 23 | # Otherwise tell rez-cook what variants we are capable of building 24 | return [ 25 | ["platform-linux", "arch-x86_64", "cxx11abi", "cfg"], 26 | ["platform-windows", "arch-AMD64", "vs", "cfg"], 27 | ] 28 | 29 | 30 | def commands(): 31 | import platform 32 | 33 | env.JPEGTurbo_ROOT = "{root}" 34 | env.CMAKE_PREFIX_PATH.append("{root}") 35 | env.PATH.prepend("{root}/bin") 36 | 37 | if platform.system() == "Linux": 38 | env.LD_LIBRARY_PATH.prepend("{root}/lib") 39 | env.PKG_CONFIG_PATH.prepend("{root}/lib/pkgconfig") 40 | 41 | 42 | def env(var: str): 43 | import platform 44 | 45 | if platform.system() == "Windows": 46 | return f"$env:{var}" 47 | else: 48 | return f"${var}" 49 | 50 | 51 | config_args = [ 52 | "cmake", 53 | "{root}", 54 | "-DCMAKE_INSTALL_PREFIX={install_path}", 55 | f'-DCMAKE_MODULE_PATH="{env("CMAKE_MODULE_PATH")}"', 56 | f'-DCMAKE_BUILD_TYPE="{env("REZ_BUILD_CONFIG")}"', 57 | " -G Ninja", 58 | ] 59 | 60 | build_command = ( 61 | " ".join(config_args) 62 | + f" && cmake --build . --target install --config {env('REZ_BUILD_CONFIG')}" 63 | ) 64 | 65 | def pre_cook(): 66 | download_and_unpack( 67 | f"https://github.com/libjpeg-turbo/libjpeg-turbo/archive/refs/tags/{version}.tar.gz" 68 | ) 69 | -------------------------------------------------------------------------------- /openjpeg/2.4.0/package.py: -------------------------------------------------------------------------------- 1 | name = "openjpeg" 2 | version = "2.4.0" 3 | 4 | 5 | @early() 6 | def build_requires(): 7 | import platform 8 | 9 | if platform.system() == "Windows": 10 | return ["cmake", "vs"] 11 | else: 12 | return ["cmake"] 13 | 14 | 15 | @early() 16 | def variants(): 17 | import os, ast 18 | 19 | cook_variant = os.getenv("REZ_COOK_VARIANT") 20 | if cook_variant: 21 | # If we're building the package, we want to use the variant supplied to us 22 | return [ast.literal_eval(cook_variant)] 23 | else: 24 | # Otherwise tell rez-cook what variants we are capable of building 25 | return [ 26 | ["platform-linux", "arch-x86_64", "cxx11abi", "cfg"], 27 | ["platform-windows", "arch-AMD64", "vs", "cfg"], 28 | ] 29 | 30 | 31 | def commands(): 32 | env.OpenJPEG_ROOT = "{root}" 33 | env.PATH.prepend("{root}/bin") 34 | env.CMAKE_PREFIX_PATH.append("{root}/bin") 35 | 36 | import platform 37 | 38 | if platform.system() == "Linux": 39 | env.LD_LIBRARY_PATH.prepend("{root}/lib") 40 | env.PKG_CONFIG_PATH.prepend("{root}/lib/pkgconfig") 41 | 42 | 43 | def env(var: str): 44 | import platform 45 | 46 | if platform.system() == "Windows": 47 | return f"$env:{var}" 48 | else: 49 | return f"${var}" 50 | 51 | 52 | config_args = [ 53 | "cmake", 54 | "{root}", 55 | "-DCMAKE_INSTALL_PREFIX={install_path}", 56 | f'-DCMAKE_MODULE_PATH="{env("CMAKE_MODULE_PATH")}"', 57 | f'-DCMAKE_BUILD_TYPE="{env("REZ_BUILD_CONFIG")}"', 58 | " -G Ninja", 59 | ] 60 | 61 | build_command = ( 62 | " ".join(config_args) 63 | + f" && cmake --build . --target install --config {env('REZ_BUILD_CONFIG')}" 64 | ) 65 | 66 | 67 | def pre_cook(): 68 | download_and_unpack( 69 | f"https://github.com/uclouvain/openjpeg/archive/refs/tags/v{version}.tar.gz" 70 | ) 71 | -------------------------------------------------------------------------------- /imath/3.1.5/package.py: -------------------------------------------------------------------------------- 1 | name = "imath" 2 | version = "3.1.5" 3 | 4 | @early() 5 | def build_requires(): 6 | import platform 7 | 8 | if platform.system() == "Windows": 9 | return ["cmake", "vs"] 10 | else: 11 | return ["cmake"] 12 | 13 | 14 | @early() 15 | def variants(): 16 | import os, ast 17 | 18 | cook_variant = os.getenv("REZ_COOK_VARIANT") 19 | if cook_variant: 20 | # If we're building the package, we want to use the variant supplied to us 21 | return [ast.literal_eval(cook_variant)] 22 | else: 23 | # Otherwise tell rez-cook what variants we are capable of building 24 | return [ 25 | ["platform-linux", "arch-x86_64", "cxx11abi", "cfg"], 26 | ["platform-windows", "arch-AMD64", "vs", "cfg"], 27 | ] 28 | 29 | 30 | def commands(): 31 | import platform 32 | 33 | env.Imath_ROOT = "{root}" 34 | env.IMATH_HOME = "{root}" 35 | env.IMATH_DIR = "{root}" 36 | env.IMATH_LOCATION = "{root}" 37 | env.CMAKE_PREFIX_PATH.append("{root}") 38 | env.PATH.prepend("{root}/bin") 39 | 40 | if platform.system() == "Linux": 41 | env.LD_LIBRARY_PATH.prepend("{root}/lib") 42 | 43 | def env(var: str): 44 | import platform 45 | if platform.system() == "Windows": 46 | return f"$env:{var}" 47 | else: 48 | return f"${var}" 49 | 50 | config_args = [ 51 | "cmake", 52 | "{root}", 53 | "-DCMAKE_INSTALL_PREFIX={install_path}", 54 | f'-DCMAKE_MODULE_PATH="{env("CMAKE_MODULE_PATH")}"', 55 | f'-DCMAKE_BUILD_TYPE="{env("REZ_BUILD_CONFIG")}"', 56 | " -G Ninja", 57 | ] 58 | 59 | build_command = ( 60 | " ".join(config_args) 61 | + f" && cmake --build . --target install --config {env('REZ_BUILD_CONFIG')}" 62 | ) 63 | 64 | def pre_cook(): 65 | download_and_unpack( 66 | f"https://github.com/AcademySoftwareFoundation/Imath/archive/refs/tags/v{version}.tar.gz" 67 | ) 68 | -------------------------------------------------------------------------------- /imath/3.0.5/package.py: -------------------------------------------------------------------------------- 1 | name = "imath" 2 | version = "3.0.5" 3 | 4 | 5 | @early() 6 | def build_requires(): 7 | import platform 8 | 9 | if platform.system() == "Windows": 10 | return ["cmake", "vs"] 11 | else: 12 | return ["cmake"] 13 | 14 | 15 | @early() 16 | def variants(): 17 | import os, ast 18 | 19 | cook_variant = os.getenv("REZ_COOK_VARIANT") 20 | if cook_variant: 21 | # If we're building the package, we want to use the variant supplied to us 22 | return [ast.literal_eval(cook_variant)] 23 | else: 24 | # Otherwise tell rez-cook what variants we are capable of building 25 | return [ 26 | ["platform-linux", "arch-x86_64", "cxx11abi", "cfg"], 27 | ["platform-windows", "arch-AMD64", "vs", "cfg"], 28 | ] 29 | 30 | 31 | def commands(): 32 | import platform 33 | 34 | env.Imath_ROOT = "{root}" 35 | env.IMATH_HOME = "{root}" 36 | env.IMATH_DIR = "{root}" 37 | env.IMATH_LOCATION = "{root}" 38 | env.CMAKE_PREFIX_PATH.append("{root}") 39 | env.PATH.prepend("{root}/bin") 40 | 41 | if platform.system() == "Linux": 42 | env.LD_LIBRARY_PATH.prepend("{root}/lib") 43 | 44 | def env(var: str): 45 | import platform 46 | if platform.system() == "Windows": 47 | return f"$env:{var}" 48 | else: 49 | return f"${var}" 50 | 51 | config_args = [ 52 | "cmake", 53 | "{root}", 54 | "-DCMAKE_INSTALL_PREFIX={install_path}", 55 | f'-DCMAKE_MODULE_PATH="{env("CMAKE_MODULE_PATH")}"', 56 | f'-DCMAKE_BUILD_TYPE="{env("REZ_BUILD_CONFIG")}"', 57 | " -G Ninja", 58 | ] 59 | 60 | build_command = ( 61 | " ".join(config_args) 62 | + f" && cmake --build . --target install --config {env('REZ_BUILD_CONFIG')}" 63 | ) 64 | 65 | def pre_cook(): 66 | download_and_unpack( 67 | f"https://github.com/AcademySoftwareFoundation/Imath/archive/refs/tags/v{version}.tar.gz" 68 | ) 69 | -------------------------------------------------------------------------------- /png/1.6.35/package.py: -------------------------------------------------------------------------------- 1 | name = "png" 2 | version = "1.6.35" 3 | 4 | requires = ["zlib-1.2"] 5 | 6 | 7 | @early() 8 | def build_requires(): 9 | import platform 10 | 11 | if platform.system() == "Windows": 12 | return ["cmake", "vs"] 13 | else: 14 | return ["cmake"] 15 | 16 | 17 | @early() 18 | def variants(): 19 | import os, ast 20 | 21 | cook_variant = os.getenv("REZ_COOK_VARIANT") 22 | if cook_variant: 23 | # If we're building the package, we want to use the variant supplied to us 24 | return [ast.literal_eval(cook_variant)] 25 | else: 26 | # Otherwise tell rez-cook what variants we are capable of building 27 | return [ 28 | ["platform-linux", "arch-x86_64", "cxx11abi", "cfg"], 29 | ["platform-windows", "arch-AMD64", "vs", "cfg"], 30 | ] 31 | 32 | 33 | def commands(): 34 | env.PNG_ROOT = "{root}" 35 | env.PATH.prepend("{root}/bin") 36 | env.CMAKE_PREFIX_PATH.append("{root}/bin") 37 | 38 | import platform 39 | 40 | if platform.system() == "Linux": 41 | env.LD_LIBRARY_PATH.prepend("{root}/lib") 42 | env.PKG_CONFIG_PATH.prepend("{root}/lib/pkgconfig") 43 | 44 | 45 | def env(var: str): 46 | import platform 47 | 48 | if platform.system() == "Windows": 49 | return f"$env:{var}" 50 | else: 51 | return f"${var}" 52 | 53 | 54 | config_args = [ 55 | "cmake", 56 | "{root}", 57 | "-DCMAKE_INSTALL_PREFIX={install_path}", 58 | f'-DCMAKE_MODULE_PATH="{env("CMAKE_MODULE_PATH")}"', 59 | f'-DCMAKE_BUILD_TYPE="{env("REZ_BUILD_CONFIG")}"', 60 | " -G Ninja", 61 | ] 62 | 63 | build_command = ( 64 | " ".join(config_args) 65 | + f" && cmake --build . --target install --config {env('REZ_BUILD_CONFIG')}" 66 | ) 67 | 68 | 69 | def pre_cook(): 70 | download_and_unpack( 71 | f"https://github.com/glennrp/libpng/archive/refs/tags/v{version}.tar.gz" 72 | ) 73 | -------------------------------------------------------------------------------- /pybind11/2.11.1/package.py: -------------------------------------------------------------------------------- 1 | name = "pybind11" 2 | version = "2.11.1" 3 | 4 | @early() 5 | def build_requires(): 6 | import platform 7 | 8 | if platform.system() == "Windows": 9 | return ["cmake", "vs", "python-3"] 10 | else: 11 | return ["cmake", "python-3"] 12 | 13 | 14 | @early() 15 | def variants(): 16 | import os, ast 17 | 18 | cook_variant = os.getenv("REZ_COOK_VARIANT") 19 | if cook_variant: 20 | # If we're building the package, we want to use the variant supplied to us 21 | return [ast.literal_eval(cook_variant)] 22 | else: 23 | # Otherwise tell rez-cook what variants we are capable of building 24 | return [ 25 | ["platform-linux", "arch-x86_64", "cxx11abi", "python", "cfg"], 26 | ["platform-windows", "arch-AMD64", "vs", "python", "cfg"], 27 | ] 28 | 29 | 30 | def commands(): 31 | import platform 32 | 33 | env.pybind11_ROOT = "{root}" 34 | env.PATH.prepend("{root}/bin") 35 | 36 | if platform.system() == "Linux": 37 | env.LD_LIBRARY_PATH.prepend("{root}/lib") 38 | 39 | 40 | def env(var: str): 41 | import platform 42 | if platform.system() == "Windows": 43 | return f"$env:{var}" 44 | else: 45 | return f"${var}" 46 | 47 | config_args = [ 48 | "cmake", 49 | "{root}", 50 | "-DCMAKE_INSTALL_PREFIX={install_path}", 51 | f'-DCMAKE_MODULE_PATH="{env("CMAKE_MODULE_PATH")}"', 52 | f'-DCMAKE_BUILD_TYPE="{env("REZ_BUILD_CONFIG")}"', 53 | "-DPYBIND11_TEST=OFF", 54 | f'-DPYTHON_EXECUTABLE="{env("Python_EXECUTABLE")}"', 55 | f'-DPYTHON_ROOT={env("Python_ROOT")}', 56 | " -G Ninja", 57 | ] 58 | 59 | build_command = ( 60 | " ".join(config_args) 61 | + f" && cmake --build . --target install --config {env('REZ_BUILD_CONFIG')}" 62 | ) 63 | 64 | def pre_cook(): 65 | download_and_unpack(f"https://github.com/pybind/pybind11/archive/refs/tags/v{version}.tar.gz") 66 | -------------------------------------------------------------------------------- /pybind11/2.8.1/package.py: -------------------------------------------------------------------------------- 1 | name = "pybind11" 2 | version = "2.8.1" 3 | 4 | @early() 5 | def build_requires(): 6 | import platform 7 | 8 | if platform.system() == "Windows": 9 | return ["cmake", "vs", "python-3"] 10 | else: 11 | return ["cmake", "python-3"] 12 | 13 | 14 | @early() 15 | def variants(): 16 | import os, ast 17 | 18 | cook_variant = os.getenv("REZ_COOK_VARIANT") 19 | if cook_variant: 20 | # If we're building the package, we want to use the variant supplied to us 21 | return [ast.literal_eval(cook_variant)] 22 | else: 23 | # Otherwise tell rez-cook what variants we are capable of building 24 | return [ 25 | ["platform-linux", "arch-x86_64", "cxx11abi", "python", "cfg"], 26 | ["platform-windows", "arch-AMD64", "vs", "python", "cfg"], 27 | ] 28 | 29 | 30 | def commands(): 31 | import platform 32 | 33 | env.pybind11_ROOT = "{root}" 34 | env.PATH.prepend("{root}/bin") 35 | 36 | if platform.system() == "Linux": 37 | env.LD_LIBRARY_PATH.prepend("{root}/lib") 38 | 39 | 40 | def env(var: str): 41 | import platform 42 | if platform.system() == "Windows": 43 | return f"$env:{var}" 44 | else: 45 | return f"${var}" 46 | 47 | config_args = [ 48 | "cmake", 49 | "{root}", 50 | "-DCMAKE_INSTALL_PREFIX={install_path}", 51 | f'-DCMAKE_MODULE_PATH="{env("CMAKE_MODULE_PATH")}"', 52 | f'-DCMAKE_BUILD_TYPE="{env("REZ_BUILD_CONFIG")}"', 53 | "-DPYBIND11_TEST=OFF", 54 | f'-DPYTHON_EXECUTABLE="{env("Python_EXECUTABLE")}"', 55 | f'-DPYTHON_ROOT={env("Python_ROOT")}', 56 | " -G Ninja", 57 | ] 58 | 59 | build_command = ( 60 | " ".join(config_args) 61 | + f" && cmake --build . --target install --config {env('REZ_BUILD_CONFIG')}" 62 | ) 63 | 64 | def pre_cook(): 65 | download_and_unpack(f"https://github.com/pybind/pybind11/archive/refs/tags/v{version}.tar.gz") 66 | -------------------------------------------------------------------------------- /pugixml/1.14/package.py: -------------------------------------------------------------------------------- 1 | name = "pugixml" 2 | version = "1.14" 3 | 4 | 5 | @early() 6 | def build_requires(): 7 | import platform 8 | 9 | if platform.system() == "Windows": 10 | return ["cmake", "vs"] 11 | else: 12 | return ["cmake"] 13 | 14 | 15 | @early() 16 | def variants(): 17 | import os, ast 18 | 19 | cook_variant = os.getenv("REZ_COOK_VARIANT") 20 | if cook_variant: 21 | # If we're building the package, we want to use the variant supplied to us 22 | return [ast.literal_eval(cook_variant)] 23 | else: 24 | # Otherwise tell rez-cook what variants we are capable of building 25 | return [ 26 | ["platform-linux", "arch-x86_64", "cxx11abi", "cfg"], 27 | ["platform-windows", "arch-AMD64", "vs", "cfg"], 28 | ] 29 | 30 | 31 | def commands(): 32 | env.PUGIXML_ROOT = "{root}" 33 | env.PUGIXML_ROOT_DIR = "{root}" 34 | env.PATH.prepend("{root}/bin") 35 | env.CMAKE_PREFIX_PATH.append("{root}/bin") 36 | 37 | import platform 38 | 39 | if platform.system() == "Linux": 40 | env.LD_LIBRARY_PATH.prepend("{root}/lib") 41 | env.PKG_CONFIG_PATH.prepend("{root}/lib/pkgconfig") 42 | 43 | 44 | def env(var: str): 45 | import platform 46 | 47 | if platform.system() == "Windows": 48 | return f"$env:{var}" 49 | else: 50 | return f"${var}" 51 | 52 | 53 | config_args = [ 54 | "cmake", 55 | "{root}", 56 | "-DCMAKE_INSTALL_PREFIX={install_path}", 57 | f'-DCMAKE_MODULE_PATH="{env("CMAKE_MODULE_PATH")}"', 58 | f'-DCMAKE_BUILD_TYPE="{env("REZ_BUILD_CONFIG")}"', 59 | " -G Ninja", 60 | ] 61 | 62 | build_command = ( 63 | " ".join(config_args) 64 | + f" && cmake --build . --target install --config {env('REZ_BUILD_CONFIG')}" 65 | ) 66 | 67 | 68 | def pre_cook(): 69 | download_and_unpack( 70 | f"https://github.com/zeux/pugixml/releases/download/v{version}/pugixml-{version}.tar.gz" 71 | ) -------------------------------------------------------------------------------- /imath/3.1.9/package.py: -------------------------------------------------------------------------------- 1 | name = "imath" 2 | version = "3.1.9" 3 | 4 | @early() 5 | def build_requires(): 6 | import platform 7 | 8 | if platform.system() == "Windows": 9 | return ["cmake", "vs"] 10 | else: 11 | return ["cmake"] 12 | 13 | 14 | @early() 15 | def variants(): 16 | import os, ast 17 | 18 | cook_variant = os.getenv("REZ_COOK_VARIANT") 19 | if cook_variant: 20 | # If we're building the package, we want to use the variant supplied to us 21 | return [ast.literal_eval(cook_variant)] 22 | else: 23 | # Otherwise tell rez-cook what variants we are capable of building 24 | return [ 25 | ["platform-linux", "arch-x86_64", "cxx11abi", "cfg"], 26 | ["platform-windows", "arch-AMD64", "vs", "cfg"], 27 | ] 28 | 29 | 30 | def commands(): 31 | import platform 32 | 33 | env.Imath_ROOT = "{root}" 34 | env.IMATH_HOME = "{root}" 35 | env.IMATH_DIR = "{root}" 36 | env.IMATH_LOCATION = "{root}" 37 | env.CMAKE_PREFIX_PATH.append("{root}") 38 | env.PATH.prepend("{root}/bin") 39 | 40 | if platform.system() == "Linux": 41 | env.LD_LIBRARY_PATH.prepend("{root}/lib") 42 | 43 | def env(var: str): 44 | import platform 45 | if platform.system() == "Windows": 46 | return f"$env:{var}" 47 | else: 48 | return f"${var}" 49 | 50 | config_args = [ 51 | "cmake", 52 | "{root}", 53 | "-DCMAKE_INSTALL_PREFIX={install_path}", 54 | f'-DCMAKE_MODULE_PATH="{env("CMAKE_MODULE_PATH")}"', 55 | f'-DCMAKE_BUILD_TYPE="{env("REZ_BUILD_CONFIG")}"', 56 | "-DCMAKE_CXX_STANDARD=17", 57 | " -G Ninja", 58 | ] 59 | 60 | build_command = ( 61 | " ".join(config_args) 62 | + f" && cmake --build . --target install --config {env('REZ_BUILD_CONFIG')}" 63 | ) 64 | 65 | def pre_cook(): 66 | download_and_unpack( 67 | f"https://github.com/AcademySoftwareFoundation/Imath/archive/refs/tags/v{version}.tar.gz" 68 | ) 69 | -------------------------------------------------------------------------------- /imath/3.1.12/package.py: -------------------------------------------------------------------------------- 1 | name = "imath" 2 | version = "3.1.12" 3 | 4 | @early() 5 | def build_requires(): 6 | import platform 7 | 8 | if platform.system() == "Windows": 9 | return ["cmake", "vs"] 10 | else: 11 | return ["cmake"] 12 | 13 | 14 | @early() 15 | def variants(): 16 | import os, ast 17 | 18 | cook_variant = os.getenv("REZ_COOK_VARIANT") 19 | if cook_variant: 20 | # If we're building the package, we want to use the variant supplied to us 21 | return [ast.literal_eval(cook_variant)] 22 | else: 23 | # Otherwise tell rez-cook what variants we are capable of building 24 | return [ 25 | ["platform-linux", "arch-x86_64", "cxx11abi", "cfg"], 26 | ["platform-windows", "arch-AMD64", "vs", "cfg"], 27 | ] 28 | 29 | 30 | def commands(): 31 | import platform 32 | 33 | env.Imath_ROOT = "{root}" 34 | env.IMATH_HOME = "{root}" 35 | env.IMATH_DIR = "{root}" 36 | env.IMATH_LOCATION = "{root}" 37 | env.CMAKE_PREFIX_PATH.append("{root}") 38 | env.PATH.prepend("{root}/bin") 39 | 40 | if platform.system() == "Linux": 41 | env.LD_LIBRARY_PATH.prepend("{root}/lib") 42 | 43 | def env(var: str): 44 | import platform 45 | if platform.system() == "Windows": 46 | return f"$env:{var}" 47 | else: 48 | return f"${var}" 49 | 50 | config_args = [ 51 | "cmake", 52 | "{root}", 53 | "-DCMAKE_INSTALL_PREFIX={install_path}", 54 | f'-DCMAKE_MODULE_PATH="{env("CMAKE_MODULE_PATH")}"', 55 | f'-DCMAKE_BUILD_TYPE="{env("REZ_BUILD_CONFIG")}"', 56 | "-DCMAKE_CXX_STANDARD=17", 57 | " -G Ninja", 58 | ] 59 | 60 | build_command = ( 61 | " ".join(config_args) 62 | + f" && cmake --build . --target install --config {env('REZ_BUILD_CONFIG')}" 63 | ) 64 | 65 | def pre_cook(): 66 | download_and_unpack( 67 | f"https://github.com/AcademySoftwareFoundation/Imath/archive/refs/tags/v{version}.tar.gz" 68 | ) 69 | -------------------------------------------------------------------------------- /openexr/3.0.5/package.py: -------------------------------------------------------------------------------- 1 | name = "openexr" 2 | version = "3.0.5" 3 | 4 | requires = ["imath-3.0", "zlib-1.2"] 5 | 6 | @early() 7 | def build_requires(): 8 | import platform 9 | 10 | if platform.system() == "Windows": 11 | return ["cmake", "vs"] 12 | else: 13 | return ["cmake"] 14 | 15 | 16 | @early() 17 | def variants(): 18 | import os, ast 19 | 20 | cook_variant = os.getenv("REZ_COOK_VARIANT") 21 | if cook_variant: 22 | # If we're building the package, we want to use the variant supplied to us 23 | return [ast.literal_eval(cook_variant)] 24 | else: 25 | # Otherwise tell rez-cook what variants we are capable of building 26 | return [ 27 | ["platform-linux", "arch-x86_64", "cxx11abi", "cfg"], 28 | ["platform-windows", "arch-AMD64", "vs", "cfg"], 29 | ] 30 | 31 | 32 | def commands(): 33 | import platform 34 | 35 | env.OPENEXR_ROOT = "{root}" 36 | env.OPENEXR_HOME = "{root}" 37 | env.OPENEXR_DIR = "{root}" 38 | env.OPENEXR_LOCATION = "{root}" 39 | env.CMAKE_PREFIX_PATH.append("{root}") 40 | env.PATH.prepend("{root}/bin") 41 | 42 | if platform.system() == "Linux": 43 | env.LD_LIBRARY_PATH.prepend("{root}/lib") 44 | 45 | def env(var: str): 46 | import platform 47 | if platform.system() == "Windows": 48 | return f"$env:{var}" 49 | else: 50 | return f"${var}" 51 | 52 | config_args = [ 53 | "cmake", 54 | "{root}", 55 | "-DCMAKE_INSTALL_PREFIX={install_path}", 56 | f'-DCMAKE_MODULE_PATH="{env("CMAKE_MODULE_PATH")}"', 57 | f'-DCMAKE_BUILD_TYPE="{env("REZ_BUILD_CONFIG")}"', 58 | " -G Ninja", 59 | ] 60 | 61 | build_command = ( 62 | " ".join(config_args) 63 | + f" && cmake --build . --target install --config {env('REZ_BUILD_CONFIG')}" 64 | ) 65 | 66 | 67 | def pre_cook(): 68 | download_and_unpack(f"https://github.com/AcademySoftwareFoundation/openexr/archive/refs/tags/v{version}.tar.gz") 69 | -------------------------------------------------------------------------------- /tiff/4.3.0/package.py: -------------------------------------------------------------------------------- 1 | name = "tiff" 2 | version = "4.3.0" 3 | 4 | requires = ["zlib-1.2", "jpegturbo-2.0"] 5 | 6 | @early() 7 | def build_requires(): 8 | import platform 9 | 10 | if platform.system() == "Windows": 11 | return ["cmake", "vs"] 12 | else: 13 | return ["cmake"] 14 | 15 | 16 | @early() 17 | def variants(): 18 | import os, ast 19 | 20 | cook_variant = os.getenv("REZ_COOK_VARIANT") 21 | if cook_variant: 22 | # If we're building the package, we want to use the variant supplied to us 23 | return [ast.literal_eval(cook_variant)] 24 | else: 25 | # Otherwise tell rez-cook what variants we are capable of building 26 | return [ 27 | ["platform-linux", "arch-x86_64", "cxx11abi", "cfg"], 28 | ["platform-windows", "arch-AMD64", "vs", "cfg"], 29 | ] 30 | 31 | 32 | def commands(): 33 | env.TIFF_ROOT = "{root}" 34 | env.LIBTIFF_ROOT = "{root}" 35 | env.PATH.prepend("{root}/bin") 36 | env.CMAKE_PREFIX_PATH.append("{root}/bin") 37 | 38 | import platform 39 | 40 | if platform.system() == "Linux": 41 | env.LD_LIBRARY_PATH.prepend("{root}/lib") 42 | env.PKG_CONFIG_PATH.prepend("{root}/lib/pkgconfig") 43 | 44 | 45 | def env(var: str): 46 | import platform 47 | 48 | if platform.system() == "Windows": 49 | return f"$env:{var}" 50 | else: 51 | return f"${var}" 52 | 53 | 54 | config_args = [ 55 | "cmake", 56 | "{root}", 57 | "-DCMAKE_INSTALL_PREFIX={install_path}", 58 | f'-DCMAKE_MODULE_PATH="{env("CMAKE_MODULE_PATH")}"', 59 | f'-DCMAKE_BUILD_TYPE="{env("REZ_BUILD_CONFIG")}"', 60 | " -G Ninja", 61 | ] 62 | 63 | build_command = ( 64 | " ".join(config_args) 65 | + f" && cmake --build . --target install --config {env('REZ_BUILD_CONFIG')}" 66 | ) 67 | 68 | 69 | def pre_cook(): 70 | download_and_unpack(f"https://gitlab.com/libtiff/libtiff/-/archive/v{version}/libtiff-v{version}.tar.gz") 71 | -------------------------------------------------------------------------------- /openexr/3.2.1/package.py: -------------------------------------------------------------------------------- 1 | name = "openexr" 2 | version = "3.2.1" 3 | 4 | requires = ["imath-3.1", "zlib-1.2"] 5 | 6 | @early() 7 | def build_requires(): 8 | import platform 9 | 10 | if platform.system() == "Windows": 11 | return ["cmake", "vs"] 12 | else: 13 | return ["cmake"] 14 | 15 | 16 | @early() 17 | def variants(): 18 | import os, ast 19 | 20 | cook_variant = os.getenv("REZ_COOK_VARIANT") 21 | if cook_variant: 22 | # If we're building the package, we want to use the variant supplied to us 23 | return [ast.literal_eval(cook_variant)] 24 | else: 25 | # Otherwise tell rez-cook what variants we are capable of building 26 | return [ 27 | ["platform-linux", "arch-x86_64", "cxx11abi", "cfg"], 28 | ["platform-windows", "arch-AMD64", "vs", "cfg"], 29 | ] 30 | 31 | 32 | def commands(): 33 | import platform 34 | 35 | env.OPENEXR_ROOT = "{root}" 36 | env.OPENEXR_HOME = "{root}" 37 | env.OPENEXR_DIR = "{root}" 38 | env.OPENEXR_LOCATION = "{root}" 39 | env.CMAKE_PREFIX_PATH.append("{root}") 40 | env.PATH.prepend("{root}/bin") 41 | 42 | if platform.system() == "Linux": 43 | env.LD_LIBRARY_PATH.prepend("{root}/lib") 44 | 45 | 46 | def env(var: str): 47 | import platform 48 | if platform.system() == "Windows": 49 | return f"$env:{var}" 50 | else: 51 | return f"${var}" 52 | 53 | 54 | config_args = [ 55 | "cmake", 56 | "{root}", 57 | "-DCMAKE_INSTALL_PREFIX={install_path}", 58 | f'-DCMAKE_MODULE_PATH="{env("CMAKE_MODULE_PATH")}"', 59 | f'-DCMAKE_BUILD_TYPE="{env("REZ_BUILD_CONFIG")}"', 60 | " -G Ninja", 61 | ] 62 | 63 | build_command = ( 64 | " ".join(config_args) 65 | + f" && cmake --build . --target install --config {env('REZ_BUILD_CONFIG')}" 66 | ) 67 | 68 | 69 | def pre_cook(): 70 | download_and_unpack(f"https://github.com/AcademySoftwareFoundation/openexr/archive/refs/tags/v{version}.tar.gz") 71 | -------------------------------------------------------------------------------- /openexr/3.3.2/package.py: -------------------------------------------------------------------------------- 1 | name = "openexr" 2 | version = "3.3.2" 3 | 4 | requires = ["imath-3.1", "zlib-1.2"] 5 | 6 | @early() 7 | def build_requires(): 8 | import platform 9 | 10 | if platform.system() == "Windows": 11 | return ["cmake", "vs"] 12 | else: 13 | return ["cmake"] 14 | 15 | 16 | @early() 17 | def variants(): 18 | import os, ast 19 | 20 | cook_variant = os.getenv("REZ_COOK_VARIANT") 21 | if cook_variant: 22 | # If we're building the package, we want to use the variant supplied to us 23 | return [ast.literal_eval(cook_variant)] 24 | else: 25 | # Otherwise tell rez-cook what variants we are capable of building 26 | return [ 27 | ["platform-linux", "arch-x86_64", "cxx11abi", "cfg"], 28 | ["platform-windows", "arch-AMD64", "vs", "cfg"], 29 | ] 30 | 31 | 32 | def commands(): 33 | import platform 34 | 35 | env.OPENEXR_ROOT = "{root}" 36 | env.OPENEXR_HOME = "{root}" 37 | env.OPENEXR_DIR = "{root}" 38 | env.OPENEXR_LOCATION = "{root}" 39 | env.CMAKE_PREFIX_PATH.append("{root}") 40 | env.PATH.prepend("{root}/bin") 41 | 42 | if platform.system() == "Linux": 43 | env.LD_LIBRARY_PATH.prepend("{root}/lib") 44 | 45 | 46 | def env(var: str): 47 | import platform 48 | if platform.system() == "Windows": 49 | return f"$env:{var}" 50 | else: 51 | return f"${var}" 52 | 53 | 54 | config_args = [ 55 | "cmake", 56 | "{root}", 57 | "-DCMAKE_INSTALL_PREFIX={install_path}", 58 | f'-DCMAKE_MODULE_PATH="{env("CMAKE_MODULE_PATH")}"', 59 | f'-DCMAKE_BUILD_TYPE="{env("REZ_BUILD_CONFIG")}"', 60 | " -G Ninja", 61 | ] 62 | 63 | build_command = ( 64 | " ".join(config_args) 65 | + f" && cmake --build . --target install --config {env('REZ_BUILD_CONFIG')}" 66 | ) 67 | 68 | 69 | def pre_cook(): 70 | download_and_unpack(f"https://github.com/AcademySoftwareFoundation/openexr/archive/refs/tags/v{version}.tar.gz") 71 | -------------------------------------------------------------------------------- /pybind11/2.13.1/package.py: -------------------------------------------------------------------------------- 1 | name = "pybind11" 2 | version = "2.13.1" 3 | 4 | 5 | @early() 6 | def build_requires(): 7 | import platform 8 | 9 | if platform.system() == "Windows": 10 | return ["cmake", "vs", "python-3"] 11 | else: 12 | return ["cmake", "python-3"] 13 | 14 | 15 | @early() 16 | def variants(): 17 | import os, ast 18 | 19 | cook_variant = os.getenv("REZ_COOK_VARIANT") 20 | if cook_variant: 21 | # If we're building the package, we want to use the variant supplied to us 22 | return [ast.literal_eval(cook_variant)] 23 | else: 24 | # Otherwise tell rez-cook what variants we are capable of building 25 | return [ 26 | ["platform-linux", "arch-x86_64", "cxx11abi", "python", "cfg"], 27 | ["platform-windows", "arch-AMD64", "vs", "python", "cfg"], 28 | ] 29 | 30 | 31 | def commands(): 32 | import platform 33 | 34 | env.pybind11_ROOT = "{root}" 35 | env.PATH.prepend("{root}/bin") 36 | 37 | if platform.system() == "Linux": 38 | env.LD_LIBRARY_PATH.prepend("{root}/lib") 39 | 40 | 41 | def env(var: str): 42 | import platform 43 | 44 | if platform.system() == "Windows": 45 | return f"$env:{var}" 46 | else: 47 | return f"${var}" 48 | 49 | 50 | config_args = [ 51 | "cmake", 52 | "{root}", 53 | "-DCMAKE_INSTALL_PREFIX={install_path}", 54 | f'-DCMAKE_MODULE_PATH="{env("CMAKE_MODULE_PATH")}"', 55 | f'-DCMAKE_BUILD_TYPE="{env("REZ_BUILD_CONFIG")}"', 56 | "-DPYBIND11_TEST=OFF", 57 | f'-DPYTHON_EXECUTABLE="{env("Python_EXECUTABLE")}"', 58 | f'-DPYTHON_ROOT={env("Python_ROOT")}', 59 | " -G Ninja", 60 | ] 61 | 62 | build_command = ( 63 | " ".join(config_args) 64 | + f" && cmake --build . --target install --config {env('REZ_BUILD_CONFIG')}" 65 | ) 66 | 67 | 68 | def pre_cook(): 69 | download_and_unpack( 70 | f"https://github.com/pybind/pybind11/archive/refs/tags/v{version}.tar.gz" 71 | ) 72 | -------------------------------------------------------------------------------- /openexr/3.1.5/package.py: -------------------------------------------------------------------------------- 1 | name = "openexr" 2 | version = "3.1.5" 3 | 4 | requires = ["imath-3.1", "zlib-1.2"] 5 | 6 | @early() 7 | def build_requires(): 8 | import platform 9 | 10 | if platform.system() == "Windows": 11 | return ["cmake", "vs"] 12 | else: 13 | return ["cmake"] 14 | 15 | 16 | @early() 17 | def variants(): 18 | import os, ast 19 | 20 | cook_variant = os.getenv("REZ_COOK_VARIANT") 21 | if cook_variant: 22 | # If we're building the package, we want to use the variant supplied to us 23 | return [ast.literal_eval(cook_variant)] 24 | else: 25 | # Otherwise tell rez-cook what variants we are capable of building 26 | return [ 27 | ["platform-linux", "arch-x86_64", "cxx11abi", "cfg"], 28 | ["platform-windows", "arch-AMD64", "vs", "cfg"], 29 | ] 30 | 31 | 32 | def commands(): 33 | import platform 34 | 35 | env.OPENEXR_ROOT = "{root}" 36 | env.OPENEXR_HOME = "{root}" 37 | env.OPENEXR_DIR = "{root}" 38 | env.OPENEXR_LOCATION = "{root}" 39 | env.CMAKE_PREFIX_PATH.append("{root}") 40 | env.PATH.prepend("{root}/bin") 41 | 42 | if platform.system() == "Linux": 43 | env.LD_LIBRARY_PATH.prepend("{root}/lib") 44 | 45 | def env(var: str): 46 | import platform 47 | if platform.system() == "Windows": 48 | return f"$env:{var}" 49 | else: 50 | return f"${var}" 51 | 52 | config_args = [ 53 | "cmake", 54 | "{root}", 55 | "-DCMAKE_INSTALL_PREFIX={install_path}", 56 | f'-DCMAKE_MODULE_PATH="{env("CMAKE_MODULE_PATH")}"', 57 | f'-DCMAKE_BUILD_TYPE="{env("REZ_BUILD_CONFIG")}"', 58 | "-DCMAKE_CXX_STANDARD=17", 59 | " -G Ninja", 60 | ] 61 | 62 | build_command = ( 63 | " ".join(config_args) 64 | + f" && cmake --build . --target install --config {env('REZ_BUILD_CONFIG')}" 65 | ) 66 | 67 | 68 | def pre_cook(): 69 | download_and_unpack(f"https://github.com/AcademySoftwareFoundation/openexr/archive/refs/tags/v{version}.tar.gz") 70 | -------------------------------------------------------------------------------- /openexr/2.4.2/package.py: -------------------------------------------------------------------------------- 1 | name = "openexr" 2 | version = "2.4.2" 3 | 4 | requires = ["zlib-1.2"] 5 | 6 | @early() 7 | def build_requires(): 8 | import platform 9 | 10 | if platform.system() == "Windows": 11 | return ["cmake", "vs"] 12 | else: 13 | return ["cmake"] 14 | 15 | 16 | @early() 17 | def variants(): 18 | import os, ast 19 | 20 | cook_variant = os.getenv("REZ_COOK_VARIANT") 21 | if cook_variant: 22 | # If we're building the package, we want to use the variant supplied to us 23 | return [ast.literal_eval(cook_variant)] 24 | else: 25 | # Otherwise tell rez-cook what variants we are capable of building 26 | return [ 27 | ["platform-linux", "arch-x86_64", "cxx11abi", "cfg"], 28 | ["platform-windows", "arch-AMD64", "vs", "cfg"], 29 | ] 30 | 31 | 32 | def commands(): 33 | import platform 34 | 35 | env.OPENEXR_ROOT = "{root}" 36 | env.OPENEXR_HOME = "{root}" 37 | env.OPENEXR_DIR = "{root}" 38 | env.OPENEXR_LOCATION = "{root}" 39 | 40 | env.ILMBASE_ROOT = "{root}" 41 | 42 | env.CMAKE_PREFIX_PATH.append("{root}") 43 | env.PATH.prepend("{root}/bin") 44 | 45 | if platform.system() == "Linux": 46 | env.LD_LIBRARY_PATH.prepend("{root}/lib") 47 | 48 | def env(var: str): 49 | import platform 50 | if platform.system() == "Windows": 51 | return f"$env:{var}" 52 | else: 53 | return f"${var}" 54 | 55 | config_args = [ 56 | "cmake", 57 | "{root}", 58 | "-DCMAKE_INSTALL_PREFIX={install_path}", 59 | f'-DCMAKE_MODULE_PATH="{env("CMAKE_MODULE_PATH")}"', 60 | f'-DCMAKE_BUILD_TYPE="{env("REZ_BUILD_CONFIG")}"', 61 | "-DPYILMBASE_ENABLE=FALSE", 62 | " -G Ninja", 63 | ] 64 | 65 | build_command = ( 66 | " ".join(config_args) 67 | + f" && cmake --build . --target install --config {env('REZ_BUILD_CONFIG')}" 68 | ) 69 | 70 | 71 | def pre_cook(): 72 | download_and_unpack(f"https://github.com/AcademySoftwareFoundation/openexr/archive/refs/tags/v{version}.zip") 73 | -------------------------------------------------------------------------------- /partio/1.17.3/package.py: -------------------------------------------------------------------------------- 1 | name = "partio" 2 | version = "1.17.3" 3 | 4 | @early() 5 | def build_requires(): 6 | import platform 7 | 8 | if platform.system() == "Windows": 9 | return ["cmake", "vs"] 10 | else: 11 | return ["cmake"] 12 | 13 | 14 | @early() 15 | def variants(): 16 | import os, ast 17 | 18 | cook_variant = os.getenv("REZ_COOK_VARIANT") 19 | if cook_variant: 20 | # If we're building the package, we want to use the variant supplied to us 21 | return [ast.literal_eval(cook_variant)] 22 | else: 23 | # Otherwise tell rez-cook what variants we are capable of building 24 | return [ 25 | ["platform-linux", "arch-x86_64", "cxx11abi", "cfg"], 26 | ["platform-windows", "arch-AMD64", "vs", "cfg"], 27 | ] 28 | 29 | 30 | def env(var: str): 31 | import platform 32 | 33 | if platform.system() == "Windows": 34 | return f"$env:{var}" 35 | else: 36 | return f"${var}" 37 | 38 | 39 | def commands(): 40 | env.PATH.prepend("{root}/bin") 41 | env.PATH.prepend("{root}/lib") 42 | env.partio_ROOT = "{root}" 43 | 44 | import platform 45 | 46 | if platform.system() == "Linux": 47 | env.LD_LIBRARY_PATH.prepend("{root}/lib") 48 | 49 | 50 | @early() 51 | def build_command(): 52 | config_args = [ 53 | "cmake", 54 | "{root}", 55 | "-DCMAKE_INSTALL_PREFIX={install_path}", 56 | f'-DCMAKE_MODULE_PATH="{env("CMAKE_MODULE_PATH")}"', 57 | f'-DCMAKE_BUILD_TYPE="{env("REZ_BUILD_CONFIG")}"', 58 | ] 59 | 60 | import platform 61 | 62 | if platform.system() == "Windows": 63 | config_args += [ 64 | "-G", 65 | f'{env("REZ_CMAKE_GENERATOR")}', 66 | "-A", 67 | "x64", 68 | ] 69 | 70 | return ( 71 | " ".join(config_args) 72 | + f" && cmake --build . --target install --config {env('REZ_BUILD_CONFIG')}" 73 | ) 74 | 75 | 76 | def pre_cook(): 77 | download_and_unpack(f"https://github.com/wdas/partio/archive/refs/tags/v{version}.tar.gz") 78 | -------------------------------------------------------------------------------- /raw/0.21.0/package.py: -------------------------------------------------------------------------------- 1 | name = "raw" 2 | version = "0.21.0" 3 | 4 | requires = ["jpegturbo", "zlib-1.2"] 5 | 6 | 7 | @early() 8 | def build_requires(): 9 | import platform 10 | 11 | if platform.system() == "Windows": 12 | return ["cmake", "vs"] 13 | else: 14 | return ["cmake"] 15 | 16 | 17 | @early() 18 | def variants(): 19 | import os, ast 20 | 21 | cook_variant = os.getenv("REZ_COOK_VARIANT") 22 | if cook_variant: 23 | # If we're building the package, we want to use the variant supplied to us 24 | return [ast.literal_eval(cook_variant)] 25 | else: 26 | # Otherwise tell rez-cook what variants we are capable of building 27 | return [ 28 | ["platform-linux", "arch-x86_64", "cxx11abi", "cfg"], 29 | ["platform-windows", "arch-AMD64", "vs", "cfg"], 30 | ] 31 | 32 | 33 | def commands(): 34 | env.LibRaw_ROOT = "{root}" 35 | env.LibRaw_LIBRARY_DIR = "{root}/lib" 36 | env.PATH.prepend("{root}/bin") 37 | env.CMAKE_PREFIX_PATH.append("{root}/bin") 38 | 39 | import platform 40 | 41 | if platform.system() == "Linux": 42 | env.LD_LIBRARY_PATH.prepend("{root}/lib") 43 | env.PKG_CONFIG_PATH.prepend("{root}/lib/pkgconfig") 44 | 45 | 46 | def env(var: str): 47 | import platform 48 | 49 | if platform.system() == "Windows": 50 | return f"$env:{var}" 51 | else: 52 | return f"${var}" 53 | 54 | 55 | config_args = [ 56 | "cmake", 57 | "{root}", 58 | "-DCMAKE_INSTALL_PREFIX={install_path}", 59 | f'-DCMAKE_MODULE_PATH="{env("CMAKE_MODULE_PATH")}"', 60 | f'-DCMAKE_BUILD_TYPE="{env("REZ_BUILD_CONFIG")}"', 61 | f"-DJPEG_INCLUDE_DIR=\"{env('JPEGTurbo_ROOT')}/include\"", 62 | f"-DJPEG_LIBRARY=\"{env('JPEGTurbo_ROOT')}/lib/libjpeg\"", 63 | " -G Ninja", 64 | ] 65 | 66 | build_command = ( 67 | " ".join(config_args) 68 | + f" && cmake --build . --target install --config {env('REZ_BUILD_CONFIG')}" 69 | ) 70 | 71 | 72 | def pre_cook(): 73 | fetch_repository("https://github.com/anderslanglands/raw.git", branch="v0.21.0a1") 74 | -------------------------------------------------------------------------------- /materialx/1.38.10/package.py: -------------------------------------------------------------------------------- 1 | name = "materialx" 2 | version = "1.38.10" 3 | 4 | requires = ["python-3"] 5 | 6 | @early() 7 | def build_requires(): 8 | import platform 9 | 10 | if platform.system() == "Windows": 11 | return ["cmake", "vs"] 12 | else: 13 | return ["cmake"] 14 | 15 | 16 | @early() 17 | def variants(): 18 | import os, ast 19 | 20 | cook_variant = os.getenv("REZ_COOK_VARIANT") 21 | if cook_variant: 22 | # If we're building the package, we want to use the variant supplied to us 23 | return [ast.literal_eval(cook_variant)] 24 | else: 25 | # Otherwise tell rez-cook what variants we are capable of building 26 | return [ 27 | ["platform-linux", "arch-x86_64", "cxx11abi", "cfg", "python"], 28 | ["platform-windows", "arch-AMD64", "vs", "cfg", "python"], 29 | ] 30 | 31 | 32 | def commands(): 33 | env.MATERIALX_ROOT = "{root}" 34 | env.MATERIALX_ROOT_DIR = "{root}" 35 | env.PATH.prepend("{root}/bin") 36 | env.CMAKE_PREFIX_PATH.append("{root}/bin") 37 | env.PYTHONPATH.prepend("{root}/lib/python") 38 | 39 | import platform 40 | 41 | if platform.system() == "Linux": 42 | env.LD_LIBRARY_PATH.prepend("{root}/lib") 43 | env.PKG_CONFIG_PATH.prepend("{root}/lib/pkgconfig") 44 | 45 | 46 | def env(var: str): 47 | import platform 48 | 49 | if platform.system() == "Windows": 50 | return f"$env:{var}" 51 | else: 52 | return f"${var}" 53 | 54 | 55 | config_args = [ 56 | "cmake", 57 | "{root}", 58 | "-DCMAKE_INSTALL_PREFIX={install_path}", 59 | f'-DCMAKE_MODULE_PATH="{env("CMAKE_MODULE_PATH")}"', 60 | f'-DCMAKE_BUILD_TYPE="{env("REZ_BUILD_CONFIG")}"', 61 | "-DMATERIALX_BUILD_PYTHON=ON", 62 | " -G Ninja", 63 | ] 64 | 65 | build_command = ( 66 | " ".join(config_args) 67 | + f" && cmake --build . --target install --config {env('REZ_BUILD_CONFIG')}" 68 | ) 69 | 70 | 71 | def pre_cook(): 72 | download_and_unpack( 73 | f"https://github.com/AcademySoftwareFoundation/MaterialX/releases/download/v{version}/MaterialX-{version}.tar.gz" 74 | ) 75 | 76 | -------------------------------------------------------------------------------- /openvdb/8.2.0/package.py: -------------------------------------------------------------------------------- 1 | name = "openvdb" 2 | version = "8.2.0" 3 | 4 | requires = ["openexr", "zlib", "boost-1.70+", "tbb", "python", "numpy", "blosc-1.5"] 5 | 6 | hashed_variants = True 7 | 8 | def commands(): 9 | env.OpenVDB_ROOT = "{root}" 10 | env.CMAKE_PREFIX_PATH.append("{root}") 11 | env.PATH.prepend("{root}/bin") 12 | env.PYTHONPATH.prepend("{root}/lib/python3.7/site-packages") 13 | 14 | import platform 15 | 16 | if platform.system() == "Linux": 17 | env.LD_LIBRARY_PATH.prepend("{root}/bin") 18 | 19 | 20 | @early() 21 | def build_requires(): 22 | import platform 23 | 24 | if platform.system() == "Windows": 25 | return ["cmake", "vs"] 26 | else: 27 | return ["cmake"] 28 | 29 | 30 | @early() 31 | def variants(): 32 | import os, ast 33 | 34 | cook_variant = os.getenv("REZ_COOK_VARIANT") 35 | if cook_variant: 36 | # If we're building the package, we want to use the variant supplied to us 37 | return [ast.literal_eval(cook_variant)] 38 | else: 39 | # Otherwise tell rez-cook what variants we are capable of building 40 | req = ["cfg", "boost", "tbb", "openexr", "python"] 41 | return [x + req for x in [ 42 | ["platform-linux", "arch-x86_64", "cxx11abi"], 43 | ["platform-windows", "arch-AMD64", "vs"], 44 | ] 45 | ] 46 | 47 | def env(var: str): 48 | import platform 49 | 50 | if platform.system() == "Windows": 51 | return f"$env:{var}" 52 | else: 53 | return f"${var}" 54 | 55 | config_args = [ 56 | "cmake", 57 | "{root}", 58 | "-DCMAKE_INSTALL_PREFIX={install_path}", 59 | f'-DCMAKE_MODULE_PATH="{env("CMAKE_MODULE_PATH")}"', 60 | f'-DCMAKE_BUILD_TYPE="{env("REZ_BUILD_CONFIG")}"', 61 | " -G Ninja", 62 | f'-DTBB_ROOT="{env("TBB_ROOT")}"', 63 | ] 64 | 65 | build_command = " ".join(config_args) + f" && cmake --build . --target install --config Release --parallel {env('REZ_BUILD_THREAD_COUNT')}" 66 | 67 | def pre_cook(): 68 | download_and_unpack( 69 | f"https://github.com/AcademySoftwareFoundation/openvdb/archive/refs/tags/v{version}.zip" 70 | ) 71 | -------------------------------------------------------------------------------- /openvdb/9.1.0/package.py: -------------------------------------------------------------------------------- 1 | name = "openvdb" 2 | version = "9.1.0" 3 | 4 | requires = ["openexr", "zlib", "boost-1.70+", "tbb", "python", "numpy", "blosc-1.5+"] 5 | 6 | hashed_variants = True 7 | 8 | def commands(): 9 | env.OpenVDB_ROOT = "{root}" 10 | env.CMAKE_PREFIX_PATH.append("{root}") 11 | env.PATH.prepend("{root}/bin") 12 | env.PYTHONPATH.prepend("{root}/lib/python3.7/site-packages") 13 | 14 | import platform 15 | 16 | if platform.system() == "Linux": 17 | env.LD_LIBRARY_PATH.prepend("{root}/bin") 18 | 19 | 20 | @early() 21 | def build_requires(): 22 | import platform 23 | 24 | if platform.system() == "Windows": 25 | return ["cmake", "vs"] 26 | else: 27 | return ["cmake"] 28 | 29 | 30 | @early() 31 | def variants(): 32 | import os, ast 33 | 34 | cook_variant = os.getenv("REZ_COOK_VARIANT") 35 | if cook_variant: 36 | # If we're building the package, we want to use the variant supplied to us 37 | return [ast.literal_eval(cook_variant)] 38 | else: 39 | # Otherwise tell rez-cook what variants we are capable of building 40 | req = ["cfg", "boost", "tbb", "openexr", "python"] 41 | return [x + req for x in [ 42 | ["platform-linux", "arch-x86_64", "cxx11abi"], 43 | ["platform-windows", "arch-AMD64", "vs"], 44 | ] 45 | ] 46 | 47 | def env(var: str): 48 | import platform 49 | 50 | if platform.system() == "Windows": 51 | return f"$env:{var}" 52 | else: 53 | return f"${var}" 54 | 55 | config_args = [ 56 | "cmake", 57 | "{root}", 58 | "-DCMAKE_INSTALL_PREFIX={install_path}", 59 | f'-DCMAKE_MODULE_PATH="{env("CMAKE_MODULE_PATH")}"', 60 | f'-DCMAKE_BUILD_TYPE="{env("REZ_BUILD_CONFIG")}"', 61 | " -G Ninja", 62 | f'-DTBB_ROOT="{env("TBB_ROOT")}"', 63 | ] 64 | 65 | build_command = " ".join(config_args) + f" && cmake --build . --target install --config Release --parallel {env('REZ_BUILD_THREAD_COUNT')}" 66 | 67 | def pre_cook(): 68 | download_and_unpack( 69 | f"https://github.com/AcademySoftwareFoundation/openvdb/archive/refs/tags/v{version}.zip" 70 | ) 71 | -------------------------------------------------------------------------------- /boost/1.82.0/package.py: -------------------------------------------------------------------------------- 1 | name = "boost" 2 | version = "1.82.0" 3 | 4 | requires = ["python"] 5 | 6 | @early() 7 | def build_requires(): 8 | import platform 9 | 10 | if platform.system() == "Windows": 11 | return ["vs"] 12 | else: 13 | return [] 14 | 15 | 16 | @early() 17 | def variants(): 18 | import os, ast 19 | 20 | cook_variant = os.getenv("REZ_COOK_VARIANT") 21 | if cook_variant: 22 | # If we're building the package, we want to use the variant supplied to us 23 | return [ast.literal_eval(cook_variant)] 24 | else: 25 | # Otherwise tell rez-cook what variants we are capable of building 26 | return [ 27 | ["platform-linux", "arch-x86_64", "cxx11abi", "python", "cfg"], 28 | ["platform-windows", "arch-AMD64", "vs", "python", "cfg"], 29 | ] 30 | 31 | 32 | def commands(): 33 | import platform 34 | 35 | env.Boost_ROOT = "{root}" 36 | env.BOOST_ROOT = "{root}" 37 | env.CMAKE_PREFIX_PATH.prepend("{root}") 38 | 39 | if platform.system() == "Windows": 40 | env.PATH.prepend("{root}/lib") 41 | elif platform.system() == "Linux": 42 | env.LD_LIBRARY_PATH.prepend("{root}/lib") 43 | 44 | 45 | def pre_cook(): 46 | download_and_unpack( 47 | f"https://github.com/boostorg/boost/releases/download/boost-{version}/boost-{version}.tar.gz", 48 | ) 49 | 50 | 51 | def env(var: str): 52 | import platform 53 | 54 | if platform.system() == "Windows": 55 | return f"$env:{var}" 56 | else: 57 | return f"${var}" 58 | 59 | 60 | @early() 61 | def build_command(): 62 | import platform 63 | 64 | if platform.system() == "Windows": 65 | return f"cd $env:REZ_BUILD_SOURCE_PATH && ./bootstrap.bat && ./b2 install --prefix=\"$env:REZ_BUILD_INSTALL_PATH\" address-model=64 link=shared threading=multi --layout=system variant=\"$env:REZ_BUILD_CONFIG\" -d0" 66 | else: 67 | return f"cd $REZ_BUILD_SOURCE_PATH && ./bootstrap.sh && ./b2 install --prefix=$REZ_BUILD_INSTALL_PATH address-model=64 link=shared threading=multi --layout=system variant=$REZ_BUILD_CONFIG -j$REZ_BUILD_THREAD_COUNT -d0 cxxflags=$CXXFLAGS" 68 | -------------------------------------------------------------------------------- /openvdb/10.1.0/package.py: -------------------------------------------------------------------------------- 1 | name = "openvdb" 2 | version = "10.1.0" 3 | 4 | requires = ["openexr", "zlib", "boost-1.70+", "tbb", "python", "numpy", "blosc-1.5+"] 5 | 6 | hashed_variants = True 7 | 8 | def commands(): 9 | env.OpenVDB_ROOT = "{root}" 10 | env.CMAKE_PREFIX_PATH.append("{root}") 11 | env.PATH.prepend("{root}/bin") 12 | env.PYTHONPATH.prepend("{root}/lib/python3.7/site-packages") 13 | 14 | import platform 15 | 16 | if platform.system() == "Linux": 17 | env.LD_LIBRARY_PATH.prepend("{root}/bin") 18 | 19 | 20 | @early() 21 | def build_requires(): 22 | import platform 23 | 24 | if platform.system() == "Windows": 25 | return ["cmake", "vs"] 26 | else: 27 | return ["cmake"] 28 | 29 | 30 | @early() 31 | def variants(): 32 | import os, ast 33 | 34 | cook_variant = os.getenv("REZ_COOK_VARIANT") 35 | if cook_variant: 36 | # If we're building the package, we want to use the variant supplied to us 37 | return [ast.literal_eval(cook_variant)] 38 | else: 39 | # Otherwise tell rez-cook what variants we are capable of building 40 | req = ["cfg", "boost", "tbb", "openexr", "python"] 41 | return [x + req for x in [ 42 | ["platform-linux", "arch-x86_64", "cxx11abi"], 43 | ["platform-windows", "arch-AMD64", "vs"], 44 | ] 45 | ] 46 | 47 | def env(var: str): 48 | import platform 49 | 50 | if platform.system() == "Windows": 51 | return f"$env:{var}" 52 | else: 53 | return f"${var}" 54 | 55 | config_args = [ 56 | "cmake", 57 | "{root}", 58 | "-DCMAKE_INSTALL_PREFIX={install_path}", 59 | f'-DCMAKE_MODULE_PATH="{env("CMAKE_MODULE_PATH")}"', 60 | f'-DCMAKE_BUILD_TYPE="{env("REZ_BUILD_CONFIG")}"', 61 | " -G Ninja", 62 | f'-DTBB_ROOT="{env("TBB_ROOT")}"', 63 | ] 64 | 65 | build_command = " ".join(config_args) + f" && cmake --build . --target install --config Release --parallel {env('REZ_BUILD_THREAD_COUNT')}" 66 | 67 | def pre_cook(): 68 | download_and_unpack( 69 | f"https://github.com/AcademySoftwareFoundation/openvdb/archive/refs/tags/v{version}.zip" 70 | ) 71 | -------------------------------------------------------------------------------- /openvdb/11.0.0/package.py: -------------------------------------------------------------------------------- 1 | name = "openvdb" 2 | version = "11.0.0" 3 | 4 | requires = ["openexr", "zlib", "boost-1.70+", "tbb", "python", "numpy", "blosc-1.5+"] 5 | 6 | hashed_variants = True 7 | 8 | def commands(): 9 | env.OpenVDB_ROOT = "{root}" 10 | env.CMAKE_PREFIX_PATH.append("{root}") 11 | env.PATH.prepend("{root}/bin") 12 | env.PYTHONPATH.prepend("{root}/lib/python3.7/site-packages") 13 | 14 | import platform 15 | 16 | if platform.system() == "Linux": 17 | env.LD_LIBRARY_PATH.prepend("{root}/bin") 18 | 19 | 20 | @early() 21 | def build_requires(): 22 | import platform 23 | 24 | if platform.system() == "Windows": 25 | return ["cmake", "vs"] 26 | else: 27 | return ["cmake"] 28 | 29 | 30 | @early() 31 | def variants(): 32 | import os, ast 33 | 34 | cook_variant = os.getenv("REZ_COOK_VARIANT") 35 | if cook_variant: 36 | # If we're building the package, we want to use the variant supplied to us 37 | return [ast.literal_eval(cook_variant)] 38 | else: 39 | # Otherwise tell rez-cook what variants we are capable of building 40 | req = ["cfg", "boost", "tbb", "openexr", "python"] 41 | return [x + req for x in [ 42 | ["platform-linux", "arch-x86_64", "cxx11abi"], 43 | ["platform-windows", "arch-AMD64", "vs"], 44 | ] 45 | ] 46 | 47 | def env(var: str): 48 | import platform 49 | 50 | if platform.system() == "Windows": 51 | return f"$env:{var}" 52 | else: 53 | return f"${var}" 54 | 55 | config_args = [ 56 | "cmake", 57 | "{root}", 58 | "-DCMAKE_INSTALL_PREFIX={install_path}", 59 | f'-DCMAKE_MODULE_PATH="{env("CMAKE_MODULE_PATH")}"', 60 | f'-DCMAKE_BUILD_TYPE="{env("REZ_BUILD_CONFIG")}"', 61 | " -G Ninja", 62 | f'-DTBB_ROOT="{env("TBB_ROOT")}"', 63 | ] 64 | 65 | build_command = " ".join(config_args) + f" && cmake --build . --target install --config Release --parallel {env('REZ_BUILD_THREAD_COUNT')}" 66 | 67 | def pre_cook(): 68 | download_and_unpack( 69 | f"https://github.com/AcademySoftwareFoundation/openvdb/archive/refs/tags/v{version}.zip" 70 | ) 71 | -------------------------------------------------------------------------------- /ptex/2.4.2/package.py: -------------------------------------------------------------------------------- 1 | name = "ptex" 2 | version = "2.4.2" 3 | 4 | requires = ["zlib-1.2"] 5 | 6 | 7 | @early() 8 | def build_requires(): 9 | import platform 10 | 11 | if platform.system() == "Windows": 12 | return ["cmake", "vs"] 13 | else: 14 | return ["cmake"] 15 | 16 | 17 | @early() 18 | def variants(): 19 | import os, ast 20 | 21 | cook_variant = os.getenv("REZ_COOK_VARIANT") 22 | if cook_variant: 23 | # If we're building the package, we want to use the variant supplied to us 24 | return [ast.literal_eval(cook_variant)] 25 | else: 26 | # Otherwise tell rez-cook what variants we are capable of building 27 | return [ 28 | ["platform-linux", "arch-x86_64", "cxx11abi", "cfg"], 29 | ["platform-windows", "arch-AMD64", "vs", "cfg"], 30 | ] 31 | 32 | 33 | def env(var: str): 34 | import platform 35 | 36 | if platform.system() == "Windows": 37 | return f"$env:{var}" 38 | else: 39 | return f"${var}" 40 | 41 | 42 | def commands(): 43 | env.PATH.prepend("{root}/bin") 44 | env.PATH.prepend("{root}/lib") 45 | env.Ptex_ROOT = "{root}" 46 | 47 | import platform 48 | 49 | if platform.system() == "Linux": 50 | env.LD_LIBRARY_PATH.prepend("{root}/lib") 51 | 52 | 53 | @early() 54 | def build_command(): 55 | config_args = [ 56 | "cmake", 57 | "{root}", 58 | "-DCMAKE_INSTALL_PREFIX={install_path}", 59 | f'-DCMAKE_MODULE_PATH="{env("CMAKE_MODULE_PATH")}"', 60 | f'-DCMAKE_BUILD_TYPE="{env("REZ_BUILD_CONFIG")}"', 61 | ] 62 | 63 | import platform 64 | 65 | if platform.system() == "Windows": 66 | config_args += [ 67 | "-G", 68 | f'{env("REZ_CMAKE_GENERATOR")}', 69 | "-A", 70 | "x64", 71 | "-DPTEX_BUILD_STATIC_LIBS=OFF", 72 | ] 73 | 74 | return ( 75 | " ".join(config_args) 76 | + f" && cmake --build . --target install --config {env('REZ_BUILD_CONFIG')}" 77 | ) 78 | 79 | 80 | def pre_cook(): 81 | download_and_unpack(f"https://github.com/wdas/ptex/archive/refs/tags/v{version}.zip") 82 | -------------------------------------------------------------------------------- /boost/1.79.0/package.py: -------------------------------------------------------------------------------- 1 | name = "boost" 2 | version = "1.79.0" 3 | 4 | requires = ["python"] 5 | 6 | @early() 7 | def build_requires(): 8 | import platform 9 | 10 | if platform.system() == "Windows": 11 | return ["vs"] 12 | else: 13 | return [] 14 | 15 | 16 | @early() 17 | def variants(): 18 | import os, ast 19 | 20 | cook_variant = os.getenv("REZ_COOK_VARIANT") 21 | if cook_variant: 22 | # If we're building the package, we want to use the variant supplied to us 23 | return [ast.literal_eval(cook_variant)] 24 | else: 25 | # Otherwise tell rez-cook what variants we are capable of building 26 | return [ 27 | ["platform-linux", "arch-x86_64", "cxx11abi", "python", "cfg"], 28 | ["platform-windows", "arch-AMD64", "vs", "python", "cfg"], 29 | ] 30 | 31 | 32 | def commands(): 33 | import platform 34 | 35 | env.Boost_ROOT = "{root}" 36 | env.BOOST_ROOT = "{root}" 37 | env.CMAKE_PREFIX_PATH.prepend("{root}") 38 | 39 | if platform.system() == "Windows": 40 | env.PATH.prepend("{root}/lib") 41 | elif platform.system() == "Linux": 42 | env.LD_LIBRARY_PATH.prepend("{root}/lib") 43 | 44 | 45 | def pre_cook(): 46 | download_and_unpack( 47 | f"https://boostorg.jfrog.io/artifactory/main/release/{version}/source/boost_{version.replace('.', '_')}.tar.bz2", 48 | ) 49 | 50 | 51 | def env(var: str): 52 | import platform 53 | 54 | if platform.system() == "Windows": 55 | return f"$env:{var}" 56 | else: 57 | return f"${var}" 58 | 59 | 60 | @early() 61 | def build_command(): 62 | import platform 63 | 64 | if platform.system() == "Windows": 65 | return f"cd $env:REZ_BUILD_SOURCE_PATH && ./bootstrap.bat && ./b2 install --prefix=\"$env:REZ_BUILD_INSTALL_PATH\" address-model=64 link=shared threading=multi --layout=system variant=\"$env:REZ_BUILD_CONFIG\" -d0" 66 | else: 67 | return f"cd $REZ_BUILD_SOURCE_PATH && ./bootstrap.sh && ./b2 install --prefix=$REZ_BUILD_INSTALL_PATH address-model=64 link=shared threading=multi --layout=system variant=$REZ_BUILD_CONFIG -j$REZ_BUILD_THREAD_COUNT -d0 cxxflags=$CXXFLAGS" 68 | -------------------------------------------------------------------------------- /boost/1.80.0/package.py: -------------------------------------------------------------------------------- 1 | name = "boost" 2 | version = "1.80.0" 3 | 4 | requires = ["python"] 5 | 6 | @early() 7 | def build_requires(): 8 | import platform 9 | 10 | if platform.system() == "Windows": 11 | return ["vs"] 12 | else: 13 | return [] 14 | 15 | 16 | @early() 17 | def variants(): 18 | import os, ast 19 | 20 | cook_variant = os.getenv("REZ_COOK_VARIANT") 21 | if cook_variant: 22 | # If we're building the package, we want to use the variant supplied to us 23 | return [ast.literal_eval(cook_variant)] 24 | else: 25 | # Otherwise tell rez-cook what variants we are capable of building 26 | return [ 27 | ["platform-linux", "arch-x86_64", "cxx11abi", "python", "cfg"], 28 | ["platform-windows", "arch-AMD64", "vs", "python", "cfg"], 29 | ] 30 | 31 | 32 | def commands(): 33 | import platform 34 | 35 | env.Boost_ROOT = "{root}" 36 | env.BOOST_ROOT = "{root}" 37 | env.CMAKE_PREFIX_PATH.prepend("{root}") 38 | 39 | if platform.system() == "Windows": 40 | env.PATH.prepend("{root}/lib") 41 | elif platform.system() == "Linux": 42 | env.LD_LIBRARY_PATH.prepend("{root}/lib") 43 | 44 | 45 | def pre_cook(): 46 | download_and_unpack( 47 | f"https://boostorg.jfrog.io/artifactory/main/release/{version}/source/boost_{version.replace('.', '_')}.tar.bz2", 48 | ) 49 | 50 | 51 | def env(var: str): 52 | import platform 53 | 54 | if platform.system() == "Windows": 55 | return f"$env:{var}" 56 | else: 57 | return f"${var}" 58 | 59 | 60 | @early() 61 | def build_command(): 62 | import platform 63 | 64 | if platform.system() == "Windows": 65 | return f"cd $env:REZ_BUILD_SOURCE_PATH && ./bootstrap.bat && ./b2 install --prefix=\"$env:REZ_BUILD_INSTALL_PATH\" address-model=64 link=shared threading=multi --layout=system variant=\"$env:REZ_BUILD_CONFIG\" -d0" 66 | else: 67 | return f"cd $REZ_BUILD_SOURCE_PATH && ./bootstrap.sh && ./b2 install --prefix=$REZ_BUILD_INSTALL_PATH address-model=64 link=shared threading=multi --layout=system variant=$REZ_BUILD_CONFIG -j$REZ_BUILD_THREAD_COUNT -d0 cxxflags=$CXXFLAGS" 68 | -------------------------------------------------------------------------------- /boost/1.70.0/package.py: -------------------------------------------------------------------------------- 1 | name = "boost" 2 | version = "1.70.0" 3 | 4 | requires = ["python<3.8"] 5 | 6 | @early() 7 | def build_requires(): 8 | import platform 9 | 10 | if platform.system() == "Windows": 11 | return ["vs"] 12 | else: 13 | return [] 14 | 15 | 16 | @early() 17 | def variants(): 18 | import os, ast 19 | 20 | cook_variant = os.getenv("REZ_COOK_VARIANT") 21 | if cook_variant: 22 | # If we're building the package, we want to use the variant supplied to us 23 | return [ast.literal_eval(cook_variant)] 24 | else: 25 | # Otherwise tell rez-cook what variants we are capable of building 26 | return [ 27 | ["platform-linux", "arch-x86_64", "cxx11abi", "python", "cfg"], 28 | ["platform-windows", "arch-AMD64", "vs", "python", "cfg"], 29 | ] 30 | 31 | 32 | def commands(): 33 | import platform 34 | 35 | env.Boost_ROOT = "{root}" 36 | env.BOOST_ROOT = "{root}" 37 | env.CMAKE_PREFIX_PATH.prepend("{root}") 38 | 39 | if platform.system() == "Windows": 40 | env.PATH.prepend("{root}/lib") 41 | elif platform.system() == "Linux": 42 | env.LD_LIBRARY_PATH.prepend("{root}/lib") 43 | 44 | 45 | def pre_cook(): 46 | download_and_unpack( 47 | f"https://boostorg.jfrog.io/artifactory/main/release/{version}/source/boost_{version.replace('.', '_')}.tar.bz2", 48 | ) 49 | 50 | 51 | def env(var: str): 52 | import platform 53 | 54 | if platform.system() == "Windows": 55 | return f"$env:{var}" 56 | else: 57 | return f"${var}" 58 | 59 | 60 | @early() 61 | def build_command(): 62 | import platform 63 | 64 | if platform.system() == "Windows": 65 | return f"cd $env:REZ_BUILD_SOURCE_PATH && ./bootstrap.bat && ./b2 install --prefix=\"$env:REZ_BUILD_INSTALL_PATH\" address-model=64 link=shared threading=multi --layout=system variant=\"$env:REZ_BUILD_CONFIG\" -d0" 66 | else: 67 | return f"cd $REZ_BUILD_SOURCE_PATH && ./bootstrap.sh --with-python=$Python_EXECUTABLE && ./b2 install --prefix=$REZ_BUILD_INSTALL_PATH address-model=64 link=shared threading=multi --layout=system variant=$REZ_BUILD_CONFIG -j$REZ_BUILD_THREAD_COUNT -d0 cxxflags=$CXXFLAGS" 68 | -------------------------------------------------------------------------------- /boost/1.73.0/package.py: -------------------------------------------------------------------------------- 1 | name = "boost" 2 | version = "1.73.0" 3 | 4 | requires = ["python"] 5 | 6 | 7 | @early() 8 | def build_requires(): 9 | import platform 10 | 11 | if platform.system() == "Windows": 12 | return ["vs"] 13 | else: 14 | return [] 15 | 16 | 17 | @early() 18 | def variants(): 19 | import os, ast 20 | 21 | cook_variant = os.getenv("REZ_COOK_VARIANT") 22 | if cook_variant: 23 | # If we're building the package, we want to use the variant supplied to us 24 | return [ast.literal_eval(cook_variant)] 25 | else: 26 | # Otherwise tell rez-cook what variants we are capable of building 27 | return [ 28 | ["platform-linux", "arch-x86_64", "cxx11abi", "python", "cfg"], 29 | ["platform-windows", "arch-AMD64", "vs", "python", "cfg"], 30 | ] 31 | 32 | 33 | def commands(): 34 | import platform 35 | 36 | env.Boost_ROOT = "{root}" 37 | env.BOOST_ROOT = "{root}" 38 | env.CMAKE_PREFIX_PATH.prepend("{root}") 39 | 40 | if platform.system() == "Windows": 41 | env.PATH.prepend("{root}/lib") 42 | elif platform.system() == "Linux": 43 | env.LD_LIBRARY_PATH.prepend("{root}/lib") 44 | 45 | 46 | def pre_cook(): 47 | download_and_unpack( 48 | f"https://boostorg.jfrog.io/artifactory/main/release/{version}/source/boost_{version.replace('.', '_')}.tar.bz2", 49 | ) 50 | 51 | 52 | def env(var: str): 53 | import platform 54 | 55 | if platform.system() == "Windows": 56 | return f"$env:{var}" 57 | else: 58 | return f"${var}" 59 | 60 | 61 | @early() 62 | def build_command(): 63 | import platform 64 | 65 | if platform.system() == "Windows": 66 | return f"cd $env:REZ_BUILD_SOURCE_PATH && ./bootstrap.bat && ./b2 install --prefix=\"$env:REZ_BUILD_INSTALL_PATH\" address-model=64 link=shared threading=multi --layout=system variant=\"$env:REZ_BUILD_CONFIG\" -d0" 67 | else: 68 | return f"cd $REZ_BUILD_SOURCE_PATH && ./bootstrap.sh --with-python=$Python_EXECUTABLE && ./b2 install --prefix=$REZ_BUILD_INSTALL_PATH address-model=64 link=shared threading=multi --layout=system variant=$REZ_BUILD_CONFIG -j$REZ_BUILD_THREAD_COUNT -d0 cxxflags=$CXXFLAGS" 69 | -------------------------------------------------------------------------------- /boost/1.76.0/package.py: -------------------------------------------------------------------------------- 1 | name = "boost" 2 | version = "1.76.0" 3 | 4 | requires = ["python"] 5 | 6 | 7 | @early() 8 | def build_requires(): 9 | import platform 10 | 11 | if platform.system() == "Windows": 12 | return ["vs"] 13 | else: 14 | return [] 15 | 16 | 17 | @early() 18 | def variants(): 19 | import os, ast 20 | 21 | cook_variant = os.getenv("REZ_COOK_VARIANT") 22 | if cook_variant: 23 | # If we're building the package, we want to use the variant supplied to us 24 | return [ast.literal_eval(cook_variant)] 25 | else: 26 | # Otherwise tell rez-cook what variants we are capable of building 27 | return [ 28 | ["platform-linux", "arch-x86_64", "cxx11abi", "python", "cfg"], 29 | ["platform-windows", "arch-AMD64", "vs", "python", "cfg"], 30 | ] 31 | 32 | 33 | def commands(): 34 | import platform 35 | 36 | env.Boost_ROOT = "{root}" 37 | env.BOOST_ROOT = "{root}" 38 | env.CMAKE_PREFIX_PATH.prepend("{root}") 39 | 40 | if platform.system() == "Windows": 41 | env.PATH.prepend("{root}/lib") 42 | elif platform.system() == "Linux": 43 | env.LD_LIBRARY_PATH.prepend("{root}/lib") 44 | 45 | 46 | def pre_cook(): 47 | download_and_unpack( 48 | f"https://boostorg.jfrog.io/artifactory/main/release/{version}/source/boost_{version.replace('.', '_')}.tar.bz2", 49 | ) 50 | 51 | 52 | def env(var: str): 53 | import platform 54 | 55 | if platform.system() == "Windows": 56 | return f"$env:{var}" 57 | else: 58 | return f"${var}" 59 | 60 | 61 | @early() 62 | def build_command(): 63 | import platform 64 | 65 | if platform.system() == "Windows": 66 | return f"cd $env:REZ_BUILD_SOURCE_PATH && ./bootstrap.bat && ./b2 install --prefix=\"$env:REZ_BUILD_INSTALL_PATH\" address-model=64 link=shared --layout=system threading=multi variant=\"$env:REZ_BUILD_CONFIG\" -d0" 67 | else: 68 | return f"cd $REZ_BUILD_SOURCE_PATH && ./bootstrap.sh --with-python=$Python_EXECUTABLE && ./b2 install --prefix=$REZ_BUILD_INSTALL_PATH address-model=64 link=shared threading=multi --layout=system variant=$REZ_BUILD_CONFIG -j$REZ_BUILD_THREAD_COUNT -d0 cxxflags=$CXXFLAGS" 69 | -------------------------------------------------------------------------------- /neovim/_0.8.0/package.py: -------------------------------------------------------------------------------- 1 | name = "neovim" 2 | version = "_0.8.0" 3 | 4 | @early() 5 | def variants(): 6 | import os, ast 7 | 8 | cook_variant = os.getenv("REZ_COOK_VARIANT") 9 | if cook_variant: 10 | # If we're building the package, we want to use the variant supplied to us 11 | return [ast.literal_eval(cook_variant)] 12 | else: 13 | # Otherwise tell rez-cook what variants we are capable of building 14 | req = ["python"] 15 | return [x + req for x in [ 16 | ["platform-linux", "arch-x86_64", "cxx11abi"], 17 | ["platform-windows", "arch-AMD64", "vs"], 18 | ] 19 | ] 20 | 21 | @early() 22 | def build_requires(): 23 | import platform 24 | 25 | if platform.system() == "Windows": 26 | return ["python-3", "vs"] 27 | else: 28 | return ["python-3"] 29 | 30 | 31 | @early() 32 | def build_requires(): 33 | import platform 34 | 35 | if platform.system() == "Windows": 36 | return ["cmake", "vs"] 37 | else: 38 | return ["cmake"] 39 | 40 | 41 | def commands(): 42 | env.PATH.prepend("{root}/bin") 43 | 44 | build_system = "cmake" 45 | 46 | def env(var: str): 47 | import platform 48 | 49 | if platform.system() == "Windows": 50 | return f"$env:{var}" 51 | else: 52 | return f"${var}" 53 | 54 | @early() 55 | def build_command(): 56 | 57 | config_args = [ 58 | "cmake", 59 | "{root}", 60 | "-DCMAKE_INSTALL_PREFIX={install_path}", 61 | f'-DCMAKE_MODULE_PATH="{env("CMAKE_MODULE_PATH")}"', 62 | f'-DCMAKE_BUILD_TYPE=Release', 63 | "-DUSE_BUNDLED_LUA=ON", 64 | ] 65 | 66 | import platform 67 | 68 | if platform.system() == "Windows": 69 | config_args += [ 70 | "-G", 71 | f'{env("REZ_CMAKE_GENERATOR")}', 72 | "-A", 73 | "x64", 74 | ] 75 | 76 | return ( 77 | f" echo {env('REZ_BUILD_CONFIG')} && cd {env('REZ_BUILD_SOURCE_PATH')}/build && " 78 | + " ".join(config_args) 79 | + f" && cmake --build . --target install --config Release" 80 | ) 81 | 82 | def pre_cook(): 83 | fetch_repository("https://github.com/neovim/neovim") 84 | -------------------------------------------------------------------------------- /neovim/0.7.2/package.py: -------------------------------------------------------------------------------- 1 | name = "neovim" 2 | version = "0.7.2" 3 | 4 | @early() 5 | def variants(): 6 | import os, ast 7 | 8 | cook_variant = os.getenv("REZ_COOK_VARIANT") 9 | if cook_variant: 10 | # If we're building the package, we want to use the variant supplied to us 11 | return [ast.literal_eval(cook_variant)] 12 | else: 13 | # Otherwise tell rez-cook what variants we are capable of building 14 | req = ["python"] 15 | return [x + req for x in [ 16 | ["platform-linux", "arch-x86_64", "cxx11abi"], 17 | ["platform-windows", "arch-AMD64", "vs"], 18 | ] 19 | ] 20 | 21 | @early() 22 | def build_requires(): 23 | import platform 24 | 25 | if platform.system() == "Windows": 26 | return ["python-3", "vs"] 27 | else: 28 | return ["python-3"] 29 | 30 | 31 | @early() 32 | def build_requires(): 33 | import platform 34 | 35 | if platform.system() == "Windows": 36 | return ["cmake", "vs"] 37 | else: 38 | return ["cmake"] 39 | 40 | 41 | def commands(): 42 | env.PATH.prepend("{root}/bin") 43 | 44 | build_system = "cmake" 45 | 46 | def env(var: str): 47 | import platform 48 | 49 | if platform.system() == "Windows": 50 | return f"$env:{var}" 51 | else: 52 | return f"${var}" 53 | 54 | @early() 55 | def build_command(): 56 | 57 | config_args = [ 58 | "cmake", 59 | "{root}", 60 | "-DCMAKE_INSTALL_PREFIX={install_path}", 61 | f'-DCMAKE_MODULE_PATH="{env("CMAKE_MODULE_PATH")}"', 62 | f'-DCMAKE_BUILD_TYPE=Release', 63 | "-DUSE_BUNDLED_LUA=ON", 64 | ] 65 | 66 | import platform 67 | 68 | if platform.system() == "Windows": 69 | config_args += [ 70 | "-G", 71 | f'{env("REZ_CMAKE_GENERATOR")}', 72 | "-A", 73 | "x64", 74 | ] 75 | 76 | return ( 77 | f" echo {env('REZ_BUILD_CONFIG')} && cd {env('REZ_BUILD_SOURCE_PATH')}/build && " 78 | + " ".join(config_args) 79 | + f" && cmake --build . --target install --config Release" 80 | ) 81 | 82 | def pre_cook(): 83 | fetch_repository("https://github.com/neovim/neovim", branch = f"v{version}") 84 | -------------------------------------------------------------------------------- /cgstubs/1.0.0/package.py: -------------------------------------------------------------------------------- 1 | name = "cgstubs" 2 | version = "1.0.0" 3 | 4 | requires = ["python-3.7+"] 5 | 6 | 7 | @early() 8 | def variants(): 9 | import os, ast 10 | 11 | cook_variant = os.getenv("REZ_COOK_VARIANT") 12 | if cook_variant: 13 | # If we're building the package, we want to use the variant supplied to us 14 | return [ast.literal_eval(cook_variant)] 15 | else: 16 | # Otherwise tell rez-cook what variants we are capable of building 17 | return [ 18 | ["python"], 19 | ] 20 | 21 | 22 | def env(var: str): 23 | import platform 24 | 25 | if platform.system() == "Windows": 26 | return f"$env:{var}" 27 | else: 28 | return f"${var}" 29 | 30 | 31 | STUBS = [ 32 | "usd", 33 | "houdini", 34 | "katana", 35 | "mari", 36 | "nuke", 37 | "opencolorio", 38 | "PySide2", 39 | "substance_painter", 40 | ] 41 | 42 | 43 | def get_build_command(): 44 | build_commands = [] 45 | for stub in STUBS: 46 | build_commands.append( 47 | f"rez-env python-{env('PYTHON_VERSION')} -- " 48 | f"python -m pip install types-{stub} " 49 | f"--target='{{install_path}}/{stub}' --no-deps --use-pep517") 50 | return " && ".join(build_commands) 51 | 52 | 53 | build_command = get_build_command() 54 | 55 | 56 | def pre_cook(): 57 | import os 58 | for stub in STUBS: 59 | os.makedirs(os.path.join(install_path, stub), exist_ok=True) 60 | 61 | 62 | def post_cook(): 63 | import os 64 | import shutil 65 | 66 | for stub in STUBS: 67 | parent = os.path.join(install_path, stub) 68 | for filename in os.listdir(parent): 69 | filepath = os.path.join(parent, filename) 70 | if filename.endswith("dist-info"): 71 | shutil.rmtree(filepath) 72 | if filename.endswith("-stubs"): 73 | shutil.move(filepath, filepath[:-6]) 74 | 75 | 76 | def commands(): 77 | import os 78 | 79 | STUBS = [ 80 | "usd", 81 | "houdini", 82 | "katana", 83 | "mari", 84 | "nuke", 85 | "opencolorio", 86 | "PySide2", 87 | "substance_painter", 88 | ] 89 | for stub in STUBS: 90 | env.PYTHONPATH.prepend(os.path.join("{root}", stub)) 91 | -------------------------------------------------------------------------------- /tbb/2020.3/package.py: -------------------------------------------------------------------------------- 1 | name = "tbb" 2 | version = "2020.3" 3 | 4 | @early() 5 | def variants(): 6 | import os, ast 7 | 8 | cook_variant = os.getenv("REZ_COOK_VARIANT") 9 | if cook_variant: 10 | # If we're building the package, we want to use the variant supplied to us 11 | return [ast.literal_eval(cook_variant)] 12 | else: 13 | # Otherwise tell rez-cook what variants we are capable of building 14 | return [ 15 | ["platform-linux", "arch-x86_64"], 16 | ["platform-windows", "arch-AMD64"], 17 | ] 18 | 19 | 20 | def commands(): 21 | env.TBB_ROOT = "{root}" 22 | env.TBB_ROOT_DIR = "{root}" 23 | env.TBB_LIBRARY_DIR = "{root}/lib/intel64/vc14" 24 | env.CMAKE_PREFIX_PATH.prepend("{root}") 25 | env.PATH.prepend("{root}/bin/intel64/vc14") 26 | 27 | import platform 28 | 29 | if platform.system() == "Linux": 30 | env.LD_LIBRARY_PATH.prepend("{root}/bin/intel64/vc14") 31 | 32 | def env(var: str): 33 | import platform 34 | 35 | if platform.system() == "Windows": 36 | return f"$env:{var}" 37 | else: 38 | return f"${var}" 39 | 40 | @early() 41 | def build_command(): 42 | import platform 43 | 44 | if platform.system() == "Windows": 45 | return """ 46 | Move-Item -Path \"$env:REZ_BUILD_SOURCE_PATH/tbb/*\" -Destination \"$env:REZ_BUILD_INSTALL_PATH\" 47 | # Copy binaries up to make VDB happy 48 | Copy-Item -Path \"$env:REZ_BUILD_INSTALL_PATH/lib/intel64/vc14/*\" -Destination \"$env:REZ_BUILD_INSTALL_PATH/lib\" 49 | Copy-Item -Path \"$env:REZ_BUILD_INSTALL_PATH/bin/intel64/vc14/*\" -Destination \"$env:REZ_BUILD_INSTALL_PATH/bin\" 50 | """ 51 | else: 52 | return ''' 53 | cp -r $REZ_BUILD_SOURCE_PATH/tbb/* $REZ_BUILD_INSTALL_PATH 54 | cp -r $REZ_BUILD_INSTALL_PATH/lib/intel64/gcc4.8/* $REZ_BUILD_INSTALL_PATH/lib/ 55 | ''' 56 | 57 | 58 | def pre_cook(): 59 | import platform 60 | 61 | if platform.system() == "Windows": 62 | download_and_unpack(f"https://github.com/oneapi-src/oneTBB/releases/download/v{version}/tbb-{version}-win.zip", move_up=False) 63 | else: 64 | download_and_unpack(f"https://github.com/oneapi-src/oneTBB/releases/download/v{version}/tbb-{version}-lin.tgz", move_up=False) 65 | -------------------------------------------------------------------------------- /osd/3.4.4/package.py: -------------------------------------------------------------------------------- 1 | name = "osd" 2 | version = "3.4.4" 3 | 4 | requires = ["imath-3", "ptex-2.4", "zlib-1.2"] 5 | 6 | 7 | @early() 8 | def build_requires(): 9 | import platform 10 | 11 | if platform.system() == "Windows": 12 | return ["cmake", "vs"] 13 | else: 14 | return ["cmake"] 15 | 16 | 17 | @early() 18 | def variants(): 19 | import os, ast 20 | 21 | cook_variant = os.getenv("REZ_COOK_VARIANT") 22 | if cook_variant: 23 | # If we're building the package, we want to use the variant supplied to us 24 | return [ast.literal_eval(cook_variant)] 25 | else: 26 | # Otherwise tell rez-cook what variants we are capable of building 27 | return [ 28 | ["platform-linux", "arch-x86_64", "cxx11abi", "cfg"], 29 | ["platform-windows", "arch-AMD64", "vs", "cfg"], 30 | ] 31 | 32 | 33 | def env(var: str): 34 | import platform 35 | 36 | if platform.system() == "Windows": 37 | return f"$env:{var}" 38 | else: 39 | return f"${var}" 40 | 41 | 42 | def commands(): 43 | env.OpenSubdiv_ROOT = "{root}" 44 | env.OPENSUBDIV_ROOT = "{root}" 45 | env.PATH.prepend("{root}/bin") 46 | 47 | 48 | @early() 49 | def build_command(): 50 | 51 | config_args = [ 52 | "cmake", 53 | "{root}", 54 | "-DCMAKE_INSTALL_PREFIX={install_path}", 55 | f'-DCMAKE_MODULE_PATH="{env("CMAKE_MODULE_PATH")}"', 56 | f'-DCMAKE_BUILD_TYPE="{env("REZ_BUILD_CONFIG")}"', 57 | "-DNO_EXAMPLES=ON", 58 | "-DNO_TUTORIALS=ON", 59 | "-DNO_REGRESSION=ON", 60 | "-DNO_DOC=ON", 61 | "-DNO_TESTS=ON", 62 | "-DNO_GLTESTS=ON", 63 | "-DBUILD_SHARED_LIBS=ON", 64 | "-DNO_OPENCL=ON", 65 | ] 66 | 67 | import platform 68 | 69 | if platform.system() == "Windows": 70 | config_args += [ 71 | "-G", 72 | f'{env("REZ_CMAKE_GENERATOR")}', 73 | "-A", 74 | "x64", 75 | ] 76 | 77 | return ( 78 | " ".join(config_args) 79 | + f" && cmake --build . --target install --config {env('REZ_BUILD_CONFIG')}" 80 | ) 81 | 82 | 83 | def pre_cook(): 84 | download_and_unpack( 85 | "https://github.com/anderslanglands/OpenSubdiv/archive/refs/tags/recipe-3_4_4.tar.gz" 86 | ) 87 | -------------------------------------------------------------------------------- /ocio/2.2.1/package.py: -------------------------------------------------------------------------------- 1 | name = "ocio" 2 | version = "2.2.1" 3 | 4 | requires = ["openexr-2.4|3.1.2+", "python-3.7+"] 5 | 6 | hashed_variants = True 7 | 8 | 9 | @early() 10 | def build_requires(): 11 | import platform 12 | 13 | if platform.system() == "Windows": 14 | return ["cmake", "vs", "pybind11-2.6.1+"] 15 | else: 16 | return ["cmake", "pybind11-2.6.1+"] 17 | 18 | 19 | @early() 20 | def variants(): 21 | import os, ast 22 | 23 | cook_variant = os.getenv("REZ_COOK_VARIANT") 24 | if cook_variant: 25 | # If we're building the package, we want to use the variant supplied to us 26 | return [ast.literal_eval(cook_variant)] 27 | else: 28 | # Otherwise tell rez-cook what variants we are capable of building 29 | req = ["cfg", "openexr", "python"] 30 | return [x + req for x in [ 31 | ["platform-linux", "arch-x86_64", "cxx11abi"], 32 | ["platform-windows", "arch-AMD64", "vs"], 33 | ] 34 | ] 35 | 36 | 37 | def commands(): 38 | env.OCIO_ROOT = "{root}" 39 | env.OpenColorIO_ROOT = "{root}" 40 | env.PATH.prepend("{root}/bin") 41 | env.CMAKE_PREFIX_PATH.append("{root}/bin") 42 | env.PYTHONPATH.prepend("{root}/lib/site-packages") 43 | env.OCIO_LOAD_DLLS_FROM_PATH = "1" 44 | 45 | import platform 46 | 47 | if platform.system() == "Linux": 48 | env.LD_LIBRARY_PATH.prepend("{root}/lib") 49 | 50 | 51 | def env(var: str): 52 | import platform 53 | 54 | if platform.system() == "Windows": 55 | return f"$env:{var}" 56 | else: 57 | return f"${var}" 58 | 59 | 60 | config_args = [ 61 | "cmake", 62 | "{root}", 63 | "-DCMAKE_INSTALL_PREFIX={install_path}", 64 | f'-DCMAKE_MODULE_PATH="{env("CMAKE_MODULE_PATH")}"', 65 | f'-DCMAKE_BUILD_TYPE="Release"', 66 | f'-DPython_ROOT={env("Python_ROOT")}', 67 | f'-DPython_EXECUTABLE={env("Python_EXECUTABLE")}', 68 | "-DOCIO_BUILD_TESTS=OFF", 69 | "-DOCIO_BUILD_GPU_TESTS=OFF", 70 | " -G Ninja", 71 | ] 72 | 73 | build_command = ( 74 | " ".join(config_args) 75 | + f" && cmake --build . --target install --config {env('REZ_BUILD_CONFIG')}" 76 | ) 77 | 78 | 79 | def pre_cook(): 80 | download_and_unpack( 81 | f"https://github.com/AcademySoftwareFoundation/OpenColorIO/archive/refs/tags/v{version}.tar.gz" 82 | ) 83 | -------------------------------------------------------------------------------- /osd/3.5.1/package.py: -------------------------------------------------------------------------------- 1 | name = "osd" 2 | version = "3.5.1" 3 | 4 | requires = ["imath-3", "ptex-2.4", "zlib-1.2"] 5 | 6 | 7 | @early() 8 | def build_requires(): 9 | import platform 10 | 11 | if platform.system() == "Windows": 12 | return ["cmake", "vs"] 13 | else: 14 | return ["cmake"] 15 | 16 | 17 | @early() 18 | def variants(): 19 | import os, ast 20 | 21 | cook_variant = os.getenv("REZ_COOK_VARIANT") 22 | if cook_variant: 23 | # If we're building the package, we want to use the variant supplied to us 24 | return [ast.literal_eval(cook_variant)] 25 | else: 26 | # Otherwise tell rez-cook what variants we are capable of building 27 | return [ 28 | ["platform-linux", "arch-x86_64", "cxx11abi", "cfg"], 29 | ["platform-windows", "arch-AMD64", "vs", "cfg"], 30 | ] 31 | 32 | 33 | def env(var: str): 34 | import platform 35 | 36 | if platform.system() == "Windows": 37 | return f"$env:{var}" 38 | else: 39 | return f"${var}" 40 | 41 | 42 | def commands(): 43 | env.OpenSubdiv_ROOT = "{root}" 44 | env.OPENSUBDIV_ROOT = "{root}" 45 | env.PATH.prepend("{root}/bin") 46 | 47 | 48 | @early() 49 | def build_command(): 50 | 51 | config_args = [ 52 | "cmake", 53 | "{root}", 54 | "-DCMAKE_INSTALL_PREFIX={install_path}", 55 | f'-DCMAKE_MODULE_PATH="{env("CMAKE_MODULE_PATH")}"', 56 | f'-DCMAKE_BUILD_TYPE="{env("REZ_BUILD_CONFIG")}"', 57 | "-DNO_EXAMPLES=ON", 58 | "-DNO_TUTORIALS=ON", 59 | "-DNO_REGRESSION=ON", 60 | "-DNO_DOC=ON", 61 | "-DNO_TESTS=ON", 62 | "-DNO_GLTESTS=ON", 63 | "-DBUILD_SHARED_LIBS=ON", 64 | "-DNO_OPENCL=ON", 65 | ] 66 | 67 | import platform 68 | 69 | if platform.system() == "Windows": 70 | config_args += [ 71 | "-G", 72 | f'{env("REZ_CMAKE_GENERATOR")}', 73 | "-A", 74 | "x64", 75 | ] 76 | 77 | return ( 78 | " ".join(config_args) 79 | + f" && cmake --build . --target install --config {env('REZ_BUILD_CONFIG')}" 80 | ) 81 | 82 | 83 | def pre_cook(): 84 | fileversion = f"{version}".replace(".", "_") 85 | download_and_unpack( 86 | f"https://github.com/PixarAnimationStudios/OpenSubdiv/archive/refs/tags/v{fileversion}.tar.gz" 87 | ) 88 | -------------------------------------------------------------------------------- /osd/3.6.0/package.py: -------------------------------------------------------------------------------- 1 | name = "osd" 2 | version = "3.6.0" 3 | 4 | requires = ["imath-3", "ptex-2.4", "zlib-1.2"] 5 | 6 | 7 | @early() 8 | def build_requires(): 9 | import platform 10 | 11 | if platform.system() == "Windows": 12 | return ["cmake", "vs"] 13 | else: 14 | return ["cmake"] 15 | 16 | 17 | @early() 18 | def variants(): 19 | import os, ast 20 | 21 | cook_variant = os.getenv("REZ_COOK_VARIANT") 22 | if cook_variant: 23 | # If we're building the package, we want to use the variant supplied to us 24 | return [ast.literal_eval(cook_variant)] 25 | else: 26 | # Otherwise tell rez-cook what variants we are capable of building 27 | return [ 28 | ["platform-linux", "arch-x86_64", "cxx11abi", "cfg"], 29 | ["platform-windows", "arch-AMD64", "vs", "cfg"], 30 | ] 31 | 32 | 33 | def env(var: str): 34 | import platform 35 | 36 | if platform.system() == "Windows": 37 | return f"$env:{var}" 38 | else: 39 | return f"${var}" 40 | 41 | 42 | def commands(): 43 | env.OpenSubdiv_ROOT = "{root}" 44 | env.OPENSUBDIV_ROOT = "{root}" 45 | env.PATH.prepend("{root}/bin") 46 | 47 | 48 | @early() 49 | def build_command(): 50 | 51 | config_args = [ 52 | "cmake", 53 | "{root}", 54 | "-DCMAKE_INSTALL_PREFIX={install_path}", 55 | f'-DCMAKE_MODULE_PATH="{env("CMAKE_MODULE_PATH")}"', 56 | f'-DCMAKE_BUILD_TYPE="{env("REZ_BUILD_CONFIG")}"', 57 | "-DNO_EXAMPLES=ON", 58 | "-DNO_TUTORIALS=ON", 59 | "-DNO_REGRESSION=ON", 60 | "-DNO_DOC=ON", 61 | "-DNO_TESTS=ON", 62 | "-DNO_GLTESTS=ON", 63 | "-DBUILD_SHARED_LIBS=ON", 64 | "-DNO_OPENCL=ON", 65 | ] 66 | 67 | import platform 68 | 69 | if platform.system() == "Windows": 70 | config_args += [ 71 | "-G", 72 | f'{env("REZ_CMAKE_GENERATOR")}', 73 | "-A", 74 | "x64", 75 | ] 76 | 77 | return ( 78 | " ".join(config_args) 79 | + f" && cmake --build . --target install --config {env('REZ_BUILD_CONFIG')}" 80 | ) 81 | 82 | 83 | def pre_cook(): 84 | fileversion = f"{version}".replace(".", "_") 85 | download_and_unpack( 86 | f"https://github.com/PixarAnimationStudios/OpenSubdiv/archive/refs/tags/v{fileversion}.tar.gz" 87 | ) 88 | -------------------------------------------------------------------------------- /ocio/2.3.1/package.py: -------------------------------------------------------------------------------- 1 | name = "ocio" 2 | version = "2.3.1" 3 | 4 | requires = ["openexr-2.4|3.1.2+", "python-3.7+"] 5 | 6 | hashed_variants = True 7 | 8 | 9 | @early() 10 | def build_requires(): 11 | import platform 12 | 13 | if platform.system() == "Windows": 14 | return ["cmake", "vs", "pybind11-2.6.1+"] 15 | else: 16 | return ["cmake", "pybind11-2.6.1+"] 17 | 18 | 19 | @early() 20 | def variants(): 21 | import os, ast 22 | 23 | cook_variant = os.getenv("REZ_COOK_VARIANT") 24 | if cook_variant: 25 | # If we're building the package, we want to use the variant supplied to us 26 | return [ast.literal_eval(cook_variant)] 27 | else: 28 | # Otherwise tell rez-cook what variants we are capable of building 29 | req = ["cfg", "openexr", "python"] 30 | return [x + req for x in [ 31 | ["platform-linux", "arch-x86_64", "cxx11abi"], 32 | ["platform-windows", "arch-AMD64", "vs"], 33 | ] 34 | ] 35 | 36 | 37 | def commands(): 38 | env.OCIO_ROOT = "{root}" 39 | env.OpenColorIO_ROOT = "{root}" 40 | env.PATH.prepend("{root}/bin") 41 | env.CMAKE_PREFIX_PATH.append("{root}/bin") 42 | env.PYTHONPATH.prepend("{root}/lib/site-packages") 43 | env.OCIO_LOAD_DLLS_FROM_PATH = "1" 44 | 45 | import platform 46 | 47 | if platform.system() == "Linux": 48 | env.LD_LIBRARY_PATH.prepend("{root}/lib") 49 | 50 | 51 | def env(var: str): 52 | import platform 53 | 54 | if platform.system() == "Windows": 55 | return f"$env:{var}" 56 | else: 57 | return f"${var}" 58 | 59 | 60 | config_args = [ 61 | "cmake", 62 | "{root}", 63 | "-DCMAKE_INSTALL_PREFIX={install_path}", 64 | f'-DCMAKE_MODULE_PATH="{env("CMAKE_MODULE_PATH")}"', 65 | f'-DCMAKE_BUILD_TYPE="{env("REZ_BUILD_CONFIG")}"', 66 | f'-DPython_ROOT={env("Python_ROOT")}', 67 | f'-DPython_EXECUTABLE={env("Python_EXECUTABLE")}', 68 | "-DOCIO_BUILD_TESTS=OFF", 69 | "-DOCIO_BUILD_GPU_TESTS=OFF", 70 | "-DOCIO_INSTALL_EXT_PACKAGES=ALL", 71 | " -G Ninja", 72 | ] 73 | 74 | build_command = ( 75 | " ".join(config_args) 76 | + f" && cmake --build . --target install --config {env('REZ_BUILD_CONFIG')}" 77 | ) 78 | 79 | 80 | def pre_cook(): 81 | download_and_unpack( 82 | f"https://github.com/AcademySoftwareFoundation/OpenColorIO/archive/refs/tags/v{version}.tar.gz" 83 | ) 84 | -------------------------------------------------------------------------------- /otio/0.15/package.py: -------------------------------------------------------------------------------- 1 | name = "otio" 2 | version = "0.15" 3 | 4 | requires = [ 5 | "python", 6 | ] 7 | 8 | hashed_variants = True 9 | 10 | 11 | @early() 12 | def build_requires(): 13 | import platform 14 | 15 | if platform.system() == "Windows": 16 | return ["cmake-3.18+", "vs"] 17 | else: 18 | return ["cmake-3.18+"] 19 | 20 | 21 | @early() 22 | def variants(): 23 | import os, ast 24 | 25 | cook_variant = os.getenv("REZ_COOK_VARIANT") 26 | if cook_variant: 27 | # If we're building the package, we want to use the variant supplied to us 28 | return [ast.literal_eval(cook_variant)] 29 | else: 30 | # Otherwise tell rez-cook what variants we are capable of building 31 | req = ["cfg", "python"] 32 | return [x + req for x in [ 33 | ["platform-linux", "arch-x86_64", "cxx11abi"], 34 | ["platform-windows", "arch-AMD64", "vs"], 35 | ] 36 | ] 37 | 38 | 39 | def env(var: str): 40 | import platform 41 | 42 | if platform.system() == "Windows": 43 | return f"$env:{var}" 44 | else: 45 | return f"${var}" 46 | 47 | 48 | def commands(): 49 | import os 50 | 51 | def envvar(var: str): 52 | import platform 53 | 54 | if platform.system() == "Windows": 55 | return f"$env:{var}" 56 | else: 57 | return f"${var}" 58 | 59 | env.OTIO_ROOT = "{root}" 60 | env.CMAKE_PREFIX_PATH.append("{root}") 61 | env.CMAKE_PREFIX_PATH.append("{root}/share") 62 | 63 | env.PYTHONPATH.prepend(f"{{root}}/python") 64 | 65 | import platform 66 | 67 | if platform.system() == "Linux": 68 | # Shared libraries get put in the python installation for reasons (python-3.8 idiocy?) 69 | env.LD_LIBRARY_PATH.prepend("{root}/python/opentimelineio") 70 | env.LD_LIBRARY_PATH.prepend("{root}/python/opentime") 71 | 72 | 73 | 74 | config_args = [ 75 | "cmake", 76 | "{root}", 77 | "-DCMAKE_INSTALL_PREFIX={install_path}", 78 | f'-DCMAKE_MODULE_PATH="{env("CMAKE_MODULE_PATH")}"', 79 | f'-DCMAKE_BUILD_TYPE="{env("REZ_BUILD_CONFIG")}"', 80 | "-DOTIO_PYTHON_INSTALL=ON", 81 | " -G Ninja", 82 | ] 83 | 84 | build_command = ( 85 | " ".join(config_args) 86 | + f" && cmake --build . --target install --config {env('REZ_BUILD_CONFIG')}" 87 | ) 88 | 89 | 90 | def pre_cook(): 91 | archive = f"v{version}.tar.gz" 92 | fetch_repository("https://github.com/AcademySoftwareFoundation/OpenTimelineIO.git", f"v{version}") 93 | 94 | -------------------------------------------------------------------------------- /osl/1.13.8.0/package.py: -------------------------------------------------------------------------------- 1 | name = "osl" 2 | version = "1.13.8.0" 3 | 4 | requires = [ 5 | "oiio", 6 | "llvm", 7 | ] 8 | 9 | hashed_variants = True 10 | 11 | 12 | @early() 13 | def build_requires(): 14 | import platform 15 | 16 | if platform.system() == "Windows": 17 | return ["cmake", "vs"] 18 | else: 19 | return ["cmake"] 20 | 21 | 22 | @early() 23 | def variants(): 24 | import os, ast 25 | 26 | cook_variant = os.getenv("REZ_COOK_VARIANT") 27 | if cook_variant: 28 | # If we're building the package, we want to use the variant supplied to us 29 | return [ast.literal_eval(cook_variant)] 30 | else: 31 | # Otherwise tell rez-cook what variants we are capable of building 32 | req = ["oiio", "llvm"] 33 | return [x + req for x in [ 34 | ["platform-linux", "arch-x86_64", "cxx11abi"], 35 | ["platform-windows", "arch-AMD64", "vs"], 36 | ] 37 | ] 38 | 39 | 40 | def env(var: str): 41 | import platform 42 | 43 | if platform.system() == "Windows": 44 | return f"$env:{var}" 45 | else: 46 | return f"${var}" 47 | 48 | 49 | def commands(): 50 | def envvar(var: str): 51 | import platform 52 | 53 | if platform.system() == "Windows": 54 | return f"$env:{var}" 55 | else: 56 | return f"${var}" 57 | 58 | env.OpenShadingLanguage_ROOT = "{root}" 59 | env.OSL_ROOT = "{root}" 60 | env.CMAKE_PREFIX_PATH.append("{root}") 61 | env.PATH.prepend("{root}/bin") 62 | 63 | env.PYTHONPATH.prepend(f"{{root}}/lib/python{envvar('PYTHON_MAJMIN_VERSION')}/site-packages") 64 | 65 | import platform 66 | 67 | if platform.system() == "Linux": 68 | env.LD_LIBRARY_PATH.prepend("{root}/lib") 69 | 70 | 71 | 72 | config_args = [ 73 | "cmake", 74 | "{root}", 75 | "-DCMAKE_INSTALL_PREFIX={install_path}", 76 | f'-DCMAKE_MODULE_PATH="{env("CMAKE_MODULE_PATH")}"', 77 | f'-DCMAKE_BUILD_TYPE="{env("REZ_BUILD_CONFIG")}"', 78 | "-DCMAKE_CXX_STANDARD=17", 79 | # "-DCMAKE_CXX_FLAGS=-I/usr/include/c++/11/", 80 | # "-DLLVM_COMPILE_FLAGS=-I/usr/include/c++/11;-I/usr/include/x86_64-linux-gnu/c++/11", 81 | "-DUSE_LLVM_BITCODE=OFF", 82 | " -G Ninja", 83 | ] 84 | 85 | build_command = ( 86 | " ".join(config_args) 87 | + f" && cmake --build . --target install --config {env('REZ_BUILD_CONFIG')}" 88 | ) 89 | 90 | 91 | def pre_cook(): 92 | download_and_unpack( 93 | f"https://github.com/AcademySoftwareFoundation/OpenShadingLanguage/archive/refs/tags/v{version}.tar.gz" 94 | ) 95 | 96 | -------------------------------------------------------------------------------- /python/3.11.9/package.py: -------------------------------------------------------------------------------- 1 | name = "python" 2 | version = "3.11.9" 3 | 4 | 5 | @early() 6 | def build_requires(): 7 | import platform 8 | 9 | if platform.system() == "Windows": 10 | return ["cmake", "vs"] 11 | else: 12 | return ["cmake"] 13 | 14 | 15 | @early() 16 | def variants(): 17 | import os, ast 18 | 19 | cook_variant = os.getenv("REZ_COOK_VARIANT") 20 | if cook_variant: 21 | # If we're building the package, we want to use the variant supplied to us 22 | return [ast.literal_eval(cook_variant)] 23 | else: 24 | # Otherwise tell rez-cook what variants we are capable of building 25 | return [ 26 | ["platform-linux", "arch-x86_64"], 27 | ["platform-windows", "arch-AMD64"], 28 | ] 29 | 30 | 31 | def commands(): 32 | import platform 33 | 34 | env.PYTHONHOME = "{root}" 35 | env.Python_ROOT = "{root}" 36 | 37 | env.PYTHON_VERSION = "{version}" 38 | env.PYTHON_MAJMIN_VERSION = ".".join(f"{version}".split(".")[:2]) 39 | 40 | if platform.system() == "Windows": 41 | env.PATH.append("{root}") 42 | env.PYTHONPATH = "{root}" 43 | env.Python_EXECUTABLE = "{root}/python.exe" 44 | else: 45 | env.PATH.append("{root}/bin") 46 | env.LD_LIBRARY_PATH.prepend("{root}/lib") 47 | env.Python_EXECUTABLE = "{root}/bin/python3" 48 | env.PYTHONPATH = "{root}/lib/python3.11" 49 | 50 | 51 | def pre_cook(): 52 | import platform 53 | 54 | if platform.system() == "Windows": 55 | download_and_unpack( 56 | f"https://github.com/anderslanglands/rez-recipes/releases/download/python-{version}/python-{version}.zip", 57 | move_up=False, 58 | ) 59 | else: 60 | download_and_unpack( 61 | f"https://www.python.org/ftp/python/{version}/Python-{version}.tgz" 62 | ) 63 | 64 | 65 | @early() 66 | def build_command(): 67 | import platform 68 | 69 | if platform.system() == "Windows": 70 | return f'Move-Item -Path "$env:REZ_BUILD_SOURCE_PATH/python-{version}/*" -Destination "$env:REZ_BUILD_INSTALL_PATH"' 71 | else: 72 | return f""" 73 | cd $REZ_BUILD_SOURCE_PATH && \ 74 | ./configure --prefix=$REZ_BUILD_INSTALL_PATH \ 75 | --enable-ipv6 --enable-shared \ 76 | --with-dbmliborder=gdbm:ndbm:bdb \ 77 | --with-system-ffi --with-ensurepip --with-computed-gotos=yes --with-ssl && \ 78 | make install -j$REZ_BUILD_THREAD_COUNT && \ 79 | ln -s $REZ_BUILD_INSTALL_PATH/bin/python3 $REZ_BUILD_INSTALL_PATH/bin/python 80 | """ 81 | -------------------------------------------------------------------------------- /python/3.10.5/package.py: -------------------------------------------------------------------------------- 1 | name = "python" 2 | version = "3.10.5" 3 | 4 | 5 | @early() 6 | def build_requires(): 7 | import platform 8 | 9 | if platform.system() == "Windows": 10 | return ["cmake", "vs"] 11 | else: 12 | return ["cmake"] 13 | 14 | 15 | @early() 16 | def variants(): 17 | import os, ast 18 | 19 | cook_variant = os.getenv("REZ_COOK_VARIANT") 20 | if cook_variant: 21 | # If we're building the package, we want to use the variant supplied to us 22 | return [ast.literal_eval(cook_variant)] 23 | else: 24 | # Otherwise tell rez-cook what variants we are capable of building 25 | return [ 26 | ["platform-linux", "arch-x86_64"], 27 | ["platform-windows", "arch-AMD64"], 28 | ] 29 | 30 | 31 | def commands(): 32 | import platform 33 | 34 | env.PYTHONHOME = "{root}" 35 | env.Python_ROOT = "{root}" 36 | 37 | env.PYTHON_VERSION = "{version}" 38 | env.PYTHON_MAJMIN_VERSION = ".".join(f"{version}".split(".")[:2]) 39 | 40 | if platform.system() == "Windows": 41 | env.PATH.append("{root}") 42 | env.PYTHONPATH = "{root}" 43 | env.Python_EXECUTABLE = "{root}/python.exe" 44 | else: 45 | env.PATH.append("{root}/bin") 46 | env.LD_LIBRARY_PATH.prepend("{root}/lib") 47 | env.Python_EXECUTABLE = "{root}/bin/python3" 48 | env.PYTHONPATH = "{root}/lib/python3.10" 49 | 50 | 51 | def pre_cook(): 52 | import platform 53 | 54 | if platform.system() == "Windows": 55 | download_and_unpack( 56 | f"https://github.com/anderslanglands/rez-recipes/releases/download/python-{version}/python-{version}.zip", 57 | move_up=False, 58 | ) 59 | else: 60 | download_and_unpack( 61 | f"https://www.python.org/ftp/python/{version}/Python-{version}.tgz" 62 | ) 63 | 64 | 65 | @early() 66 | def build_command(): 67 | import platform 68 | 69 | if platform.system() == "Windows": 70 | return f'Move-Item -Path "$env:REZ_BUILD_SOURCE_PATH/python-{version}/*" -Destination "$env:REZ_BUILD_INSTALL_PATH"' 71 | else: 72 | return f""" 73 | cd $REZ_BUILD_SOURCE_PATH && \ 74 | ./configure --prefix=$REZ_BUILD_INSTALL_PATH \ 75 | --enable-optimizations --enable-ipv6 --enable-shared \ 76 | --with-dbmliborder=gdbm:ndbm:bdb --with-system-expat \ 77 | --with-system-ffi --with-ensurepip --with-computed-gotos=yes --with-ssl && \ 78 | make install -j$REZ_BUILD_THREAD_COUNT && \ 79 | ln -s $REZ_BUILD_INSTALL_PATH/bin/python3 $REZ_BUILD_INSTALL_PATH/bin/python 80 | """ 81 | -------------------------------------------------------------------------------- /python/3.9.12/package.py: -------------------------------------------------------------------------------- 1 | name = "python" 2 | version = "3.9.12" 3 | 4 | 5 | @early() 6 | def build_requires(): 7 | import platform 8 | 9 | if platform.system() == "Windows": 10 | return ["cmake", "vs"] 11 | else: 12 | return ["cmake"] 13 | 14 | 15 | @early() 16 | def variants(): 17 | import os, ast 18 | 19 | cook_variant = os.getenv("REZ_COOK_VARIANT") 20 | if cook_variant: 21 | # If we're building the package, we want to use the variant supplied to us 22 | return [ast.literal_eval(cook_variant)] 23 | else: 24 | # Otherwise tell rez-cook what variants we are capable of building 25 | return [ 26 | ["platform-linux", "arch-x86_64"], 27 | ["platform-windows", "arch-AMD64"], 28 | ] 29 | 30 | 31 | def commands(): 32 | import platform 33 | 34 | env.PYTHONHOME = "{root}" 35 | env.Python_ROOT = "{root}" 36 | 37 | env.PYTHON_VERSION = "{version}" 38 | env.PYTHON_MAJMIN_VERSION = ".".join(f"{version}".split(".")[:2]) 39 | 40 | if platform.system() == "Windows": 41 | env.PATH.append("{root}") 42 | env.PYTHONPATH.prepend("{root}") 43 | env.Python_EXECUTABLE = "{root}/python.exe" 44 | else: 45 | env.PATH.append("{root}/bin") 46 | env.LD_LIBRARY_PATH.prepend("{root}/lib") 47 | env.Python_EXECUTABLE = "{root}/bin/python3" 48 | env.PYTHONPATH.prepend("{root}/lib/python3.9") 49 | 50 | 51 | def pre_cook(): 52 | import platform 53 | 54 | if platform.system() == "Windows": 55 | download_and_unpack( 56 | f"https://github.com/anderslanglands/rez-recipes/releases/download/python-3.7.9-3.9.12/python-{version}.zip", 57 | move_up=False, 58 | ) 59 | else: 60 | download_and_unpack( 61 | f"https://www.python.org/ftp/python/{version}/Python-{version}.tgz" 62 | ) 63 | 64 | 65 | @early() 66 | def build_command(): 67 | import platform 68 | 69 | if platform.system() == "Windows": 70 | return f'Move-Item -Path "$env:REZ_BUILD_SOURCE_PATH/python-{version}/*" -Destination "$env:REZ_BUILD_INSTALL_PATH"' 71 | else: 72 | return f""" 73 | cd $REZ_BUILD_SOURCE_PATH && \ 74 | ./configure --prefix=$REZ_BUILD_INSTALL_PATH \ 75 | --enable-optimizations --enable-ipv6 --enable-shared \ 76 | --with-dbmliborder=gdbm:ndbm:bdb --with-system-expat \ 77 | --with-system-ffi --with-ensurepip --with-computed-gotos=yes --with-ssl && \ 78 | make install -j$REZ_BUILD_THREAD_COUNT && \ 79 | ln -s $REZ_BUILD_INSTALL_PATH/bin/python3 $REZ_BUILD_INSTALL_PATH/bin/python 80 | """ 81 | -------------------------------------------------------------------------------- /python/3.7.9/package.py: -------------------------------------------------------------------------------- 1 | name = "python" 2 | version = "3.7.9" 3 | 4 | 5 | @early() 6 | def build_requires(): 7 | import platform 8 | 9 | if platform.system() == "Windows": 10 | return ["cmake", "vs"] 11 | else: 12 | return ["cmake"] 13 | 14 | 15 | @early() 16 | def variants(): 17 | import os, ast 18 | 19 | cook_variant = os.getenv("REZ_COOK_VARIANT") 20 | if cook_variant: 21 | # If we're building the package, we want to use the variant supplied to us 22 | return [ast.literal_eval(cook_variant)] 23 | else: 24 | # Otherwise tell rez-cook what variants we are capable of building 25 | return [ 26 | ["platform-linux", "arch-x86_64"], 27 | ["platform-windows", "arch-AMD64"], 28 | ] 29 | 30 | 31 | def commands(): 32 | import platform 33 | 34 | env.PYTHONHOME = "{root}" 35 | env.Python_ROOT = "{root}" 36 | 37 | env.PYTHON_VERSION = "{version}" 38 | env.PYTHON_MAJMIN_VERSION = ".".join(f"{version}".split(".")[:2]) 39 | 40 | if platform.system() == "Windows": 41 | env.PATH.append("{root}") 42 | env.PYTHONPATH = "{root}" 43 | env.Python_EXECUTABLE = "{root}/python.exe" 44 | else: 45 | env.PATH.append("{root}/bin") 46 | env.LD_LIBRARY_PATH.prepend("{root}/lib") 47 | env.Python_EXECUTABLE = "{root}/bin/python" 48 | env.PYTHONPATH = "{root}/lib/python3.7" 49 | 50 | 51 | def pre_cook(): 52 | import platform 53 | 54 | if platform.system() == "Windows": 55 | download_and_unpack( 56 | f"https://github.com/anderslanglands/rez-recipes/releases/download/python-3.7.9-3.9.12/python-{version}.zip", 57 | move_up=False, 58 | ) 59 | else: 60 | download_and_unpack( 61 | f"https://www.python.org/ftp/python/{version}/Python-{version}.tgz" 62 | ) 63 | 64 | 65 | @early() 66 | def build_command(): 67 | import platform 68 | 69 | if platform.system() == "Windows": 70 | return f'Move-Item -Path "$env:REZ_BUILD_SOURCE_PATH/python-{version}/*" -Destination "$env:REZ_BUILD_INSTALL_PATH"' 71 | else: 72 | return f""" 73 | cd $REZ_BUILD_SOURCE_PATH && \ 74 | ./configure --prefix=$REZ_BUILD_INSTALL_PATH \ 75 | --enable-optimizations \ 76 | --enable-ipv6 \ 77 | --enable-shared \ 78 | --with-dbmliborder=gdbm:ndbm:bdb \ 79 | --with-system-expat \ 80 | --with-system-ffi \ 81 | --with-ensurepip \ 82 | --without-pymalloc \ 83 | --with-computed-gotos=yes && \ 84 | make install -j$REZ_BUILD_THREAD_COUNT && \ 85 | ln -s $REZ_BUILD_INSTALL_PATH/bin/python3 $REZ_BUILD_INSTALL_PATH/bin/python && \ 86 | """ 87 | -------------------------------------------------------------------------------- /dusd/20.08/package.py: -------------------------------------------------------------------------------- 1 | name = "usd" 2 | version = "20.08" 3 | 4 | requires = [ 5 | "openexr-3", 6 | "boost-1.70+", 7 | "ocio-2", 8 | "oiio-2.3", 9 | "osd-3.4", 10 | "tbb-2020", 11 | "glew-2.1", 12 | "jinja2-3.1", 13 | "pyside2-5.15", 14 | "pyopengl-3.1", 15 | "numpy", 16 | "python-<3.8", 17 | ] 18 | 19 | hashed_variants = True 20 | 21 | 22 | @early() 23 | def build_requires(): 24 | import platform 25 | 26 | if platform.system() == "Windows": 27 | return ["cmake", "vs"] 28 | else: 29 | return ["cmake"] 30 | 31 | 32 | @early() 33 | def variants(): 34 | import os, ast 35 | 36 | cook_variant = os.getenv("REZ_COOK_VARIANT") 37 | if cook_variant: 38 | # If we're building the package, we want to use the variant supplied to us 39 | return [ast.literal_eval(cook_variant)] 40 | else: 41 | # Otherwise tell rez-cook what variants we are capable of building 42 | req = ["cfg", "boost", "tbb", "openexr", "ocio", "oiio", "python", "ptex", "osd"] 43 | return [x + req for x in [ 44 | ["platform-linux", "arch-x86_64", "cxx11abi"], 45 | ["platform-windows", "arch-AMD64", "vs"], 46 | ] 47 | ] 48 | 49 | 50 | def commands(): 51 | env.USD_ROOT = "{root}" 52 | env.CMAKE_PREFIX_PATH.prepend("{root}") 53 | env.PATH.prepend("{root}/bin") 54 | env.PATH.prepend("{root}/lib") 55 | env.PYTHONPATH.prepend("{root}/lib/python") 56 | 57 | import platform 58 | 59 | if platform.system() == "Linux": 60 | env.LD_LIBRARY_PATH.prepend("{root}/bin") 61 | env.PYOPENGL_PLATFORM = "glx" 62 | 63 | 64 | def env(var: str): 65 | import platform 66 | 67 | if platform.system() == "Windows": 68 | return f"$env:{var}" 69 | else: 70 | return f"${var}" 71 | 72 | 73 | config_args = [ 74 | "cmake", 75 | "{root}", 76 | "-DCMAKE_INSTALL_PREFIX={install_path}", 77 | f'-DCMAKE_MODULE_PATH="{env("CMAKE_MODULE_PATH")}"', 78 | f'-DCMAKE_BUILD_TYPE="{env("REZ_BUILD_CONFIG")}"', 79 | f'-DTBB_ROOT_DIR="{env("TBB_ROOT")}"', 80 | f'-DOPENEXR_LOCATION="{env("OPENEXR_ROOT")}"', 81 | f'-DOPENSUBDIV_ROOT_DIR="{env("OPENSUBDIV_ROOT")}"', 82 | f'-DPTEX_LOCATION="{env("Ptex_ROOT")}"', 83 | f'-DOIIO_LOCATION="{env("OpenImageIO_ROOT")}"', 84 | f'-DBOOST_ROOT="{env("Boost_ROOT")}"', 85 | f'-DPython_ROOT="{env("Python_ROOT")}"', 86 | "-DPXR_BUILD_DOCUMENTATION=FALSE", 87 | "-DPXR_BUILD_TESTS=FALSE", 88 | " -G Ninja", 89 | ] 90 | 91 | build_command = ( 92 | " ".join(config_args) 93 | + f" && cmake --build . --target install --config {env('REZ_BUILD_CONFIG')}" 94 | ) 95 | 96 | 97 | def pre_cook(): 98 | download_and_unpack( 99 | f"https://github.com/PixarAnimationStudios/USD/archive/refs/tags/v{version}.tar.gz" 100 | ) 101 | -------------------------------------------------------------------------------- /usd/20.08/package.py: -------------------------------------------------------------------------------- 1 | name = "usd" 2 | version = "20.08" 3 | 4 | requires = [ 5 | "openexr-3", 6 | "boost-1.70+", 7 | "ocio-2", 8 | "oiio-2.3", 9 | "osd-3.4", 10 | "tbb-2020", 11 | "glew-2.1", 12 | "jinja2-3.1", 13 | "pyside2-5.15", 14 | "pyopengl-3.1", 15 | "numpy", 16 | "python-<3.8", 17 | ] 18 | 19 | hashed_variants = True 20 | 21 | 22 | @early() 23 | def build_requires(): 24 | import platform 25 | 26 | if platform.system() == "Windows": 27 | return ["cmake", "vs"] 28 | else: 29 | return ["cmake"] 30 | 31 | 32 | @early() 33 | def variants(): 34 | import os, ast 35 | 36 | cook_variant = os.getenv("REZ_COOK_VARIANT") 37 | if cook_variant: 38 | # If we're building the package, we want to use the variant supplied to us 39 | return [ast.literal_eval(cook_variant)] 40 | else: 41 | # Otherwise tell rez-cook what variants we are capable of building 42 | req = ["cfg", "boost", "tbb", "openexr", "ocio", "oiio", "python", "ptex", "osd"] 43 | return [x + req for x in [ 44 | ["platform-linux", "arch-x86_64", "cxx11abi"], 45 | ["platform-windows", "arch-AMD64", "vs"], 46 | ] 47 | ] 48 | 49 | 50 | def commands(): 51 | env.USD_ROOT = "{root}" 52 | env.CMAKE_PREFIX_PATH.prepend("{root}") 53 | env.PATH.prepend("{root}/bin") 54 | env.PATH.prepend("{root}/lib") 55 | env.PYTHONPATH.prepend("{root}/lib/python") 56 | 57 | import platform 58 | 59 | if platform.system() == "Linux": 60 | env.LD_LIBRARY_PATH.prepend("{root}/bin") 61 | env.PYOPENGL_PLATFORM = "glx" 62 | 63 | 64 | def env(var: str): 65 | import platform 66 | 67 | if platform.system() == "Windows": 68 | return f"$env:{var}" 69 | else: 70 | return f"${var}" 71 | 72 | 73 | config_args = [ 74 | "cmake", 75 | "{root}", 76 | "-DCMAKE_INSTALL_PREFIX={install_path}", 77 | f'-DCMAKE_MODULE_PATH="{env("CMAKE_MODULE_PATH")}"', 78 | f'-DCMAKE_BUILD_TYPE="{env("REZ_BUILD_CONFIG")}"', 79 | f'-DTBB_ROOT_DIR="{env("TBB_ROOT")}"', 80 | f'-DOPENEXR_LOCATION="{env("OPENEXR_ROOT")}"', 81 | f'-DOPENSUBDIV_ROOT_DIR="{env("OPENSUBDIV_ROOT")}"', 82 | f'-DPTEX_LOCATION="{env("Ptex_ROOT")}"', 83 | f'-DOIIO_LOCATION="{env("OpenImageIO_ROOT")}"', 84 | f'-DBOOST_ROOT="{env("Boost_ROOT")}"', 85 | f'-DPython_ROOT="{env("Python_ROOT")}"', 86 | "-DPXR_BUILD_DOCUMENTATION=FALSE", 87 | "-DPXR_BUILD_TESTS=FALSE", 88 | " -G Ninja", 89 | ] 90 | 91 | build_command = ( 92 | " ".join(config_args) 93 | + f" && cmake --build . --target install --config {env('REZ_BUILD_CONFIG')}" 94 | ) 95 | 96 | 97 | def pre_cook(): 98 | download_and_unpack( 99 | f"https://github.com/PixarAnimationStudios/USD/archive/refs/tags/v{version}.tar.gz" 100 | ) 101 | -------------------------------------------------------------------------------- /dusd/21.08/package.py: -------------------------------------------------------------------------------- 1 | name = "usd" 2 | version = "21.08" 3 | 4 | requires = [ 5 | "openexr-3", 6 | "boost-1.70+", 7 | "ocio-2", 8 | "oiio-2.3", 9 | "osd-3.4", 10 | "tbb-2020", 11 | "glew-2.1", 12 | "jinja2-3.1", 13 | "pyside2-5.15", 14 | "pyopengl-3.1", 15 | "numpy", 16 | "python", 17 | ] 18 | 19 | 20 | hashed_variants = True 21 | 22 | @early() 23 | def build_requires(): 24 | import platform 25 | 26 | if platform.system() == "Windows": 27 | return ["cmake", "vs"] 28 | else: 29 | return ["cmake"] 30 | 31 | 32 | @early() 33 | def variants(): 34 | import os, ast 35 | 36 | cook_variant = os.getenv("REZ_COOK_VARIANT") 37 | if cook_variant: 38 | # If we're building the package, we want to use the variant supplied to us 39 | return [ast.literal_eval(cook_variant)] 40 | else: 41 | # Otherwise tell rez-cook what variants we are capable of building 42 | req = ["cfg", "boost", "tbb", "openexr", "ocio", "oiio", "python", "ptex", "osd"] 43 | return [x + req for x in [ 44 | ["platform-linux", "arch-x86_64", "cxx11abi"], 45 | ["platform-windows", "arch-AMD64", "vs"], 46 | ] 47 | ] 48 | 49 | 50 | def commands(): 51 | env.USD_ROOT = "{root}" 52 | env.CMAKE_PREFIX_PATH.prepend("{root}") 53 | env.PATH.prepend("{root}/bin") 54 | env.PATH.prepend("{root}/lib") 55 | env.PYTHONPATH.prepend("{root}/lib/python") 56 | 57 | import platform 58 | 59 | if platform.system() == "Linux": 60 | env.LD_LIBRARY_PATH.prepend("{root}/bin") 61 | env.PYOPENGL_PLATFORM = "glx" 62 | 63 | 64 | def env(var: str): 65 | import platform 66 | 67 | if platform.system() == "Windows": 68 | return f"$env:{var}" 69 | else: 70 | return f"${var}" 71 | 72 | 73 | config_args = [ 74 | "cmake", 75 | "{root}", 76 | "-DCMAKE_INSTALL_PREFIX={install_path}", 77 | f'-DCMAKE_MODULE_PATH="{env("CMAKE_MODULE_PATH")}"', 78 | f'-DCMAKE_BUILD_TYPE="{env("REZ_BUILD_CONFIG")}"', 79 | f'-DTBB_ROOT_DIR="{env("TBB_ROOT")}"', 80 | f'-DOPENEXR_LOCATION="{env("OPENEXR_ROOT")}"', 81 | f'-DOPENSUBDIV_ROOT_DIR="{env("OPENSUBDIV_ROOT")}"', 82 | f'-DPTEX_LOCATION="{env("Ptex_ROOT")}"', 83 | f'-DOIIO_LOCATION="{env("OpenImageIO_ROOT")}"', 84 | f'-DBOOST_ROOT="{env("Boost_ROOT")}"', 85 | f'-DPython_ROOT="{env("Python_ROOT")}"', 86 | "-DPXR_BUILD_DOCUMENTATION=FALSE", 87 | "-DPXR_BUILD_TESTS=FALSE", 88 | # Fix for boost inserting the wrong library names into the libs with 89 | # --layout=system... 90 | f'-DCMAKE_CXX_FLAGS="-DBOOST_ALL_NO_LIB {env("CXXFLAGS")}"', 91 | " -G Ninja", 92 | ] 93 | 94 | build_command = ( 95 | " ".join(config_args) 96 | + f" && cmake --build . --target install --config {env('REZ_BUILD_CONFIG')}" 97 | ) 98 | 99 | 100 | def pre_cook(): 101 | download_and_unpack( 102 | f"https://github.com/PixarAnimationStudios/USD/archive/refs/tags/v{version}.tar.gz" 103 | ) 104 | -------------------------------------------------------------------------------- /usd/21.08/package.py: -------------------------------------------------------------------------------- 1 | name = "usd" 2 | version = "21.08" 3 | 4 | requires = [ 5 | "openexr-3", 6 | "boost-1.70+", 7 | "ocio-2", 8 | "oiio-2.3", 9 | "osd-3.4", 10 | "tbb-2020", 11 | "glew-2.1", 12 | "jinja2-3.1", 13 | "pyside2-5.15", 14 | "pyopengl-3.1", 15 | "numpy", 16 | "python", 17 | ] 18 | 19 | 20 | hashed_variants = True 21 | 22 | @early() 23 | def build_requires(): 24 | import platform 25 | 26 | if platform.system() == "Windows": 27 | return ["cmake", "vs"] 28 | else: 29 | return ["cmake"] 30 | 31 | 32 | @early() 33 | def variants(): 34 | import os, ast 35 | 36 | cook_variant = os.getenv("REZ_COOK_VARIANT") 37 | if cook_variant: 38 | # If we're building the package, we want to use the variant supplied to us 39 | return [ast.literal_eval(cook_variant)] 40 | else: 41 | # Otherwise tell rez-cook what variants we are capable of building 42 | req = ["cfg", "boost", "tbb", "openexr", "ocio", "oiio", "python", "ptex", "osd"] 43 | return [x + req for x in [ 44 | ["platform-linux", "arch-x86_64", "cxx11abi"], 45 | ["platform-windows", "arch-AMD64", "vs"], 46 | ] 47 | ] 48 | 49 | 50 | def commands(): 51 | env.USD_ROOT = "{root}" 52 | env.CMAKE_PREFIX_PATH.prepend("{root}") 53 | env.PATH.prepend("{root}/bin") 54 | env.PATH.prepend("{root}/lib") 55 | env.PYTHONPATH.prepend("{root}/lib/python") 56 | 57 | import platform 58 | 59 | if platform.system() == "Linux": 60 | env.LD_LIBRARY_PATH.prepend("{root}/bin") 61 | env.PYOPENGL_PLATFORM = "glx" 62 | 63 | 64 | def env(var: str): 65 | import platform 66 | 67 | if platform.system() == "Windows": 68 | return f"$env:{var}" 69 | else: 70 | return f"${var}" 71 | 72 | 73 | config_args = [ 74 | "cmake", 75 | "{root}", 76 | "-DCMAKE_INSTALL_PREFIX={install_path}", 77 | f'-DCMAKE_MODULE_PATH="{env("CMAKE_MODULE_PATH")}"', 78 | f'-DCMAKE_BUILD_TYPE="{env("REZ_BUILD_CONFIG")}"', 79 | f'-DTBB_ROOT_DIR="{env("TBB_ROOT")}"', 80 | f'-DOPENEXR_LOCATION="{env("OPENEXR_ROOT")}"', 81 | f'-DOPENSUBDIV_ROOT_DIR="{env("OPENSUBDIV_ROOT")}"', 82 | f'-DPTEX_LOCATION="{env("Ptex_ROOT")}"', 83 | f'-DOIIO_LOCATION="{env("OpenImageIO_ROOT")}"', 84 | f'-DBOOST_ROOT="{env("Boost_ROOT")}"', 85 | f'-DPython_ROOT="{env("Python_ROOT")}"', 86 | "-DPXR_BUILD_DOCUMENTATION=FALSE", 87 | "-DPXR_BUILD_TESTS=FALSE", 88 | # Fix for boost inserting the wrong library names into the libs with 89 | # --layout=system... 90 | f'-DCMAKE_CXX_FLAGS="-DBOOST_ALL_NO_LIB {env("CXXFLAGS")}"', 91 | " -G Ninja", 92 | ] 93 | 94 | build_command = ( 95 | " ".join(config_args) 96 | + f" && cmake --build . --target install --config {env('REZ_BUILD_CONFIG')}" 97 | ) 98 | 99 | 100 | def pre_cook(): 101 | download_and_unpack( 102 | f"https://github.com/PixarAnimationStudios/USD/archive/refs/tags/v{version}.tar.gz" 103 | ) 104 | -------------------------------------------------------------------------------- /oiio/2.2.21.0/package.py: -------------------------------------------------------------------------------- 1 | name = "oiio" 2 | version = "2.2.21.0" 3 | 4 | requires = [ 5 | "boost-1.70+", 6 | "openexr-3.0+<3.2", 7 | "ocio-2.0+", 8 | "tiff-4.3", 9 | "openjpeg-2.4", 10 | "jpegturbo-2.0", 11 | "png-1.6", 12 | "raw-0.21", 13 | "python", 14 | "pybind11-2.8", 15 | "webp-1.1", 16 | "zlib-1.2", 17 | "ptex-2.4", 18 | "gif-5.2.1", 19 | "tbb", 20 | ] 21 | 22 | hashed_variants = True 23 | 24 | 25 | @early() 26 | def build_requires(): 27 | import platform 28 | 29 | if platform.system() == "Windows": 30 | return ["cmake", "vs"] 31 | else: 32 | return ["cmake"] 33 | 34 | 35 | @early() 36 | def variants(): 37 | import os, ast 38 | 39 | cook_variant = os.getenv("REZ_COOK_VARIANT") 40 | if cook_variant: 41 | # If we're building the package, we want to use the variant supplied to us 42 | return [ast.literal_eval(cook_variant)] 43 | else: 44 | # Otherwise tell rez-cook what variants we are capable of building 45 | req = ["cfg", "boost", "tbb", "openexr", "ocio", "python", "ptex"] 46 | return [x + req for x in [ 47 | ["platform-linux", "arch-x86_64", "cxx11abi"], 48 | ["platform-windows", "arch-AMD64", "vs"], 49 | ] 50 | ] 51 | 52 | 53 | def env(var: str): 54 | import platform 55 | 56 | if platform.system() == "Windows": 57 | return f"$env:{var}" 58 | else: 59 | return f"${var}" 60 | 61 | 62 | def commands(): 63 | import os 64 | 65 | def envvar(var: str): 66 | import platform 67 | 68 | if platform.system() == "Windows": 69 | return f"$env:{var}" 70 | else: 71 | return f"${var}" 72 | 73 | env.OpenImageIO_ROOT = "{root}" 74 | env.OPENIMAGEIO_HOME = "{root}" 75 | env.OPENIMAGEIO_DIR = "{root}" 76 | env.OPENIMAGEIO_LOCATION = "{root}" 77 | env.CMAKE_PREFIX_PATH.append("{root}") 78 | env.PATH.prepend("{root}/bin") 79 | 80 | env.PYTHONPATH.prepend(f"{{root}}/lib/python{envvar('PYTHON_MAJMIN_VERSION')}/site-packages") 81 | 82 | import platform 83 | 84 | if platform.system() == "Linux": 85 | env.LD_LIBRARY_PATH.prepend("{root}/bin") 86 | 87 | 88 | 89 | config_args = [ 90 | "cmake", 91 | "{root}", 92 | "-DCMAKE_INSTALL_PREFIX={install_path}", 93 | f'-DCMAKE_MODULE_PATH="{env("CMAKE_MODULE_PATH")}"', 94 | f'-DCMAKE_BUILD_TYPE="{env("REZ_BUILD_CONFIG")}"', 95 | "-DBUILD_DOCS=OFF", 96 | "-DOIIO_BUILD_TESTS=OFF", 97 | "-DBUILD_TESTING=OFF", 98 | f'-DPython_ROOT="{env("Python_ROOT")}"', 99 | f'-DPython_EXECUTABLE="{env("Python_EXECUTABLE")}"', 100 | " -G Ninja", 101 | ] 102 | 103 | build_command = ( 104 | " ".join(config_args) 105 | + f" && cmake --build . --target install --config {env('REZ_BUILD_CONFIG')}" 106 | ) 107 | 108 | 109 | def pre_cook(): 110 | archive = f"v{version}.tar.gz" 111 | download_and_unpack( 112 | f"https://github.com/OpenImageIO/oiio/archive/refs/tags/{archive}" 113 | ) 114 | -------------------------------------------------------------------------------- /oiio/2.5.7.0/package.py: -------------------------------------------------------------------------------- 1 | name = "oiio" 2 | version = "2.5.7.0" 3 | 4 | requires = [ 5 | "boost-1.70+", 6 | "openexr-3", 7 | "ocio-2.0+", 8 | "tiff-4.3", 9 | "openjpeg-2.4", 10 | "jpegturbo-2.0", 11 | "png-1.6", 12 | "raw-0.21", 13 | "python", 14 | "pybind11-2", 15 | "webp-1.1", 16 | "zlib-1.2", 17 | "ptex-2.4", 18 | "gif-5.2.1", 19 | "tbb", 20 | ] 21 | 22 | hashed_variants = True 23 | 24 | 25 | @early() 26 | def build_requires(): 27 | import platform 28 | 29 | if platform.system() == "Windows": 30 | return ["cmake", "vs"] 31 | else: 32 | return ["cmake"] 33 | 34 | 35 | @early() 36 | def variants(): 37 | import os, ast 38 | 39 | cook_variant = os.getenv("REZ_COOK_VARIANT") 40 | if cook_variant: 41 | # If we're building the package, we want to use the variant supplied to us 42 | return [ast.literal_eval(cook_variant)] 43 | else: 44 | # Otherwise tell rez-cook what variants we are capable of building 45 | req = ["cfg", "boost", "tbb", "openexr", "ocio", "python", "ptex"] 46 | return [x + req for x in [ 47 | ["platform-linux", "arch-x86_64", "cxx11abi"], 48 | ["platform-windows", "arch-AMD64", "vs"], 49 | ] 50 | ] 51 | 52 | 53 | def env(var: str): 54 | import platform 55 | 56 | if platform.system() == "Windows": 57 | return f"$env:{var}" 58 | else: 59 | return f"${var}" 60 | 61 | 62 | def commands(): 63 | def envvar(var: str): 64 | import platform 65 | 66 | if platform.system() == "Windows": 67 | return f"$env:{var}" 68 | else: 69 | return f"${var}" 70 | 71 | env.OpenImageIO_ROOT = "{root}" 72 | env.OPENIMAGEIO_HOME = "{root}" 73 | env.OPENIMAGEIO_DIR = "{root}" 74 | env.OPENIMAGEIO_LOCATION = "{root}" 75 | env.CMAKE_PREFIX_PATH.append("{root}") 76 | env.PATH.prepend("{root}/bin") 77 | 78 | env.PYTHONPATH.prepend(f"{{root}}/lib/python{envvar('PYTHON_MAJMIN_VERSION')}/site-packages") 79 | 80 | import platform 81 | 82 | if platform.system() == "Linux": 83 | env.LD_LIBRARY_PATH.prepend("{root}/bin") 84 | 85 | 86 | 87 | config_args = [ 88 | "cmake", 89 | "{root}", 90 | "-DCMAKE_INSTALL_PREFIX={install_path}", 91 | f'-DCMAKE_MODULE_PATH="{env("CMAKE_MODULE_PATH")}"', 92 | f'-DCMAKE_BUILD_TYPE="{env("REZ_BUILD_CONFIG")}"', 93 | "-DBUILD_DOCS=OFF", 94 | "-DOIIO_BUILD_TESTS=OFF", 95 | "-DBUILD_TESTING=OFF", 96 | "-DCMAKE_CXX_STANDARD=17", 97 | f'-DPython_ROOT="{env("Python_ROOT")}"', 98 | f'-DPython_EXECUTABLE="{env("Python_EXECUTABLE")}"', 99 | " -G Ninja", 100 | ] 101 | 102 | build_command = ( 103 | " ".join(config_args) 104 | + f" && cmake --build . --target install --config {env('REZ_BUILD_CONFIG')}" 105 | ) 106 | 107 | 108 | def pre_cook(): 109 | archive = f"v{version}.tar.gz" 110 | download_and_unpack( 111 | f"https://github.com/OpenImageIO/oiio/archive/refs/tags/{archive}" 112 | ) 113 | -------------------------------------------------------------------------------- /oiio/3.0.5.0/package.py: -------------------------------------------------------------------------------- 1 | name = "oiio" 2 | version = "3.0.5.0" 3 | 4 | requires = [ 5 | "boost-1.70+", 6 | "openexr-3", 7 | "ocio-2.0+", 8 | "tiff-4.3", 9 | "openjpeg-2.4", 10 | "jpegturbo-2.0", 11 | "png-1.6", 12 | "raw-0.21", 13 | "python", 14 | "pybind11-2", 15 | "webp-1.1", 16 | "zlib-1.2", 17 | "ptex-2.4", 18 | "gif-5.2.1", 19 | "tbb", 20 | ] 21 | 22 | hashed_variants = True 23 | 24 | 25 | @early() 26 | def build_requires(): 27 | import platform 28 | 29 | if platform.system() == "Windows": 30 | return ["cmake", "vs"] 31 | else: 32 | return ["cmake"] 33 | 34 | 35 | @early() 36 | def variants(): 37 | import os, ast 38 | 39 | cook_variant = os.getenv("REZ_COOK_VARIANT") 40 | if cook_variant: 41 | # If we're building the package, we want to use the variant supplied to us 42 | return [ast.literal_eval(cook_variant)] 43 | else: 44 | # Otherwise tell rez-cook what variants we are capable of building 45 | req = ["cfg", "boost", "tbb", "openexr", "ocio", "python", "ptex"] 46 | return [x + req for x in [ 47 | ["platform-linux", "arch-x86_64", "cxx11abi"], 48 | ["platform-windows", "arch-AMD64", "vs"], 49 | ] 50 | ] 51 | 52 | 53 | def env(var: str): 54 | import platform 55 | 56 | if platform.system() == "Windows": 57 | return f"$env:{var}" 58 | else: 59 | return f"${var}" 60 | 61 | 62 | def commands(): 63 | def envvar(var: str): 64 | import platform 65 | 66 | if platform.system() == "Windows": 67 | return f"$env:{var}" 68 | else: 69 | return f"${var}" 70 | 71 | env.OpenImageIO_ROOT = "{root}" 72 | env.OPENIMAGEIO_HOME = "{root}" 73 | env.OPENIMAGEIO_DIR = "{root}" 74 | env.OPENIMAGEIO_LOCATION = "{root}" 75 | env.CMAKE_PREFIX_PATH.append("{root}") 76 | env.PATH.prepend("{root}/bin") 77 | 78 | env.PYTHONPATH.prepend(f"{{root}}/lib/python{envvar('PYTHON_MAJMIN_VERSION')}/site-packages") 79 | 80 | import platform 81 | 82 | if platform.system() == "Linux": 83 | env.LD_LIBRARY_PATH.prepend("{root}/bin") 84 | 85 | 86 | 87 | config_args = [ 88 | "cmake", 89 | "{root}", 90 | "-DCMAKE_INSTALL_PREFIX={install_path}", 91 | f'-DCMAKE_MODULE_PATH="{env("CMAKE_MODULE_PATH")}"', 92 | f'-DCMAKE_BUILD_TYPE="{env("REZ_BUILD_CONFIG")}"', 93 | "-DBUILD_DOCS=OFF", 94 | "-DOIIO_BUILD_TESTS=OFF", 95 | "-DBUILD_TESTING=OFF", 96 | "-DCMAKE_CXX_STANDARD=17", 97 | f'-DPython_ROOT="{env("Python_ROOT")}"', 98 | f'-DPython_EXECUTABLE="{env("Python_EXECUTABLE")}"', 99 | " -G Ninja", 100 | ] 101 | 102 | build_command = ( 103 | " ".join(config_args) 104 | + f" && cmake --build . --target install --config {env('REZ_BUILD_CONFIG')}" 105 | ) 106 | 107 | 108 | def pre_cook(): 109 | archive = f"v{version}.tar.gz" 110 | download_and_unpack( 111 | f"https://github.com/OpenImageIO/oiio/archive/refs/tags/{archive}" 112 | ) 113 | -------------------------------------------------------------------------------- /oiio/2.1.18.0/package.py: -------------------------------------------------------------------------------- 1 | name = "oiio" 2 | version = "2.1.18.0" 3 | 4 | requires = [ 5 | "boost-1.70+", 6 | "openexr-2+<3", 7 | "ocio-2.0+", 8 | "tiff-4.3", 9 | "openjpeg-2.4", 10 | "jpegturbo-2.0", 11 | "png-1.6", 12 | "raw-0.21", 13 | "python", 14 | "pybind11-2.8", 15 | "webp-1.1", 16 | "zlib-1.2", 17 | "ptex-2.4", 18 | "gif-5.2.1", 19 | "tbb", 20 | ] 21 | 22 | hashed_variants = True 23 | 24 | 25 | @early() 26 | def build_requires(): 27 | import platform 28 | 29 | if platform.system() == "Windows": 30 | return ["cmake", "vs"] 31 | else: 32 | return ["cmake"] 33 | 34 | 35 | @early() 36 | def variants(): 37 | import os, ast 38 | 39 | cook_variant = os.getenv("REZ_COOK_VARIANT") 40 | if cook_variant: 41 | # If we're building the package, we want to use the variant supplied to us 42 | return [ast.literal_eval(cook_variant)] 43 | else: 44 | # Otherwise tell rez-cook what variants we are capable of building 45 | req = ["cfg", "boost", "tbb", "openexr", "ocio", "python", "ptex"] 46 | return [x + req for x in [ 47 | ["platform-linux", "arch-x86_64", "cxx11abi"], 48 | ["platform-windows", "arch-AMD64", "vs"], 49 | ] 50 | ] 51 | 52 | 53 | def env(var: str): 54 | import platform 55 | 56 | if platform.system() == "Windows": 57 | return f"$env:{var}" 58 | else: 59 | return f"${var}" 60 | 61 | 62 | def commands(): 63 | import os 64 | 65 | def envvar(var: str): 66 | import platform 67 | 68 | if platform.system() == "Windows": 69 | return f"$env:{var}" 70 | else: 71 | return f"${var}" 72 | 73 | env.OpenImageIO_ROOT = "{root}" 74 | env.OPENIMAGEIO_HOME = "{root}" 75 | env.OPENIMAGEIO_DIR = "{root}" 76 | env.OPENIMAGEIO_LOCATION = "{root}" 77 | env.CMAKE_PREFIX_PATH.append("{root}") 78 | env.PATH.prepend("{root}/bin") 79 | 80 | env.PYTHONPATH.prepend(f"{{root}}/lib/python{envvar('PYTHON_MAJMIN_VERSION')}/site-packages") 81 | 82 | import platform 83 | 84 | if platform.system() == "Linux": 85 | env.LD_LIBRARY_PATH.prepend("{root}/bin") 86 | 87 | 88 | 89 | config_args = [ 90 | "cmake", 91 | "{root}", 92 | "-DCMAKE_INSTALL_PREFIX={install_path}", 93 | f'-DCMAKE_MODULE_PATH="{env("CMAKE_MODULE_PATH")}"', 94 | f'-DCMAKE_BUILD_TYPE="{env("REZ_BUILD_CONFIG")}"', 95 | "-DBUILD_DOCS=OFF", 96 | "-DOIIO_BUILD_TESTS=OFF", 97 | "-DBUILD_TESTING=OFF", 98 | f'-DPython_ROOT="{env("Python_ROOT")}"', 99 | f'-DPython_EXECUTABLE="{env("Python_EXECUTABLE")}"', 100 | " -G Ninja", 101 | ] 102 | 103 | build_command = ( 104 | " ".join(config_args) 105 | + f" && cmake --build . --target install --config {env('REZ_BUILD_CONFIG')}" 106 | ) 107 | 108 | 109 | def pre_cook(): 110 | archive = f"Release-{version}.tar.gz" 111 | download_and_unpack( 112 | f"https://github.com/OpenImageIO/oiio/archive/refs/tags/{archive}" 113 | ) 114 | -------------------------------------------------------------------------------- /oiio/2.3.16.0/package.py: -------------------------------------------------------------------------------- 1 | name = "oiio" 2 | version = "2.3.16.0" 3 | 4 | requires = [ 5 | "boost-1.70+", 6 | "openexr-3.0+<3.2", 7 | "ocio-2.0+", 8 | "tiff-4.3", 9 | "openjpeg-2.4", 10 | "jpegturbo-2.0", 11 | "png-1.6", 12 | "raw-0.21", 13 | "python", 14 | "pybind11-2", 15 | "webp-1.1", 16 | "zlib-1.2", 17 | "ptex-2.4", 18 | "gif-5.2.1", 19 | "tbb", 20 | ] 21 | 22 | hashed_variants = True 23 | 24 | 25 | @early() 26 | def build_requires(): 27 | import platform 28 | 29 | if platform.system() == "Windows": 30 | return ["cmake", "vs"] 31 | else: 32 | return ["cmake"] 33 | 34 | 35 | @early() 36 | def variants(): 37 | import os, ast 38 | 39 | cook_variant = os.getenv("REZ_COOK_VARIANT") 40 | if cook_variant: 41 | # If we're building the package, we want to use the variant supplied to us 42 | return [ast.literal_eval(cook_variant)] 43 | else: 44 | # Otherwise tell rez-cook what variants we are capable of building 45 | req = ["cfg", "boost", "tbb", "openexr", "ocio", "python", "ptex"] 46 | return [x + req for x in [ 47 | ["platform-linux", "arch-x86_64", "cxx11abi"], 48 | ["platform-windows", "arch-AMD64", "vs"], 49 | ] 50 | ] 51 | 52 | 53 | def env(var: str): 54 | import platform 55 | 56 | if platform.system() == "Windows": 57 | return f"$env:{var}" 58 | else: 59 | return f"${var}" 60 | 61 | 62 | def commands(): 63 | import os 64 | 65 | def envvar(var: str): 66 | import platform 67 | 68 | if platform.system() == "Windows": 69 | return f"$env:{var}" 70 | else: 71 | return f"${var}" 72 | 73 | env.OpenImageIO_ROOT = "{root}" 74 | env.OPENIMAGEIO_HOME = "{root}" 75 | env.OPENIMAGEIO_DIR = "{root}" 76 | env.OPENIMAGEIO_LOCATION = "{root}" 77 | env.CMAKE_PREFIX_PATH.append("{root}") 78 | env.PATH.prepend("{root}/bin") 79 | 80 | env.PYTHONPATH.prepend(f"{{root}}/lib/python{envvar('PYTHON_MAJMIN_VERSION')}/site-packages") 81 | 82 | import platform 83 | 84 | if platform.system() == "Linux": 85 | env.LD_LIBRARY_PATH.prepend("{root}/bin") 86 | 87 | 88 | 89 | config_args = [ 90 | "cmake", 91 | "{root}", 92 | "-DCMAKE_INSTALL_PREFIX={install_path}", 93 | f'-DCMAKE_MODULE_PATH="{env("CMAKE_MODULE_PATH")}"', 94 | f'-DCMAKE_BUILD_TYPE="{env("REZ_BUILD_CONFIG")}"', 95 | "-DCMAKE_CXX_STANDARD=17", 96 | "-DBUILD_DOCS=OFF", 97 | "-DOIIO_BUILD_TESTS=OFF", 98 | "-DBUILD_TESTING=OFF", 99 | f'-DPython_ROOT="{env("Python_ROOT")}"', 100 | f'-DPython_EXECUTABLE="{env("Python_EXECUTABLE")}"', 101 | " -G Ninja", 102 | ] 103 | 104 | build_command = ( 105 | " ".join(config_args) 106 | + f" && cmake --build . --target install --config {env('REZ_BUILD_CONFIG')}" 107 | ) 108 | 109 | 110 | def pre_cook(): 111 | archive = f"v{version}.tar.gz" 112 | download_and_unpack( 113 | f"https://github.com/OpenImageIO/oiio/archive/refs/tags/{archive}" 114 | ) 115 | -------------------------------------------------------------------------------- /webp/1.1.0/package.py: -------------------------------------------------------------------------------- 1 | name = "webp" 2 | version = "1.1.0" 3 | 4 | requires = ["zlib-1.2", "png-1.6", "jpegturbo-2.0", "tiff-4.3", "gif-5.2"] 5 | 6 | @early() 7 | def build_requires(): 8 | import platform 9 | 10 | if platform.system() == "Windows": 11 | return ["cmake", "vs"] 12 | else: 13 | return ["cmake"] 14 | 15 | 16 | @early() 17 | def variants(): 18 | import os, ast 19 | 20 | cook_variant = os.getenv("REZ_COOK_VARIANT") 21 | if cook_variant: 22 | # If we're building the package, we want to use the variant supplied to us 23 | return [ast.literal_eval(cook_variant)] 24 | else: 25 | # Otherwise tell rez-cook what variants we are capable of building 26 | return [ 27 | ["platform-linux", "arch-x86_64", "cxx11abi", "cfg"], 28 | ["platform-windows", "arch-AMD64", "vs", "cfg"], 29 | ] 30 | 31 | 32 | def commands(): 33 | env.WebP_ROOT = "{root}" 34 | env.WEBP_ROOT = "{root}" 35 | env.WEBP_INCLUDE_PATH = "{root}/include" 36 | env.WEBP_LIBRARY_PATH = "{root}/lib" 37 | env.PATH.prepend("{root}/bin") 38 | 39 | import platform 40 | if platform.system() == "Linux": 41 | env.PKG_CONFIG_PATH.prepend("{root}/lib/pkgconfig") 42 | env.LD_LIBRARY_PATH.prepend("{root}/lib") 43 | 44 | 45 | def env(var: str): 46 | import platform 47 | 48 | if platform.system() == "Windows": 49 | return f"$env:{var}" 50 | else: 51 | return f"${var}" 52 | 53 | 54 | config_args = [ 55 | "cmake", 56 | "{root}", 57 | "-DCMAKE_INSTALL_PREFIX={install_path}", 58 | f'-DCMAKE_MODULE_PATH="{env("CMAKE_MODULE_PATH")}"', 59 | f'-DCMAKE_BUILD_TYPE="{env("REZ_BUILD_CONFIG")}"', 60 | "-DBUILD_SHARED_LIBS=ON", 61 | "-DBUILD_TESTS=OFF", 62 | "-DWEBP_BUILD_ANIM_UTILS=OFF", 63 | "-DWEBP_BUILD_CWEBP=OFF", 64 | "-DWEBP_BUILD_VWEBP=OFF", 65 | "-DWEBP_BUILD_GIF2WEBPx=OFF", 66 | "-DDWEBP_BUILD_IMG2WEBP=OFF", 67 | "-DWEBP_BUILD_EXTRAS=OFF", 68 | f'-DJPEG_INCLUDE_DIR={env("JPEGTurbo_ROOT")}/include', 69 | f'-DJPEG_LIBRARY={env("JPEGTurbo_ROOT")}/lib/jpeg.lib', 70 | f'-DTIFF_INCLUDE_DIR={env("TIFF_ROOT")}/include', 71 | f'-DTIFF_LIBRARY={env("TIFF_ROOT")}/lib/tiff.lib', 72 | " -G Ninja", 73 | ] 74 | 75 | build_command = ( 76 | " ".join(config_args) 77 | + f" && cmake --build . --target install --config {env('REZ_BUILD_CONFIG')}" 78 | ) 79 | 80 | @early() 81 | def build_command(): 82 | import platform 83 | 84 | config_args = [ 85 | "cmake", 86 | "{root}", 87 | "-DCMAKE_INSTALL_PREFIX={install_path}", 88 | f'-DCMAKE_MODULE_PATH="{env("CMAKE_MODULE_PATH")}"', 89 | f'-DCMAKE_BUILD_TYPE="{env("REZ_BUILD_CONFIG")}"', 90 | "-DBUILD_SHARED_LIBS=OFF", 91 | "-DBUILD_TESTS=OFF", 92 | "-DWEBP_BUILD_ANIM_UTILS=OFF", 93 | "-DWEBP_BUILD_CWEBP=OFF", 94 | "-DWEBP_BUILD_VWEBP=OFF", 95 | "-DWEBP_BUILD_GIF2WEBPx=OFF", 96 | "-DDWEBP_BUILD_IMG2WEBP=OFF", 97 | "-DWEBP_BUILD_EXTRAS=OFF", 98 | "-G Ninja", 99 | ] 100 | 101 | return ( 102 | " ".join(config_args) 103 | + f" && cmake --build . --target install --config {env('REZ_BUILD_CONFIG')}" 104 | ) 105 | 106 | 107 | def pre_cook(): 108 | download_and_unpack( 109 | f"https://github.com/webmproject/libwebp/archive/refs/tags/v{version}.tar.gz" 110 | ) 111 | -------------------------------------------------------------------------------- /dusd/22.08/package.py: -------------------------------------------------------------------------------- 1 | name = "usd" 2 | version = "22.08" 3 | 4 | requires = [ 5 | "openexr-3", 6 | "boost-1.70+", 7 | "ocio-2", 8 | "oiio-2.3", 9 | "osd-3.4", 10 | "tbb-2020", 11 | "glew-2.1", 12 | "jinja2-3.1", 13 | "pyside2-5.15", 14 | "pyopengl-3.1", 15 | "numpy", 16 | "python", 17 | ] 18 | 19 | 20 | hashed_variants = True 21 | 22 | @early() 23 | def build_requires(): 24 | import platform 25 | 26 | if platform.system() == "Windows": 27 | return ["cmake", "vs"] 28 | else: 29 | return ["cmake"] 30 | 31 | 32 | @early() 33 | def variants(): 34 | import os, ast 35 | 36 | cook_variant = os.getenv("REZ_COOK_VARIANT") 37 | if cook_variant: 38 | # If we're building the package, we want to use the variant supplied to us 39 | return [ast.literal_eval(cook_variant)] 40 | else: 41 | # Otherwise tell rez-cook what variants we are capable of building 42 | req = ["cfg", "boost", "tbb", "openexr", "ocio", "oiio", "python", "ptex", "osd"] 43 | return [x + req for x in [ 44 | ["platform-linux", "arch-x86_64", "cxx11abi"], 45 | ["platform-windows", "arch-AMD64", "vs"], 46 | ] 47 | ] 48 | 49 | 50 | def commands(): 51 | env.USD_ROOT = "{root}" 52 | env.CMAKE_PREFIX_PATH.prepend("{root}") 53 | env.PATH.prepend("{root}/bin") 54 | env.PATH.prepend("{root}/lib") 55 | env.PYTHONPATH.prepend("{root}/lib/python") 56 | 57 | import platform 58 | 59 | if platform.system() == "Linux": 60 | env.LD_LIBRARY_PATH.prepend("{root}/bin") 61 | env.PYOPENGL_PLATFORM = "glx" 62 | 63 | 64 | def env(var: str): 65 | import platform 66 | 67 | if platform.system() == "Windows": 68 | return f"$env:{var}" 69 | else: 70 | return f"${var}" 71 | 72 | 73 | config_args = [ 74 | "cmake", 75 | "{root}", 76 | "-DCMAKE_INSTALL_PREFIX={install_path}", 77 | f'-DCMAKE_MODULE_PATH="{env("CMAKE_MODULE_PATH")}"', 78 | f'-DCMAKE_BUILD_TYPE="{env("REZ_BUILD_CONFIG")}"', 79 | f'-DTBB_ROOT_DIR="{env("TBB_ROOT")}"', 80 | f'-DOPENEXR_LOCATION="{env("OPENEXR_ROOT")}"', 81 | f'-DOPENSUBDIV_ROOT_DIR="{env("OPENSUBDIV_ROOT")}"', 82 | f'-DPTEX_LOCATION="{env("Ptex_ROOT")}"', 83 | f'-DOIIO_LOCATION="{env("OpenImageIO_ROOT")}"', 84 | f'-DBOOST_ROOT="{env("Boost_ROOT")}"', 85 | f'-DPython_ROOT="{env("Python_ROOT")}"', 86 | "-DPXR_BUILD_DOCUMENTATION=FALSE", 87 | "-DPXR_BUILD_TESTS=FALSE", 88 | "-DPXR_BUILD_EXAMPLES=FALSE", 89 | "-DPXR_USE_PYTHON_3=ON", 90 | # Fix for boost inserting the wrong library names into the libs with 91 | # --layout=system... 92 | f'-DCMAKE_CXX_FLAGS="-DBOOST_ALL_NO_LIB -D__TBB_show_deprecation_message_task_H -DBOOST_BIND_GLOBAL_PLACEHOLDERS -Wno-class-memaccess {env("CXXFLAGS")}"', 93 | " -G Ninja", 94 | ] 95 | 96 | import platform 97 | 98 | if platform.system() == "Linux": 99 | config_args.append(f'-DCMAKE_CXX_FLAGS="-DBOOST_ALL_NO_LIB -D__TBB_show_deprecation_message_task_H -DBOOST_BIND_GLOBAL_PLACEHOLDERS -Wno-class-memaccess {env("CXXFLAGS")}"') 100 | else: 101 | config_args.append(f'-DCMAKE_CXX_FLAGS="-DBOOST_ALL_NO_LIB -D__TBB_show_deprecation_message_task_H -DBOOST_BIND_GLOBAL_PLACEHOLDERS {env("CXXFLAGS")}"') 102 | 103 | 104 | build_command = ( 105 | " ".join(config_args) 106 | + f" && cmake --build . --target install --config {env('REZ_BUILD_CONFIG')}" 107 | ) 108 | 109 | 110 | def pre_cook(): 111 | download_and_unpack( 112 | f"https://github.com/PixarAnimationStudios/USD/archive/refs/tags/v{version}.tar.gz" 113 | ) 114 | -------------------------------------------------------------------------------- /usd/22.08/package.py: -------------------------------------------------------------------------------- 1 | name = "usd" 2 | version = "22.08" 3 | 4 | requires = [ 5 | "openexr-3", 6 | "boost-1.70+", 7 | "ocio-2", 8 | "oiio-2.3", 9 | "osd-3.4", 10 | "tbb-2020", 11 | "glew-2.1", 12 | "jinja2-3.1", 13 | "pyside2-5.15", 14 | "pyopengl-3.1", 15 | "numpy", 16 | "python", 17 | ] 18 | 19 | 20 | hashed_variants = True 21 | 22 | @early() 23 | def build_requires(): 24 | import platform 25 | 26 | if platform.system() == "Windows": 27 | return ["cmake", "vs"] 28 | else: 29 | return ["cmake"] 30 | 31 | 32 | @early() 33 | def variants(): 34 | import os, ast 35 | 36 | cook_variant = os.getenv("REZ_COOK_VARIANT") 37 | if cook_variant: 38 | # If we're building the package, we want to use the variant supplied to us 39 | return [ast.literal_eval(cook_variant)] 40 | else: 41 | # Otherwise tell rez-cook what variants we are capable of building 42 | req = ["cfg", "boost", "tbb", "openexr", "ocio", "oiio", "python", "ptex", "osd"] 43 | return [x + req for x in [ 44 | ["platform-linux", "arch-x86_64", "cxx11abi"], 45 | ["platform-windows", "arch-AMD64", "vs"], 46 | ] 47 | ] 48 | 49 | 50 | def commands(): 51 | env.USD_ROOT = "{root}" 52 | env.CMAKE_PREFIX_PATH.prepend("{root}") 53 | env.PATH.prepend("{root}/bin") 54 | env.PATH.prepend("{root}/lib") 55 | env.PYTHONPATH.prepend("{root}/lib/python") 56 | 57 | import platform 58 | 59 | if platform.system() == "Linux": 60 | env.LD_LIBRARY_PATH.prepend("{root}/bin") 61 | env.PYOPENGL_PLATFORM = "glx" 62 | 63 | 64 | def env(var: str): 65 | import platform 66 | 67 | if platform.system() == "Windows": 68 | return f"$env:{var}" 69 | else: 70 | return f"${var}" 71 | 72 | 73 | config_args = [ 74 | "cmake", 75 | "{root}", 76 | "-DCMAKE_INSTALL_PREFIX={install_path}", 77 | f'-DCMAKE_MODULE_PATH="{env("CMAKE_MODULE_PATH")}"', 78 | f'-DCMAKE_BUILD_TYPE="{env("REZ_BUILD_CONFIG")}"', 79 | f'-DTBB_ROOT_DIR="{env("TBB_ROOT")}"', 80 | f'-DOPENEXR_LOCATION="{env("OPENEXR_ROOT")}"', 81 | f'-DOPENSUBDIV_ROOT_DIR="{env("OPENSUBDIV_ROOT")}"', 82 | f'-DPTEX_LOCATION="{env("Ptex_ROOT")}"', 83 | f'-DOIIO_LOCATION="{env("OpenImageIO_ROOT")}"', 84 | f'-DBOOST_ROOT="{env("Boost_ROOT")}"', 85 | f'-DPython_ROOT="{env("Python_ROOT")}"', 86 | "-DPXR_BUILD_DOCUMENTATION=FALSE", 87 | "-DPXR_BUILD_TESTS=FALSE", 88 | "-DPXR_BUILD_EXAMPLES=FALSE", 89 | "-DPXR_USE_PYTHON_3=ON", 90 | "-DCMAKE_CXX_STANDARD=17", 91 | # Fix for boost inserting the wrong library names into the libs with 92 | # --layout=system... 93 | f'-DCMAKE_CXX_FLAGS="-DBOOST_ALL_NO_LIB -D__TBB_show_deprecation_message_task_H -DBOOST_BIND_GLOBAL_PLACEHOLDERS -Wno-class-memaccess {env("CXXFLAGS")}"', 94 | " -G Ninja", 95 | ] 96 | 97 | import platform 98 | 99 | if platform.system() == "Linux": 100 | config_args.append(f'-DCMAKE_CXX_FLAGS="-DBOOST_ALL_NO_LIB -D__TBB_show_deprecation_message_task_H -DBOOST_BIND_GLOBAL_PLACEHOLDERS -Wno-class-memaccess {env("CXXFLAGS")}"') 101 | else: 102 | config_args.append(f'-DCMAKE_CXX_FLAGS="-DBOOST_ALL_NO_LIB -D__TBB_show_deprecation_message_task_H -DBOOST_BIND_GLOBAL_PLACEHOLDERS {env("CXXFLAGS")}"') 103 | 104 | 105 | build_command = ( 106 | " ".join(config_args) 107 | + f" && cmake --build . --target install --config {env('REZ_BUILD_CONFIG')}" 108 | ) 109 | 110 | 111 | def pre_cook(): 112 | download_and_unpack( 113 | f"https://github.com/PixarAnimationStudios/USD/archive/refs/tags/v{version}.tar.gz" 114 | ) 115 | -------------------------------------------------------------------------------- /usd/22.11/package.py: -------------------------------------------------------------------------------- 1 | name = "usd" 2 | version = "22.11" 3 | 4 | requires = [ 5 | "openexr-3", 6 | "boost-1.70+", 7 | "ocio-2", 8 | "oiio-2.3", 9 | "osd-3.4", 10 | "tbb-2020", 11 | "glew-2.1", 12 | "jinja2-3.1", 13 | "pyside2-5.15", 14 | "pyopengl-3.1", 15 | "numpy", 16 | "python", 17 | ] 18 | 19 | 20 | hashed_variants = True 21 | 22 | @early() 23 | def build_requires(): 24 | import platform 25 | 26 | if platform.system() == "Windows": 27 | return ["cmake", "vs"] 28 | else: 29 | return ["cmake"] 30 | 31 | 32 | @early() 33 | def variants(): 34 | import os, ast 35 | 36 | cook_variant = os.getenv("REZ_COOK_VARIANT") 37 | if cook_variant: 38 | # If we're building the package, we want to use the variant supplied to us 39 | return [ast.literal_eval(cook_variant)] 40 | else: 41 | # Otherwise tell rez-cook what variants we are capable of building 42 | req = ["cfg", "boost", "tbb", "openexr", "ocio", "oiio", "python", "ptex", "osd"] 43 | return [x + req for x in [ 44 | ["platform-linux", "arch-x86_64", "cxx11abi"], 45 | ["platform-windows", "arch-AMD64", "vs"], 46 | ] 47 | ] 48 | 49 | 50 | def commands(): 51 | env.USD_ROOT = "{root}" 52 | env.CMAKE_PREFIX_PATH.prepend("{root}") 53 | env.PATH.prepend("{root}/bin") 54 | env.PATH.prepend("{root}/lib") 55 | env.PYTHONPATH.prepend("{root}/lib/python") 56 | 57 | import platform 58 | 59 | if platform.system() == "Linux": 60 | env.LD_LIBRARY_PATH.prepend("{root}/bin") 61 | env.PYOPENGL_PLATFORM = "glx" 62 | 63 | 64 | def env(var: str): 65 | import platform 66 | 67 | if platform.system() == "Windows": 68 | return f"$env:{var}" 69 | else: 70 | return f"${var}" 71 | 72 | 73 | config_args = [ 74 | "cmake", 75 | "{root}", 76 | "-DCMAKE_INSTALL_PREFIX={install_path}", 77 | f'-DCMAKE_MODULE_PATH="{env("CMAKE_MODULE_PATH")}"', 78 | f'-DCMAKE_BUILD_TYPE="{env("REZ_BUILD_CONFIG")}"', 79 | f'-DTBB_ROOT_DIR="{env("TBB_ROOT")}"', 80 | f'-DOPENEXR_LOCATION="{env("OPENEXR_ROOT")}"', 81 | f'-DOPENSUBDIV_ROOT_DIR="{env("OPENSUBDIV_ROOT")}"', 82 | f'-DPTEX_LOCATION="{env("Ptex_ROOT")}"', 83 | f'-DOIIO_LOCATION="{env("OpenImageIO_ROOT")}"', 84 | f'-DBOOST_ROOT="{env("Boost_ROOT")}"', 85 | f'-DPython_ROOT="{env("Python_ROOT")}"', 86 | "-DPXR_BUILD_DOCUMENTATION=FALSE", 87 | "-DPXR_BUILD_TESTS=FALSE", 88 | "-DPXR_BUILD_EXAMPLES=FALSE", 89 | "-DPXR_USE_PYTHON_3=ON", 90 | "-DCMAKE_CXX_STANDARD=17", 91 | # Fix for boost inserting the wrong library names into the libs with 92 | # --layout=system... 93 | f'-DCMAKE_CXX_FLAGS="-DBOOST_ALL_NO_LIB -D__TBB_show_deprecation_message_task_H -DBOOST_BIND_GLOBAL_PLACEHOLDERS -Wno-class-memaccess {env("CXXFLAGS")}"', 94 | " -G Ninja", 95 | ] 96 | 97 | import platform 98 | 99 | if platform.system() == "Linux": 100 | config_args.append(f'-DCMAKE_CXX_FLAGS="-DBOOST_ALL_NO_LIB -D__TBB_show_deprecation_message_task_H -DBOOST_BIND_GLOBAL_PLACEHOLDERS -Wno-class-memaccess {env("CXXFLAGS")}"') 101 | else: 102 | config_args.append(f'-DCMAKE_CXX_FLAGS="-DBOOST_ALL_NO_LIB -D__TBB_show_deprecation_message_task_H -DBOOST_BIND_GLOBAL_PLACEHOLDERS {env("CXXFLAGS")}"') 103 | 104 | 105 | build_command = ( 106 | " ".join(config_args) 107 | + f" && cmake --build . --target install --config {env('REZ_BUILD_CONFIG')}" 108 | ) 109 | 110 | 111 | def pre_cook(): 112 | download_and_unpack( 113 | f"https://github.com/PixarAnimationStudios/USD/archive/refs/tags/v{version}.tar.gz" 114 | ) 115 | -------------------------------------------------------------------------------- /usd/0-dev/package.py: -------------------------------------------------------------------------------- 1 | name = "usd" 2 | version = "0-dev" 3 | 4 | requires = [ 5 | "openexr-3", 6 | "boost-1.70+", 7 | "ocio-2", 8 | "oiio-2", 9 | "osd-3.4+", 10 | "tbb-2020", 11 | "glew-2.1", 12 | "jinja2-3.1", 13 | "pyside6", 14 | "pyopengl-3.1", 15 | "numpy", 16 | "python", 17 | ] 18 | 19 | 20 | hashed_variants = True 21 | 22 | @early() 23 | def build_requires(): 24 | import platform 25 | 26 | if platform.system() == "Windows": 27 | return ["cmake", "vs"] 28 | else: 29 | return ["cmake"] 30 | 31 | 32 | @early() 33 | def variants(): 34 | import os, ast 35 | 36 | cook_variant = os.getenv("REZ_COOK_VARIANT") 37 | if cook_variant: 38 | # If we're building the package, we want to use the variant supplied to us 39 | return [ast.literal_eval(cook_variant)] 40 | else: 41 | # Otherwise tell rez-cook what variants we are capable of building 42 | req = ["cfg", "boost", "tbb", "openexr", "ocio", "oiio", "python", "ptex", "osd"] 43 | return [x + req for x in [ 44 | ["platform-linux", "arch-x86_64", "cxx11abi"], 45 | ["platform-windows", "arch-AMD64", "vs"], 46 | ] 47 | ] 48 | 49 | 50 | def commands(): 51 | env.USD_ROOT = "{root}" 52 | env.CMAKE_PREFIX_PATH.prepend("{root}") 53 | env.PATH.prepend("{root}/bin") 54 | env.PATH.prepend("{root}/lib") 55 | env.PYTHONPATH.prepend("{root}/lib/python") 56 | 57 | import platform 58 | 59 | if platform.system() == "Linux": 60 | env.LD_LIBRARY_PATH.prepend("{root}/lib") 61 | env.PYOPENGL_PLATFORM = "glx" 62 | 63 | 64 | def env(var: str): 65 | import platform 66 | 67 | if platform.system() == "Windows": 68 | return f"$env:{var}" 69 | else: 70 | return f"${var}" 71 | 72 | 73 | config_args = [ 74 | "cmake", 75 | "{root}", 76 | "-DCMAKE_INSTALL_PREFIX={install_path}", 77 | f'-DCMAKE_MODULE_PATH="{env("CMAKE_MODULE_PATH")}"', 78 | f'-DCMAKE_BUILD_TYPE="{env("REZ_BUILD_CONFIG")}"', 79 | f'-DTBB_ROOT_DIR="{env("TBB_ROOT")}"', 80 | f'-DOPENEXR_LOCATION="{env("OPENEXR_ROOT")}"', 81 | f'-DOPENSUBDIV_ROOT_DIR="{env("OPENSUBDIV_ROOT")}"', 82 | f'-DPTEX_LOCATION="{env("Ptex_ROOT")}"', 83 | f'-DOIIO_LOCATION="{env("OpenImageIO_ROOT")}"', 84 | f'-DBOOST_ROOT="{env("Boost_ROOT")}"', 85 | f'-DPython_ROOT="{env("Python_ROOT")}"', 86 | f'-DPython3_ROOT="{env("Python_ROOT")}"', 87 | f'-DPython_EXECUTABLE="{env("Python_EXECUTABLE")}"', 88 | f'-DPython3_EXECUTABLE="{env("Python_EXECUTABLE")}"', 89 | "-DPXR_BUILD_DOCUMENTATION=FALSE", 90 | "-DPXR_BUILD_TESTS=FALSE", 91 | "-DPXR_BUILD_EXAMPLES=FALSE", 92 | "-DPXR_USE_PYTHON_3=ON", 93 | "-DCMAKE_CXX_STANDARD=17", 94 | # Fix for boost inserting the wrong library names into the libs with 95 | # --layout=system... 96 | f'-DCMAKE_CXX_FLAGS="-DBOOST_ALL_NO_LIB -D__TBB_show_deprecation_message_task_H -DBOOST_BIND_GLOBAL_PLACEHOLDERS -Wno-class-memaccess {env("CXXFLAGS")}"', 97 | " -G Ninja", 98 | ] 99 | 100 | import platform 101 | 102 | if platform.system() == "Linux": 103 | config_args.append(f'-DCMAKE_CXX_FLAGS="-DBOOST_ALL_NO_LIB -D__TBB_show_deprecation_message_task_H -DBOOST_BIND_GLOBAL_PLACEHOLDERS -Wno-class-memaccess {env("CXXFLAGS")}"') 104 | else: 105 | config_args.append(f'-DCMAKE_CXX_FLAGS="-DBOOST_ALL_NO_LIB -D__TBB_show_deprecation_message_task_H -DBOOST_BIND_GLOBAL_PLACEHOLDERS {env("CXXFLAGS")}"') 106 | 107 | 108 | build_command = ( 109 | " ".join(config_args) 110 | + f" && cmake --build . --target install --config {env('REZ_BUILD_CONFIG')}" 111 | ) 112 | 113 | 114 | def pre_cook(): 115 | fetch_repository("https://github.com/PixarAnimationStudios/OpenUSD.git", branch="dev") 116 | -------------------------------------------------------------------------------- /usd/0-release/package.py: -------------------------------------------------------------------------------- 1 | name = "usd" 2 | version = "0-release" 3 | 4 | requires = [ 5 | "openexr-3", 6 | "boost-1.70+", 7 | "ocio-2", 8 | "oiio-2", 9 | "osd-3.4+", 10 | "tbb-2020", 11 | "glew-2.1", 12 | "jinja2-3.1", 13 | "pyside6", 14 | "pyopengl-3.1", 15 | "numpy", 16 | "python", 17 | ] 18 | 19 | 20 | hashed_variants = True 21 | 22 | @early() 23 | def build_requires(): 24 | import platform 25 | 26 | if platform.system() == "Windows": 27 | return ["cmake", "vs"] 28 | else: 29 | return ["cmake"] 30 | 31 | 32 | @early() 33 | def variants(): 34 | import os, ast 35 | 36 | cook_variant = os.getenv("REZ_COOK_VARIANT") 37 | if cook_variant: 38 | # If we're building the package, we want to use the variant supplied to us 39 | return [ast.literal_eval(cook_variant)] 40 | else: 41 | # Otherwise tell rez-cook what variants we are capable of building 42 | req = ["cfg", "boost", "tbb", "openexr", "ocio", "oiio", "python", "ptex", "osd"] 43 | return [x + req for x in [ 44 | ["platform-linux", "arch-x86_64", "cxx11abi"], 45 | ["platform-windows", "arch-AMD64", "vs"], 46 | ] 47 | ] 48 | 49 | 50 | def commands(): 51 | env.USD_ROOT = "{root}" 52 | env.CMAKE_PREFIX_PATH.prepend("{root}") 53 | env.PATH.prepend("{root}/bin") 54 | env.PATH.prepend("{root}/lib") 55 | env.PYTHONPATH.prepend("{root}/lib/python") 56 | 57 | import platform 58 | 59 | if platform.system() == "Linux": 60 | env.LD_LIBRARY_PATH.prepend("{root}/lib") 61 | env.PYOPENGL_PLATFORM = "glx" 62 | 63 | 64 | def env(var: str): 65 | import platform 66 | 67 | if platform.system() == "Windows": 68 | return f"$env:{var}" 69 | else: 70 | return f"${var}" 71 | 72 | 73 | config_args = [ 74 | "cmake", 75 | "{root}", 76 | "-DCMAKE_INSTALL_PREFIX={install_path}", 77 | f'-DCMAKE_MODULE_PATH="{env("CMAKE_MODULE_PATH")}"', 78 | f'-DCMAKE_BUILD_TYPE="{env("REZ_BUILD_CONFIG")}"', 79 | f'-DTBB_ROOT_DIR="{env("TBB_ROOT")}"', 80 | f'-DOPENEXR_LOCATION="{env("OPENEXR_ROOT")}"', 81 | f'-DOPENSUBDIV_ROOT_DIR="{env("OPENSUBDIV_ROOT")}"', 82 | f'-DPTEX_LOCATION="{env("Ptex_ROOT")}"', 83 | f'-DOIIO_LOCATION="{env("OpenImageIO_ROOT")}"', 84 | f'-DBOOST_ROOT="{env("Boost_ROOT")}"', 85 | f'-DPython_ROOT="{env("Python_ROOT")}"', 86 | f'-DPython3_ROOT="{env("Python_ROOT")}"', 87 | f'-DPython_EXECUTABLE="{env("Python_EXECUTABLE")}"', 88 | f'-DPython3_EXECUTABLE="{env("Python_EXECUTABLE")}"', 89 | "-DPXR_BUILD_DOCUMENTATION=FALSE", 90 | "-DPXR_BUILD_TESTS=FALSE", 91 | "-DPXR_BUILD_EXAMPLES=FALSE", 92 | "-DPXR_USE_PYTHON_3=ON", 93 | "-DCMAKE_CXX_STANDARD=17", 94 | # Fix for boost inserting the wrong library names into the libs with 95 | # --layout=system... 96 | f'-DCMAKE_CXX_FLAGS="-DBOOST_ALL_NO_LIB -D__TBB_show_deprecation_message_task_H -DBOOST_BIND_GLOBAL_PLACEHOLDERS -Wno-class-memaccess {env("CXXFLAGS")}"', 97 | " -G Ninja", 98 | ] 99 | 100 | import platform 101 | 102 | if platform.system() == "Linux": 103 | config_args.append(f'-DCMAKE_CXX_FLAGS="-DBOOST_ALL_NO_LIB -D__TBB_show_deprecation_message_task_H -DBOOST_BIND_GLOBAL_PLACEHOLDERS -Wno-class-memaccess {env("CXXFLAGS")}"') 104 | else: 105 | config_args.append(f'-DCMAKE_CXX_FLAGS="-DBOOST_ALL_NO_LIB -D__TBB_show_deprecation_message_task_H -DBOOST_BIND_GLOBAL_PLACEHOLDERS {env("CXXFLAGS")}"') 106 | 107 | 108 | build_command = ( 109 | " ".join(config_args) 110 | + f" && cmake --build . --target install --config {env('REZ_BUILD_CONFIG')}" 111 | ) 112 | 113 | 114 | def pre_cook(): 115 | fetch_repository("https://github.com/PixarAnimationStudios/OpenUSD.git", branch="release") 116 | --------------------------------------------------------------------------------