Nuke; Python Essentials; Installing Plug-ins in a Custom Directory Video Lecture | Create Visual Effects with Nuke - Professional Skills

so in part 1 of this tutorial we had a
look at how to customize nuke through
our home nuke directory which pretty
much gives you a sandbox to prototype
your own tools to install what you want
to play with your settings and all that
sort of stuff without affecting anybody
else on the network in this part we'll
have a look at how to set up a facility
wide repository that people can actually
share as well as experimenting with a
custom user directory and a show wide
tool repository let's have a look at our
new facility wide repository here I've
already set up the directory structure
gizmos icons Python TCL let's have a
quick look that's where all the gizmos
go that's where my icons go there's a
Python module on here and here's my old
TCL code here is my respective init py
that actually sources all those
subdirectories followed by the menu py
that creates interfaces for all those
tools so I'm importing my custom node
tools python module that lives in the
python subdirectory then I'm referencing
three different menus inside of nuke the
first one being the main menu bar the
second is the right-click menu in the
properties panels and the third one is a
custom menu that lives in the nodes
toolbar so it'll show up up here then we
proceed to actually add the image plane
gizmo to the custom menu we add
functionality from the node Tools Python
module into the Edit node subdirectory
and lastly we're adding our TCL script
into the right-click of the property
panel so this is all set up and ready to
go the only thing we have to do is
connect our nuke to this repository and
the easiest way to do this is using
environment variables obviously setting
up environment variables is different
depending on what operating system
you're on I'm just going to use a bash
shell to demonstrate how you could be
doing it so the important part is that
you create an environment variable
called nuke underscore path all caps and
give it the value of your custom
directory in my case that's library
slash new
tools Excel and once I've got that
environment variables set up I can now
start nuke nuke will find this directory
and retain that py find all the
subdirectories and add them to a plugin
path and also create the items that we
defined in the menu py so you can see we
now have our new menu here which pulls
in the gizmo from the gizmo subdirectory
that's just wire that up real quick and
we'll also find the new items in the
Edit node subdirectory down here relax
and contract connections map to old up
arrow and old down arrow let's just try
that to see if the Python module is read
properly yes looks like it's working and
lastly the TCL command that now lives in
the right-click menu of our properties
panel so it's up here and that properly
runs the TCL script that lives in the
subdirectory and spits out some gizmo
information now let's say we want to
extend our setup with a custom users
directory that will give people the
possibility to actually put all their
stuff onto the server into the same
location as all the facility-wide stuff
without having to mess with their home
nuke directory so we'll create a user's
structure here let me just close all
those other menus and let's have a look
at the users directory the users folder
has a subfolder for every person that
wants to use this structure and all they
have to do is create a new folder with a
login and then they can go nuts in there
so I've just put a menu py in mine to
demonstrate how this can be done and
obviously with this user's structure now
we have to modify the Annette py again
to make it part of the plugin path
let's have a quick look at those
additions first I'm importing the OS
package then I use the US package to
extract the current user from the
environment variable called user and
then I use that value to construct a
path from our base directory which is
library nuke tools users that's this guy
here followed by the current users login
name so that brings us into the current
user subdirectory in my case - this one
here then we just double check if that
directory actually exists and if it does
we'll add it to the plugin path so let's
go ahead and save this and close out of
nuke to force it to reread our main init
py and you can see this gives us a new
menu and then there is a 3d menu and
that's exactly what my menu py defines
and if somebody else will log in they
won't get this menu they will get
whatever is in their directory if they
have one so that's just an example of a
users based repository so now let's
apply that sort of technique to create a
show based repository let's say our show
root is called slash projects and in
there we'll have all of our show
directories with all the data in them
including a new corrector e that holds
show specific tools and in there the
usual directories and init and menu P
wise to manage the user interface and
the sub directory structures once again
we'll just drive it through our main
init py in the library nuke tools
directory so let's open that again and
add a few lines so this is pretty much
the same as we did for the users we're
getting the environment variable called
show we then go into our directory route
with it which in this case is slash
projects we add the current show that we
found in the environment variable and we
add the subdirectory nuke then once
again we make sure that that directory
actually exists and add it to a plugin
path so let's save that close out
and also quit out of nuke and let's go
ahead and set our environment variable
for the show and I'll point that to our
first test shell setup this is obviously
something that your job system would be
doing for you again this is just an
example so now that I've got the show
environment variable pointing to test
shell we once again can launch nuke and
will now find a new menu called test
show and in there we'll find whatever
show specific tools we've got so now if
I close this and change my environment
variable to test show one for example
launch nucleon we will get the menu for
test show 1 and the directory structure
in the test show one directory is being
read and so forth and as the last
example we'll set it up so we actually
get a menu for all the shows that exist
in the project root rather than just the
current one so once again let's open our
main init py and do some modifications
so instead of reading the environment
variable I now simply list all the
directories in our projects route and
then loop through all the directories
found verify that the nuke subdirectory
exists and if it does it'll be added to
the plugin path so one last time let's
save this and close nuke so it
relaunches and rereads our in it and now
you can see we get all the directories
tests show to test your one test show