339 lines
12 KiB
Python
Executable File
339 lines
12 KiB
Python
Executable File
'''
|
|
Module for accessing configuration and settings.
|
|
|
|
Provides access to the current Project, User, Environment( Motionbuilder ) and installed Tools.
|
|
|
|
Author: Jason Hayes <jason.hayes@rockstarsandiego.com>
|
|
Author: Ross George <ross.george@rockstarlondon.com>
|
|
'''
|
|
|
|
import clr
|
|
import sys
|
|
import os
|
|
import inspect
|
|
|
|
import RS.Core.Metadata
|
|
|
|
clr.AddReference("RSG.Base.Configuration")
|
|
from RSG.Base.Configuration import ConfigFactory
|
|
|
|
#Create our .NET config object which we will extract all configuration settings from
|
|
_Config = ConfigFactory.CreateConfig()
|
|
|
|
class Branch( object ):
|
|
'''Represents a branch within a project.'''
|
|
def __init__( self, in_CLRBranch ):
|
|
|
|
self._Name = in_CLRBranch.Name
|
|
self._IsDefault = in_CLRBranch.IsDefault
|
|
|
|
class Path:
|
|
'''Nested singleton which contains all paths related to the branch.'''
|
|
def __init__( self ):
|
|
self._Common = str( in_CLRBranch.Common )
|
|
self._Build = str( in_CLRBranch.Build )
|
|
self._Audio = str( in_CLRBranch.Audio )
|
|
self._Code = str( in_CLRBranch.Code )
|
|
|
|
@property
|
|
def Common(self):
|
|
'''Common root path.'''
|
|
return self._Common
|
|
@property
|
|
def Build(self):
|
|
'''Build root path.'''
|
|
return self._Build
|
|
@property
|
|
def Audio(self):
|
|
'''Audio root path.'''
|
|
return self._Audio
|
|
@property
|
|
def Code(self):
|
|
'''Code root path.'''
|
|
return self._Code
|
|
self._Path = Path()
|
|
|
|
@property
|
|
def Name(self):
|
|
'''Name of the branch.'''
|
|
return self._Name
|
|
@property
|
|
def IsDefault(self):
|
|
'''Indicates if the branch is the default branch.'''
|
|
return self._IsDefault
|
|
@property
|
|
def Path(self):
|
|
'''Paths related to the branch'''
|
|
return self._Path
|
|
|
|
class Project( object ):
|
|
'''Provides access to project specific settings and configuration.'''
|
|
def __init__( self ):
|
|
|
|
class Path( object ):
|
|
'''Nested singleton which contains all root level paths for the project.'''
|
|
def __init__( self ):
|
|
self._Cache = str( _Config.Project.Cache )
|
|
self._Root = str( _Config.Project.Root )
|
|
self._Art = str( _Config.Project.DefaultBranch.Art )
|
|
self._Anim = str( _Config.Project.DefaultBranch.Anim )
|
|
self._Assets = str( _Config.Project.DefaultBranch.Assets )
|
|
self._Processed = str( _Config.Project.DefaultBranch.Processed )
|
|
self._Export = str( _Config.Project.DefaultBranch.Export )
|
|
self._Metadata = str( _Config.Project.DefaultBranch.Metadata )
|
|
|
|
@property
|
|
def Cache(self):
|
|
'''Project export cache root path.'''
|
|
return self._Cache
|
|
@property
|
|
def Root(self):
|
|
'''Project root path.'''
|
|
return self._Root
|
|
@property
|
|
def Art(self):
|
|
'''Project art source root path.'''
|
|
return self._Art
|
|
@property
|
|
def Anim(self):
|
|
'''Project anim source root path.'''
|
|
return self._Anim
|
|
@property
|
|
def Assets(self):
|
|
'''Project assets root path.'''
|
|
return self._Assets
|
|
@property
|
|
def Processed(self):
|
|
'''Project processed root path.'''
|
|
return self._Processed
|
|
@property
|
|
def Export(self):
|
|
'''Project export root path.'''
|
|
return self._Export
|
|
@property
|
|
def Metadata(self):
|
|
'''Project metadata root path.'''
|
|
return self._Metadata
|
|
|
|
self._Name = _Config.Project.FriendlyName
|
|
self._Path = Path()
|
|
|
|
self._DefaultBranch = None
|
|
self._Branches = list()
|
|
|
|
for CLRBranch in _Config.Project.Branches:
|
|
CurrentBranch = Branch( CLRBranch.Value )
|
|
self._Branches.append( CurrentBranch )
|
|
if( CurrentBranch.Name == _Config.Project.DefaultBranch.Name ):
|
|
self._DefaultBranch = CurrentBranch
|
|
self._DefaultBranch._IsDefault = True
|
|
|
|
@property
|
|
def Name(self):
|
|
'''Name of the project.'''
|
|
return self._Name
|
|
@property
|
|
def Path(self):
|
|
'''Paths related to the project'''
|
|
return self._Path
|
|
@property
|
|
def Branches(self):
|
|
'''Branches for the current project'''
|
|
return self._Branches
|
|
@property
|
|
def DefaultBranch(self):
|
|
'''The default branch for the project'''
|
|
return self._DefaultBranch
|
|
|
|
class User( object ):
|
|
'''Provides access to properties and settings related to the current user.'''
|
|
def __init__( self ):
|
|
self._Name = str( _Config.Username )
|
|
self._Domain = str( _Config.Studios.ThisStudio.Domain )
|
|
self._Studio = str( _Config.Studios.ThisStudio.FriendlyName )
|
|
self._Email = str( _Config.EmailAddress )
|
|
self._IsExternal = False
|
|
self._Type = NotImplemented
|
|
self._ExchangeServer = str( _Config.Studios.ThisStudio.ExchangeServer )
|
|
|
|
@property
|
|
def Name(self):
|
|
'''Name of the user.'''
|
|
return self._Name
|
|
@property
|
|
def Domain(self):
|
|
'''Domain the user belongs to.'''
|
|
return self._Domain
|
|
@property
|
|
def Studio(self):
|
|
'''Studio the user belongs to.'''
|
|
return self._Studio
|
|
@property
|
|
def Email(self):
|
|
'''Email address of the user'''
|
|
return self._Email
|
|
@property
|
|
def IsExternal(self):
|
|
'''Indicates whether the user is external (outsourcer) or not'''
|
|
return self._IsExternal
|
|
@property
|
|
def Type(self):
|
|
'''Type of user (e.g. Animator, Artist, Tools Developer)'''
|
|
return self._Type
|
|
@property
|
|
def ExchangeServer( self ):
|
|
'''Users exhange server'''
|
|
return self._ExchangeServer
|
|
|
|
class Tool( object ):
|
|
'''Provides access to information and settings about the tools currently installed.'''
|
|
def __init__( self ):
|
|
|
|
class Path( object ):
|
|
'''Nested singleton which contains relevant paths for tools.'''
|
|
def __init__( self ):
|
|
self._Library = str( _Config.ToolsLib )
|
|
self._Bin = str( _Config.ToolsBin )
|
|
self._Logs = str( _Config.ToolsLogs )
|
|
self._Root = str( _Config.ToolsRoot )
|
|
self._Config = str( _Config.ToolsConfig )
|
|
self._Drive = str( _Config.ToolsDrive )
|
|
self._Temp = str( _Config.ToolsTemp )
|
|
self._TechArt = '{0}\\techart'.format( self._Root )
|
|
|
|
currentFile = str( os.path.abspath( inspect.getfile( inspect.currentframe() ) ) ).lower()
|
|
|
|
if 'x:\\wildwest' in currentFile:
|
|
self._TechArt = 'x:\\wildwest'
|
|
|
|
@property
|
|
def TechArt( self ):
|
|
'''Tech Art directory root path.'''
|
|
return self._TechArt
|
|
|
|
@property
|
|
def Library(self):
|
|
'''Tools root library path.'''
|
|
return self._Library
|
|
@property
|
|
def Bin(self):
|
|
'''Tools root bin path.'''
|
|
return self._Bin
|
|
@property
|
|
def Logs(self):
|
|
'''Tools log path.'''
|
|
return self._Logs
|
|
@property
|
|
def Root(self):
|
|
'''Tools root path.'''
|
|
return self._Root
|
|
@property
|
|
def Config(self):
|
|
'''Tools configuration path.'''
|
|
return self._Config
|
|
@property
|
|
def Drive(self):
|
|
'''Tools root drive.'''
|
|
return self._Drive
|
|
@property
|
|
def Temp(self):
|
|
'''Tools temporary path.'''
|
|
return self._Temp
|
|
|
|
class Executable( object ):
|
|
'''Nested singleton which contains relevant executable paths for tools.'''
|
|
def __init__( self ):
|
|
self._LogViewer = '{0}\\bin\\UniversalLogViewer\\UniversalLogViewer.exe'.format( _Config.ToolsLib )
|
|
|
|
@property
|
|
def LogViewer(self):
|
|
'''Log viewer .exe path.'''
|
|
return self._LogViewer
|
|
|
|
self._Version = _Config.Version.InstalledVersion.LabelName
|
|
self._Path = Path()
|
|
self._Executable = Executable()
|
|
|
|
@property
|
|
def Version(self):
|
|
'''Currently install of tools version.'''
|
|
return self._Version
|
|
@property
|
|
def Path(self):
|
|
'''Useful paths related to tools.'''
|
|
return self._Path
|
|
@property
|
|
def Executable(self):
|
|
'''Useful executable paths (mainly from the bin directory).'''
|
|
return self._Executable
|
|
|
|
|
|
class Script( object ):
|
|
'''Provides access to information about the python script framework for this session of Motionbuilder.'''
|
|
|
|
def __init__( self ):
|
|
|
|
class Path( object ):
|
|
'''Nested singleton which contains relevant paths for scripts.'''
|
|
def __init__( self ):
|
|
|
|
currentFile = str( os.path.abspath( inspect.getfile( inspect.currentframe() ) ) ).lower()
|
|
|
|
self._Root = os.path.abspath( '{0}/../..'.format( os.path.dirname( currentFile ) ) )
|
|
self._RockstarRoot = '{0}\\packages\\RS'.format( self._Root )
|
|
|
|
@property
|
|
def Root(self):
|
|
'''Script root path.'''
|
|
return self._Root
|
|
|
|
@property
|
|
def RockstarRoot(self):
|
|
'''Rockstar script root path.'''
|
|
return self._RockstarRoot
|
|
|
|
@property
|
|
def ToolImages(self):
|
|
return os.path.abspath( '{0}\\images'.format( self._Root ) )
|
|
|
|
@property
|
|
def StandaloneRoot(self):
|
|
return os.path.abspath( '{0}\\standalone'.format( self._Root ) )
|
|
|
|
@property
|
|
def PackagesRoot(self):
|
|
return os.path.abspath( '{0}\\packages'.format( self._Root ) )
|
|
|
|
self._Path = Path()
|
|
|
|
@property
|
|
def Path(self):
|
|
'''Useful paths related to script.'''
|
|
return self._Path
|
|
@property
|
|
def DevelopmentMode(self):
|
|
'''Indicates if the session of MotionBuilder is in development mode.'''
|
|
return self._DevelopmentMode
|
|
@property
|
|
def TargetBuildVersion(self):
|
|
'''The build version of MotionBuilder the scripts are designed to work with.'''
|
|
return self._TargetBuildVersion
|
|
@property
|
|
def TargetBuildTitle(self):
|
|
'''Human friendly name for the TargetBuildVersion.'''
|
|
return self._TargetBuildTitle
|
|
@property
|
|
def DependencyPathList(self):
|
|
'''Paths to files and directories that MotionBuilder is dependant on.'''
|
|
return self._DependencyPathList
|
|
|
|
#Overwrite the Project class definition with a single instance of Project
|
|
Project = Project( )
|
|
#Overwrite the User class definition with a single instance of User
|
|
User = User( )
|
|
#Overwrite the Tool class definition with a single instance of User
|
|
Tool = Tool( )
|
|
#Overwrite the Environment class definition with a single instance of User
|
|
Script = Script( )
|
|
|