def returnClosestPointOnMeshInfo(targetObj, mesh):
"""
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
DESCRIPTION:
Returns pertinent info of the closest point of a mesh to a target object -
position, normal, parameterU,parameterV,closestFaceIndex,closestVertexIndex
ARGUMENTS:
targetObj(string)
mesh(string)
RETURNS:
closestPointInfo(dict)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
"""
""" make the closest point node """
closestPointNode = mc.createNode ('closestPointOnMesh')
controlSurface = mc.listRelatives(mesh,shapes=True)
""" to account for target objects in heirarchies """
attributes.doConnectAttr((targetObj+'.translate'),(closestPointNode+'.inPosition'))
attributes.doConnectAttr((controlSurface[0]+'.worldMesh'),(closestPointNode+'.inMesh'))
attributes.doConnectAttr((controlSurface[0]+'.matrix'),(closestPointNode+'.inputMatrix'))
pointInfo = {}
pointInfo['position']=attributes.doGetAttr(closestPointNode,'position')
pointInfo['normal']=attributes.doGetAttr(closestPointNode,'normal')
pointInfo['parameterU']=mc.getAttr(closestPointNode+'.parameterU')
pointInfo['parameterV']=mc.getAttr(closestPointNode+'.parameterV')
pointInfo['closestFaceIndex']=mc.getAttr(closestPointNode+'.closestFaceIndex')
pointInfo['closestVertexIndex']=mc.getAttr(closestPointNode+'.closestVertexIndex')
mc.delete(closestPointNode)
return pointInfo
def returnClosestPointOnMeshInfo(targetObj, mesh):
"""
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
DESCRIPTION:
Returns pertinent info of the closest point of a mesh to a target object -
position, normal, parameterU,parameterV,closestFaceIndex,closestVertexIndex
ARGUMENTS:
targetObj(string)
mesh(string)
RETURNS:
closestPointInfo(dict)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
"""
""" make the closest point node """
closestPointNode = mc.createNode ('closestPointOnMesh')
controlSurface = mc.listRelatives(mesh,shapes=True)
""" to account for target objects in heirarchies """
attributes.doConnectAttr((targetObj+'.translate'),(closestPointNode+'.inPosition'))
attributes.doConnectAttr((controlSurface[0]+'.worldMesh'),(closestPointNode+'.inMesh'))
attributes.doConnectAttr((controlSurface[0]+'.matrix'),(closestPointNode+'.inputMatrix'))
pointInfo = {}
pointInfo['position']=attributes.doGetAttr(closestPointNode,'position')
pointInfo['normal']=attributes.doGetAttr(closestPointNode,'normal')
pointInfo['parameterU']=mc.getAttr(closestPointNode+'.parameterU')
pointInfo['parameterV']=mc.getAttr(closestPointNode+'.parameterV')
pointInfo['closestFaceIndex']=mc.getAttr(closestPointNode+'.closestFaceIndex')
pointInfo['closestVertexIndex']=mc.getAttr(closestPointNode+'.closestVertexIndex')
mc.delete(closestPointNode)
return pointInfo
def finalize(self):
"""
Press action. Clears buffers.
"""
#Clean our lists...
self.l_created = lists.returnListNoDuplicates(self.l_created)
self.l_return = lists.returnListNoDuplicates(self.l_return)
if self._createMode in ['curve','jointChain','group','follicle'] and self.l_return:
if self._createMode == 'group':
bufferList = []
for i,o in enumerate(self.l_created):
buffer = rigging.groupMeObject(o,False)
bufferList.append(buffer)
try:mc.delete(o)
except:pass
self.l_created = bufferList
elif self._createMode =='follicle':
if self.mode == 'midPoint':
log.warning("Mid point mode doesn't work with follicles")
return
bufferList = []
for o in self.l_created:
mesh = attributes.doGetAttr(o,'cgmHitTarget')
if mc.objExists(mesh):
uv = distance.returnClosestUVToPos(mesh,distance.returnWorldSpacePosition(o))
log.info("uv: {0}".format(uv))
follicle = nodes.createFollicleOnMesh(mesh)
log.info("follicle: {0}".format(follicle))
attributes.doSetAttr(follicle[0],'parameterU',uv[0])
attributes.doSetAttr(follicle[0],'parameterV',uv[1])
try:mc.delete(o)
except:pass
else:
for o in self.l_created:
try:mc.delete(o)
except:pass
if self._createMode == 'curve' and len(self.l_return)>1:
if len(self.l_return) > 1:
self.l_created = [curves.curveFromPosList(self.l_return)]
else:
log.warning("Need at least 2 points for a curve")
elif self._createMode == 'jointChain':
self.l_created = []
mc.select(cl=True)
for pos in self.l_return:
self.l_created.append( mc.joint (p = (pos[0], pos[1], pos[2]),radius = 1) )
log.debug( self.l_created)
if self.d_tagAndName:
for o in self.l_created:
try:
i_o = cgmMeta.cgmNode(o)
for tag in self.d_tagAndName.keys():
i_o.doStore(tag,self.d_tagAndName[tag])
i_o.doName()
except StandardError,error:
log.error(">>> clickMesh >> Failed to tag and name: %s | error: %s"%(i_o.p_nameShort,error))
def __init__(self, *args, **kws):
log.info('ChildClass.__init__ --')
#Pull out our args/kws we need ----------------------------------------------------------------------
node = kws.get('node')
name = kws.get('name')
_setClass = kws.get('setClass') or None
if args:
node = args[0]
if len(args) > 1:
name = args[1]
else:
name = kws.get('name')
if node is None or name is not None and mc.objExists(name):
log.info("Created node")
createdState = True
else:
createdState = False
if _setClass:
log.info(
"Preinitialize, setClass | default {0} | Maybe you shouldn't do this..."
.format(type(self).__name__))
try: #>>> TO CHECK IF WE NEED TO CLEAR CACHE ---------------------------------------------------------
_currentMClass = attributes.doGetAttr(
node, 'mClass') #...use to avoid exceptions
if _setClass in [True, 1]:
_setClass = type(self).__name__
if _setClass not in r9Meta.RED9_META_REGISTERY:
log.error("mClass value not registered - '{0}'".format(
_setClass))
_setMClass = False
if _setClass: #...if we're going to set the mClass attr...
if _currentMClass: #...does it have a current mClass attr value?
if _currentMClass != _setClass: #...if not the same, replace
log.warning(
"mClasses don't match. Changing to '{0}'".
format(_setClass))
#mc.setAttr('%s.mClass' %(node), value = _setClass)
attributes.doSetAttr(node, 'mClass', _setClass,
True)
attributes.doSetAttr(node, 'UUID', '', True)
_setMClass = True
else:
log.info("mClasses match. ignoring...")
else: #...if we have no value, set it
log.info("No mClass value, setting...")
_setMClass = True
if _setMClass:
if not mc.objExists("{0}.mClass".format(node)):
attributes.doAddAttr(node, 'mClass', 'string')
if not mc.objExists("{0}.UUID".format(node)):
attributes.doAddAttr(node, 'UUID', 'string')
attributes.doSetAttr(node, 'UUID', '', True)
attributes.doSetAttr(node, 'mClass', _setClass, True)
except Exception, error:
log.error("pre setClass fail >> %s" % error)
def returnClosestPointOnMeshInfoFromPos(pos, mesh):
"""
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
DESCRIPTION:
Returns pertinent info of the closest point of a mesh to a position in space -
position, normal, parameterU,parameterV,closestFaceIndex,closestVertexIndex
ARGUMENTS:
pos(string)
mesh(string)
RETURNS:
closestPointInfo(dict)
Keys:
position
normal
parameterU
parameterV
closestFaceIndex
closestVertexIndex
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
"""
""" make the closest point node """
closestPointNode = mc.createNode ('closestPointOnMesh')
controlSurface = mc.listRelatives(mesh,shapes=True)
""" to account for target objects in heirarchies """
locBuffer = mc.spaceLocator()
mc.move (pos[0],pos[1],pos[2], locBuffer[0])
attributes.doConnectAttr((locBuffer[0]+'.translate'),(closestPointNode+'.inPosition'))
attributes.doConnectAttr((controlSurface[0]+'.worldMesh'),(closestPointNode+'.inMesh'))
attributes.doConnectAttr((locBuffer[0]+'.matrix'),(closestPointNode+'.inputMatrix'))
pointInfo = {}
pointInfo['position']=attributes.doGetAttr(closestPointNode,'position')
pointInfo['normal']=attributes.doGetAttr(closestPointNode,'normal')
pointInfo['parameterU']=mc.getAttr(closestPointNode+'.parameterU')
pointInfo['parameterV']=mc.getAttr(closestPointNode+'.parameterV')
pointInfo['closestFaceIndex']=mc.getAttr(closestPointNode+'.closestFaceIndex')
pointInfo['closestVertexIndex']=mc.getAttr(closestPointNode+'.closestVertexIndex')
mc.delete(closestPointNode)
mc.delete(locBuffer[0])
return pointInfo
def simplePuppetReturn():
catch = mc.ls(type='network')
returnList = []
if catch:
for o in catch:
if attributes.doGetAttr(o,'mClass') in ['cgmPuppet','cgmMorpheusPuppet']:
returnList.append(o)
return returnList
def simplePuppetReturn():
catch = mc.ls(type='network')
returnList = []
if catch:
for o in catch:
if attributes.doGetAttr(
o, 'mClass') in ['cgmPuppet', 'cgmMorpheusPuppet']:
returnList.append(o)
return returnList
def verifyRotateOrderControl(self):
assert self.transform,"'%s' has no transform"%self.nameShort
initialValue = attributes.doGetAttr(self.nameLong,'rotateOrder')
try:
self.RotateOrderControl = AttrFactory(self,'setRO','enum',enum = 'xyz:yzx:zxy:xzy:yxz:zyx',initialValue=initialValue)
except:
raise StandardError("Failed to add rotate order control")
self.stateControlRO == True
self.RotateOrderControl.doConnectOut(self.nameShort+'.rotateOrder')
def returnTemplateObjects(self):
try:
templateNull = self.templateNull.getShortName()
returnList = []
for obj in mc.ls(type = 'transform'):
if attributes.doGetAttr(obj,'templateOwner') == templateNull:
returnList.append(obj)
return returnList
except StandardError,error:
log.warning(error)
def returnTemplateObjects(self):
try:
templateNull = self.templateNull.getShortName()
returnList = []
for obj in mc.ls(type='transform'):
if attributes.doGetAttr(obj, 'templateOwner') == templateNull:
returnList.append(obj)
return returnList
except StandardError, error:
log.warning(error)
def verifyRotateOrderControl(self):
assert self.transform,"'%s' has no transform"%self.nameShort
initialValue = attributes.doGetAttr(self.nameLong,'rotateOrder')
try:
self.RotateOrderControl = AttrFactory(self,'setRO','enum',enum = 'xyz:yzx:zxy:xzy:yxz:zyx',initialValue=initialValue)
except:
raise StandardError("Failed to add rotate order control")
self.stateControlRO == True
self.RotateOrderControl.doConnectOut(self.nameShort+'.rotateOrder')
def __init__(self,*args,**kws):
log.info('ChildClass.__init__ --')
#Pull out our args/kws we need ----------------------------------------------------------------------
node = kws.get('node')
name = kws.get('name')
_setClass = kws.get('setClass') or None
if args:
node = args[0]
if len(args)>1:
name = args[1]
else:
name = kws.get('name')
if node is None or name is not None and mc.objExists(name):
log.info("Created node")
createdState = True
else:
createdState = False
if _setClass:
log.info("Preinitialize, setClass | default {0} | Maybe you shouldn't do this...".format(type(self).__name__))
try:#>>> TO CHECK IF WE NEED TO CLEAR CACHE ---------------------------------------------------------
_currentMClass = attributes.doGetAttr(node,'mClass')#...use to avoid exceptions
if _setClass in [True, 1]:
_setClass = type(self).__name__
if _setClass not in r9Meta.RED9_META_REGISTERY:
log.error("mClass value not registered - '{0}'".format(_setClass))
_setMClass = False
if _setClass:#...if we're going to set the mClass attr...
if _currentMClass:#...does it have a current mClass attr value?
if _currentMClass != _setClass:#...if not the same, replace
log.warning("mClasses don't match. Changing to '{0}'".format(_setClass))
#mc.setAttr('%s.mClass' %(node), value = _setClass)
attributes.doSetAttr(node,'mClass',_setClass,True)
attributes.doSetAttr(node,'UUID','',True)
_setMClass = True
else:
log.info("mClasses match. ignoring...")
else:#...if we have no value, set it
log.info("No mClass value, setting...")
_setMClass = True
if _setMClass:
if not mc.objExists("{0}.mClass".format(node)):
attributes.doAddAttr(node, 'mClass', 'string')
if not mc.objExists("{0}.UUID".format(node)):
attributes.doAddAttr(node, 'UUID', 'string')
attributes.doSetAttr(node,'UUID','',True)
attributes.doSetAttr(node,'mClass',_setClass,True)
except Exception,error:
log.error("pre setClass fail >> %s"%error)
def finalize(self):
"""
Press action. Clears buffers.
"""
#Clean our lists...
self.createdList = lists.returnListNoDuplicates(self.createdList)
self.returnList = lists.returnListNoDuplicates(self.returnList)
if self.createMode in ['curve','jointChain','group','follicle'] and self.returnList:
if self.createMode == 'group':
bufferList = []
for i,o in enumerate(self.createdList):
buffer = rigging.groupMeObject(o,False)
bufferList.append(buffer)
try:mc.delete(o)
except:pass
self.createdList = bufferList
elif self.createMode =='follicle':
if self.mode == 'midPoint':
guiFactory.warning("Mid point mode doesn't work with follicles")
return
bufferList = []
for o in self.createdList:
mesh = attributes.doGetAttr(o,'cgmHitTarget')
if mc.objExists(mesh):
uv = distance.returnClosestUVToPos(mesh,distance.returnWorldSpacePosition(o))
follicle = nodes.createFollicleOnMesh(mesh)
attributes.doSetAttr(follicle[0],'parameterU',uv[0])
attributes.doSetAttr(follicle[0],'parameterV',uv[1])
try:mc.delete(o)
except:pass
else:
for o in self.createdList:
try:mc.delete(o)
except:pass
if self.createMode == 'curve' and len(self.returnList)>1:
if len(self.returnList) > 1:
self.createdList = [curves.curveFromPosList(self.returnList)]
else:
guiFactory.warning("Need at least 2 points for a curve")
elif self.createMode == 'jointChain':
self.createdList = []
mc.select(cl=True)
for pos in self.returnList:
self.createdList.append( mc.joint (p = (pos[0], pos[1], pos[2]),radius = 1) )
self.reset()
def finalize(self):
"""
Press action. Clears buffers.
"""
#Clean our lists...
self.createdList = lists.returnListNoDuplicates(self.createdList)
self.returnList = lists.returnListNoDuplicates(self.returnList)
if self.createMode in ['curve','jointChain','group','follicle'] and self.returnList:
if self.createMode == 'group':
bufferList = []
for i,o in enumerate(self.createdList):
buffer = rigging.groupMeObject(o,False)
bufferList.append(buffer)
try:mc.delete(o)
except:pass
self.createdList = bufferList
elif self.createMode =='follicle':
if self.mode == 'midPoint':
guiFactory.warning("Mid point mode doesn't work with follicles")
return
bufferList = []
for o in self.createdList:
mesh = attributes.doGetAttr(o,'cgmHitTarget')
if mc.objExists(mesh):
uv = distance.returnClosestUVToPos(mesh,distance.returnWorldSpacePosition(o))
follicle = nodes.createFollicleOnMesh(mesh)
attributes.doSetAttr(follicle[0],'parameterU',uv[0])
attributes.doSetAttr(follicle[0],'parameterV',uv[1])
try:mc.delete(o)
except:pass
else:
for o in self.createdList:
try:mc.delete(o)
except:pass
if self.createMode == 'curve' and len(self.returnList)>1:
if len(self.returnList) > 1:
self.createdList = [mc.curve (d=3, p = self.returnList , ws=True)]
else:
guiFactory.warning("Need at least 2 points for a curve")
elif self.createMode == 'jointChain':
self.createdList = []
mc.select(cl=True)
for pos in self.returnList:
self.createdList.append( mc.joint (p = (pos[0], pos[1], pos[2])) )
self.reset()
def returnClosestPointOnSurfaceInfo(targetObj, surface):
"""
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
DESCRIPTION:
Returns pertinent info of the closest point of a mesh to a target object -
position, normal, parameterU,parameterV,closestFaceIndex,closestVertexIndex
ARGUMENTS:
targetObj(string)
mesh(string)
RETURNS:
closestPointInfo(dict)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
"""
# make the closest point node #
closestPointNode = mc.createNode ('closestPointOnSurface')
pointOnSurfaceNode = mc.createNode ('pointOnSurfaceInfo')
controlSurface = mc.listRelatives(surface,shapes=True)
#>>>Surface Info
#Thanks - http://www.kylenikolich.com/scripting/lod/parentToSurface.mel
f_minU = attributes.doGetAttr(controlSurface[0],'mnu')
f_maxU = attributes.doGetAttr(controlSurface[0],'mxu')
f_sizeU = f_maxU - f_minU
f_minV = attributes.doGetAttr(controlSurface[0],'mnv')
f_maxV = attributes.doGetAttr(controlSurface[0],'mxv')
f_sizeV = f_maxV - f_minV
# to account for target objects in heirarchies #
pos = returnWorldSpacePosition(targetObj)
attributes.doSetAttr(closestPointNode,'inPositionX',pos[0])
attributes.doSetAttr(closestPointNode,'inPositionY',pos[1])
attributes.doSetAttr(closestPointNode,'inPositionZ',pos[2])
attributes.doConnectAttr((controlSurface[0]+'.worldSpace'),(closestPointNode+'.inputSurface'))
# Connect the info node to the surface #
attributes.doConnectAttr ((controlSurface[0]+'.local'),(pointOnSurfaceNode+'.inputSurface'))
# Contect the pos group to the info node#
attributes.doConnectAttr ((closestPointNode+'.parameterU'),(pointOnSurfaceNode+'.parameterU'))
attributes.doConnectAttr ((closestPointNode+'.parameterV'),(pointOnSurfaceNode+'.parameterV'))
pointInfo = {}
pointInfo['position']=attributes.doGetAttr(pointOnSurfaceNode,'position')
pointInfo['normal']=attributes.doGetAttr(pointOnSurfaceNode,'normal')
pointInfo['parameterU']=mc.getAttr(pointOnSurfaceNode+'.parameterU')
pointInfo['parameterV']=mc.getAttr(pointOnSurfaceNode+'.parameterV')
pointInfo['normalizedU'] = (pointInfo['parameterU'] + f_minU)/f_sizeU
pointInfo['normalizedV'] = (pointInfo['parameterV'] + f_minV)/f_sizeV
pointInfo['tangentU']=mc.getAttr(pointOnSurfaceNode+'.tangentU')
pointInfo['tangentV']=mc.getAttr(pointOnSurfaceNode+'.tangentV')
mc.delete(closestPointNode)
mc.delete(pointOnSurfaceNode)
log.debug(pointInfo)
return pointInfo
def validateMeshArg(self, mesh=None):
'''
Validates a mesh and returns a dict of data
:param mesh: mesh to evaluate
'''
_mesh = None
_skin = None
if mesh is None:
#if self.d_kws.get('sourceMesh'):
#log.info("Using stored sourceMesh data")
#sourceMesh = self.d_kws.get('sourceMesh')
#else:
log.info("No source specified, checking if selection found")
_bfr = mc.ls(sl=True)
if not _bfr:
raise ValueError, "No selection found and no source arg"
mesh = _bfr[0]
_type = search.returnObjectType(mesh)
if _type in ['mesh', 'nurbsCurve', 'nurbsSurface']:
if _type in ['nurbsCurve', 'nurbsSurface']:
raise NotImplementedError, "Haven't implemented nurbsCurve or nurbsSurface yet"
log.info("Skinnable object '{0}', checking skin".format(mesh))
_mesh = mesh
_skin = skinning.querySkinCluster(_mesh) or False
if _skin:
log.info("Found skin '{0}' on '{1}'".format(_skin, _mesh))
elif _type in ['skinCluster']:
log.info("skinCluster '{0}' passed...".format(mesh))
_skin = mesh
_mesh = attributes.doGetAttr(_skin, 'outputGeometry')[0]
log.info("Found: {0}".format(_mesh))
else:
raise ValueError, "Not a usable mesh type : {0}".format(_type)
_shape = mc.listRelatives(_mesh, shapes=True, fullPath=False)[0]
_return = {
'mesh': _mesh,
'meshType': _type,
'shape': _shape,
'skin': _skin,
'component': data._geoToComponent.get(_type, False),
'pointCount': mc.polyEvaluate(_shape, vertex=True)
}
return _return
def get(self,*a, **kw):
"""
Get and store attribute value based on attr type
Keyword arguments:
*a, **kw
"""
try:
if self.form == 'message':
self.value = attributes.returnMessageObject(self.obj.nameShort,self.attr)
else:
self.value = attributes.doGetAttr(self.obj.nameShort,self.attr)
#guiFactory.report("'%s.%s' >> '%s'"%(self.obj.nameShort,self.attr,self.value))
return self.value
except:
guiFactory.warning("'%s.%s' failed to get"%(self.obj.nameShort,self.attr))
def getModuleFromDict(self,checkDict):
"""
Pass a check dict of attrsibutes and arguments. If that module is found, it returns it.
checkDict = {'moduleType':'torso',etc}
"""
assert type(checkDict) is dict,"Arg must be dictionary"
for i_m in self.moduleChildren:
matchBuffer = 0
for key in checkDict.keys():
if i_m.hasAttr(key) and attributes.doGetAttr(i_m.mNode,key) == checkDict.get(key):
matchBuffer +=1
if matchBuffer == len(checkDict.keys()):
log.debug("Found Morpheus Module: '%s'"%i_m.getShortName())
return i_m
return False
def validateMeshArg(self, mesh = None):
'''
Validates a mesh and returns a dict of data
:param mesh: mesh to evaluate
'''
_mesh = None
_skin = None
if mesh is None:
#if self.d_kws.get('sourceMesh'):
#log.info("Using stored sourceMesh data")
#sourceMesh = self.d_kws.get('sourceMesh')
#else:
log.info("No source specified, checking if selection found")
_bfr = mc.ls(sl=True)
if not _bfr:raise ValueError,"No selection found and no source arg"
mesh = _bfr[0]
_type = search.returnObjectType(mesh)
if _type in ['mesh', 'nurbsCurve', 'nurbsSurface']:
if _type in ['nurbsCurve','nurbsSurface']:
raise NotImplementedError, "Haven't implemented nurbsCurve or nurbsSurface yet"
log.info("Skinnable object '{0}', checking skin".format(mesh))
_mesh = mesh
_skin = skinning.querySkinCluster(_mesh) or False
if _skin:
log.info("Found skin '{0}' on '{1}'".format(_skin,_mesh))
elif _type in ['skinCluster']:
log.info("skinCluster '{0}' passed...".format(mesh))
_skin = mesh
_mesh = attributes.doGetAttr(_skin,'outputGeometry')[0]
log.info("Found: {0}".format(_mesh))
else:
raise ValueError,"Not a usable mesh type : {0}".format(_type)
_shape = mc.listRelatives(_mesh,shapes=True,fullPath=False)[0]
_return = {'mesh':_mesh,
'meshType':_type,
'shape':_shape,
'skin':_skin,
'component':data._geoToComponent.get(_type, False),
'pointCount':mc.polyEvaluate(_shape, vertex=True)
}
return _return
def getModuleFromDict(self, checkDict):
"""
Pass a check dict of attrsibutes and arguments. If that module is found, it returns it.
checkDict = {'moduleType':'torso',etc}
"""
assert type(checkDict) is dict, "Arg must be dictionary"
for i_m in self.moduleChildren:
matchBuffer = 0
for key in checkDict.keys():
if i_m.hasAttr(key) and attributes.doGetAttr(
i_m.mNode, key) == checkDict.get(key):
matchBuffer += 1
if matchBuffer == len(checkDict.keys()):
log.debug("Found Morpheus Module: '%s'" % i_m.getShortName())
return i_m
return False
def get(self, *a, **kw):
"""
Get and store attribute value based on attr type
Keyword arguments:
*a, **kw
"""
try:
if self.form == 'message':
self.value = attributes.returnMessageObject(
self.obj.nameShort, self.attr)
else:
self.value = attributes.doGetAttr(self.obj.nameShort,
self.attr)
#guiFactory.report("'%s.%s' >> '%s'"%(self.obj.nameShort,self.attr,self.value))
return self.value
except:
guiFactory.warning("'%s.%s' failed to get" %
(self.obj.nameShort, self.attr))
def doTemplate(self,PuppetInstance):
"""
"""
def makeLimbTemplate (self):
#>>>Curve degree finder
if self.optionCurveDegree.get() == 0:
doCurveDegree = 1
else:
if len(corePositionList) <= 3:
doCurveDegree = 1
else:
doCurveDegree = len(corePositionList) - 1
#Make some storage vehicles
self.templatePosObjectsBuffer = BufferFactory(self.infoNulls['templatePosObjects'].get())
self.templatePosObjectsBuffer.purge()
LocatorCatcher = ObjectFactory('')
LocatorBuffer = BufferFactory(LocatorCatcher.nameLong)
LocatorBuffer.purge()
returnList = []
self.templHandleList = []
moduleColors = modules.returnModuleColors(self.ModuleNull.nameShort)
#>>>Scale stuff
moduleParent = self.msgModuleParent.get()
if not moduleParent:
length = (distance.returnDistanceBetweenPoints (corePositionList[0],corePositionList[-1]))
size = length / self.optionHandles.get()
else:
#>>>>>>>>>>>>>>>>>>>>> NOT TOUCHED YET
parentTemplatePosObjectsInfoNull = modules.returnInfoTypeNull(moduleParent,'templatePosObjects')
parentTemplatePosObjectsInfoData = attributes.returnUserAttrsToDict (parentTemplatePosObjectsInfoNull)
parentTemplateObjects = []
for key in parentTemplatePosObjectsInfoData.keys():
if (mc.attributeQuery (key,node=parentTemplatePosObjectsInfoNull,msg=True)) == True:
if search.returnTagInfo((parentTemplatePosObjectsInfoData[key]),'cgmType') != 'templateCurve':
parentTemplateObjects.append (parentTemplatePosObjectsInfoData[key])
createBuffer = curves.createControlCurve('sphere',1)
pos = corePositionList[0]
mc.move (pos[0], pos[1], pos[2], createBuffer, a=True)
closestParentObject = distance.returnClosestObject(createBuffer,parentTemplateObjects)
boundingBoxSize = distance.returnBoundingBoxSize (closestParentObject)
maxSize = max(boundingBoxSize)
size = maxSize *.25
mc.delete(createBuffer)
if partType == 'clavicle':
size = size * .5
elif partType == 'head':
size = size * .75
if (search.returnTagInfo(moduleParent,'cgmModuleType')) == 'clavicle':
size = size * 2
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
# Making the template objects
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
self.TemplateObject = {}
#>>> Template objects
for cnt,pos in enumerate(corePositionList):
#Size multiplier based on PuppetMode, make it take into account module mode eventually
if PuppetInstance.optionPuppetMode.get() == 0:
if cnt == 0:
sizeMultiplier = 1
elif cnt == len(corePositionList) -1:
sizeMultiplier = .8
else:
sizeMultiplier = .5
else:
sizeMultiplier = 1
#make a sphere and move it
createBuffer = curves.createControlCurve('sphere',(size * sizeMultiplier))
self.TemplateObject[cnt] = ObjectFactory(createBuffer) # Instance the control to our module
obj = self.TemplateObject[cnt]
curves.setCurveColorByName(obj.nameLong,moduleColors[0])
obj.store('cgmName',coreNames[cnt])
obj.getNameTagsFromObject(self.ModuleNull.nameLong,['cgmName','cgmType'])
obj.store('cgmType','templateObject')
obj.doName()
mc.move (pos[0], pos[1], pos[2], [obj.nameLong], a=True)
#adds it to the list
self.templHandleList.append (obj.nameLong)
self.templatePosObjectsBuffer.store(obj.nameLong)
#Aim the objects
position.aimObjects(self.templHandleList,
dictionary.axisDirectionsByString[ self.optionAimAxis.get() ],
dictionary.axisDirectionsByString[ self.optionUpAxis.get() ],
dictionary.axisDirectionsByString[ PuppetInstance.optionUpAxis.get() ])
#>>> Template curve
crvName = mc.curve (d=doCurveDegree, p = corePositionList , os=True, n=('%s_%s' %(partName,(typesDictionary.get('templateCurve')))))
self.afTemplateCurve = AttrFactory(self.infoNulls['templatePosObjects'].get(),
'curve','message', value=crvName)# connect it back to our template objects info null
curve = ObjectFactory(crvName) # instance it
curve.getNameTagsFromObject(self.ModuleNull.nameLong,['cgmType']) #get name tags from the module
attributes.storeInfo(crvName,'cgmType','templateCurve') # store type
curves.setCurveColorByName(crvName,moduleColors[1]) # set curve color
# Make locators to connect the cv's to
for cnt,obj in enumerate(self.templHandleList):
pointLoc = locators.locMeObject(obj) # make the loc
loc = ObjectFactory(pointLoc) #instance it
mc.setAttr ((loc.nameShort+'.visibility'),0) # turn off visibility
mc.parentConstraint ([obj],[loc.nameShort],mo=False) # parent constrain
mc.connectAttr ( (loc.nameShort+'.translate'),
('%s.controlPoints[%i]' % (crvName, cnt)), f=True ) # connect the cv to the loc
self.TemplateObject[cnt].store('loc',loc.nameLong)
LocatorBuffer.store(loc.nameLong)
#>>> Direction and size Stuff
"""
# Directional data derived from joints
generalDirection = logic.returnHorizontalOrVertical(self.templHandleList)
if generalDirection == 'vertical' and 'leg' not in self.afModuleType.get():
worldUpVector = [0,0,-1]
elif generalDirection == 'vertical' and 'leg' in self.afModuleType.get():
worldUpVector = [0,0,1]
else:
worldUpVector = [0,1,0]
"""
# Create root control
templateNull = self.msgTemplateNull.get()
handleList = copy.copy(self.templatePosObjectsBuffer.bufferList)
rootSize = (distance.returnBoundingBoxSizeToAverage(self.templHandleList[0])*1.5)
rootCtrl = ObjectFactory(curves.createControlCurve('cube',rootSize))
rootCtrl.getNameTagsFromObject(self.ModuleNull.nameLong)
self.msgTemplateRoot = AttrFactory(self.infoNulls['templatePosObjects'].get(), 'root', 'message', value = rootCtrl.nameLong)
curves.setCurveColorByName(rootCtrl.nameLong,moduleColors[0])
# move the root
if self.afModuleType.get() == 'clavicle':
position.movePointSnap(rootCtrl.nameLong,self.templHandleList[0])
else:
position.movePointSnap(rootCtrl.nameLong,self.templHandleList[0])
# aim the root
position.aimSnap(rootCtrl.nameShort,self.templHandleList[-1],
dictionary.axisDirectionsByString[ self.optionAimAxis.get() ],
dictionary.axisDirectionsByString[ self.optionUpAxis.get() ],
dictionary.axisDirectionsByString[ PuppetInstance.optionUpAxis.get() ])
rootCtrl.store('cgmType','templateRoot')
rootCtrl.doName()
#>>> Parent the main objcts
rootGroup = rootCtrl.doGroup()
rootGroup = rigging.doParentReturnName(rootGroup,templateNull)
curve.doParent(templateNull)
for obj in LocatorBuffer.bufferList:
rigging.doParentReturnName(obj,templateNull)
mc.delete(LocatorCatcher.nameShort) # delete the locator buffer obj
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
#>> Orientation helpers
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
# Make our Orientation Helpers
"""
orientHelpersReturn = template.addOrientationHelpers(self)
masterOrient = orientHelpersReturn[0]
orientObjects = orientHelpersReturn[1]
return
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
#>> Control helpers
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
print orientObjects
print self.ModuleNull.nameShort
print (templateNull+'.visControlHelpers')
controlHelpersReturn = addControlHelpers(orientObjects,self.ModuleNull.nameShort,(templateNull+'.visControlHelpers'))"""
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
#>> Input the saved values if there are any
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
# Orientation Helpers
"""rotBuffer = coreRotationList[-1]
#actualName = mc.spaceLocator (n= wantedName)
rotCheck = sum(rotBuffer)
if rotCheck != 0:
mc.rotate(rotBuffer[0],rotBuffer[1],rotBuffer[2],masterOrient,os=True)
cnt = 0
for obj in orientObjects:
rotBuffer = coreRotationList[cnt]
rotCheck = sum(rotBuffer)
if rotCheck != 0:
mc.rotate(rotBuffer[0],rotBuffer[1],rotBuffer[2],obj,os=True)
cnt +=1
# Control Helpers
controlHelpers = controlHelpersReturn[0]
cnt = 0
for obj in controlHelpers:
posBuffer = controlPositionList[cnt]
posCheck = sum(posBuffer)
if posCheck != 0:
mc.xform(obj,t=[posBuffer[0],posBuffer[1],posBuffer[2]],ws=True)
rotBuffer = controlRotationList[cnt]
rotCheck = sum(rotBuffer)
if rotCheck != 0:
mc.rotate(rotBuffer[0],rotBuffer[1],rotBuffer[2],obj,ws=True)
scaleBuffer = controlScaleList[cnt]
scaleCheck = sum(scaleBuffer)
if scaleCheck != 0:
mc.scale(scaleBuffer[0],scaleBuffer[1],scaleBuffer[2],obj,absolute=True)
cnt +=1 """
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
#>> Final stuff
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
"""
returnList.append(templObjNameList)
returnList.append(self.templHandleList)
returnList.append(rootCtrl)"""
return True
# Start objects stuff
partName = NameFactory.returnRawGeneratedName(self.ModuleNull.nameShort,ignore=['cgmType','cgmTypeModifier'])
templateStarterDataInfoNull = self.infoNulls['templateStarterData'].value
initialObjectsPosData = mc.listAttr(templateStarterDataInfoNull,userDefined=True)
corePositionList = []
coreRotationList = []
corePositionDict = {}
coreRotationDict = {}
for a in initialObjectsPosData:
buffer = attributes.doGetAttr(templateStarterDataInfoNull,a)
if 'cgm' not in a and type(buffer) is list:
if 'pos' in a:
split = a.split('pos_')
corePositionDict[int(split[1])] = buffer[0]
corePositionList.append(buffer[0])
elif 'rot' in a:
split = a.split('rot_')
coreRotationDict[int(split[1])] = buffer[0]
coreRotationList.append(buffer[0])
print corePositionList
print coreRotationList
# template control objects stuff #
templateControlObjectsDataNull = self.infoNulls['templateControlObjects'].value
templateControlObjectsData = mc.listAttr(templateControlObjectsDataNull,userDefined=True)
controlPositionList = []
controlRotationList = []
controlScaleList = []
controlPositionDict = {}
controlRotationDict = {}
controlScaleDict = {}
for a in templateControlObjectsData:
buffer = attributes.doGetAttr(templateControlObjectsDataNull,a)
if 'cgm' not in a and type(buffer) is list:
if 'pos' in a:
split = a.split('pos_')
controlPositionDict[int(split[1])] = buffer[0]
controlPositionList.append(buffer[0])
elif 'rot' in a:
split = a.split('rot_')
controlRotationDict[int(split[1])] = buffer[0]
controlRotationList.append(buffer[0])
elif 'scale' in a:
split = a.split('scale_')
controlScaleDict[int(split[1])] = buffer[0]
controlScaleList.append(buffer[0])
print controlPositionList
print controlRotationList
print controlScaleList
# Names Info #
coreNamesInfoNull = self.infoNulls['coreNames'].value
coreNamesBuffer = mc.listAttr(coreNamesInfoNull,userDefined=True)
coreNames = {}
for a in coreNamesBuffer:
if 'cgm' not in a and 'name_' in a:
split = a.split('name_')
coreNames[int(split[1])] = attributes.doGetAttr(coreNamesInfoNull,a)
print coreNames
print ('%s data aquired...'%self.ModuleNull.nameShort)
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
#>> make template objects
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
#makes template objects#
assert len(corePositionList) == self.optionHandles.get(),"There isn't enough data to template. Needs to be sized"
templateObjects = makeLimbTemplate(self)
guiFactory.report( 'Template Limb made....')
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
#>> Parent objects
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
for cnt,obj in enumerate(self.templHandleList):
self.TemplateObject[cnt].doParent(self.msgTemplateNull.get())
guiFactory.report('Template objects parented')
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
#>> Transform groups and Handles...handling
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
self.templatePosObjectsBuffer.updateData()
root = self.msgTemplateRoot.get()
handles = copy.copy( self.templatePosObjectsBuffer.bufferList )
stiffIndex = self.optionStiffIndex.get()
""" Don't remember why I did this stiff index thing....
#>>> Break up the handles into the sets we need
if stiffIndex == 0:
splitHandles = False
handlesToSplit = handles
handlesRemaining = [handles[0],handles[-1]]
elif stiffIndex < 0:
splitHandles = True
handlesToSplit = handles[:stiffIndex]
handlesRemaining = handles[stiffIndex:]
handlesRemaining.append(handles[0])
elif stiffIndex > 0:
splitHandles = True
handlesToSplit = handles[stiffIndex:]
handlesRemaining = handles[:stiffIndex]
handlesRemaining.append(handles[-1])
if len(handlesToSplit)>2:"""
# makes our mid transform groups#
if len(handles)>2:
constraintGroups = constraints.doLimbSegmentListParentConstraint(handles)
print 'Constraint groups created...'
for group in constraintGroups:
mc.parent(group,root)
# zero out the first and last#
for handle in [handles[0],handles[-1]]:
groupBuffer = (rigging.groupMeObject(handle,maintainParent=True))
mc.parent(groupBuffer,root)
#>>> Break up the handles into the sets we need
if stiffIndex < 0:
for handle in handles[(stiffIndex+-1):-1]:
groupBuffer = (rigging.groupMeObject(handle,maintainParent=True))
mc.parent(groupBuffer,handles[-1])
elif stiffIndex > 0:
for handle in handles[1:(stiffIndex+1)]:
groupBuffer = (rigging.groupMeObject(handle,maintainParent=True))
mc.parent(groupBuffer,handles[0])
print 'Constraint groups parented...'
#>>> Lock off handles
self.templatePosObjectsBuffer.updateData()
for obj in self.templatePosObjectsBuffer.bufferList:
attributes.doSetLockHideKeyableAttr(obj,True,False,False,['sx','sy','sz','v'])
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
# Parenting constraining parts
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
""" COME BACK AFTER DONE WITH SEGMENT
if self.moduleParent:
if self.afModuleType.get() == 'clavicle':
self.moduleParent = attributes.returnMessageObject(self.moduleParent,'self.moduleParent')
parentTemplatePosObjectsInfoNull = modules.returnInfoTypeNull(self.moduleParent,'templatePosObjects')
parentTemplatePosObjectsInfoData = attributes.returnUserAttrsToDict (parentTemplatePosObjectsInfoNull)
parentTemplateObjects = []
for key in parentTemplatePosObjectsInfoData.keys():
if (mc.attributeQuery (key,node=parentTemplatePosObjectsInfoNull,msg=True)) == True:
if search.returnTagInfo((parentTemplatePosObjectsInfoData[key]),'cgmType') != 'templateCurve':
parentTemplateObjects.append (parentTemplatePosObjectsInfoData[key])
closestParentObject = distance.returnClosestObject(rootName,parentTemplateObjects)
if (search.returnTagInfo(self.ModuleNull.nameShort,'cgmModuleType')) != 'foot':
constraintGroup = rigging.groupMeObject(rootName,maintainParent=True)
constraintGroup = NameFactory.doNameObject(constraintGroup)
mc.pointConstraint(closestParentObject,constraintGroup, maintainOffset=True)
mc.scaleConstraint(closestParentObject,constraintGroup, maintainOffset=True)
else:
constraintGroup = rigging.groupMeObject(closestParentObject,maintainParent=True)
constraintGroup = NameFactory.doNameObject(constraintGroup)
mc.parentConstraint(rootName,constraintGroup, maintainOffset=True)
# grab the last clavicle piece if the arm has one and connect it to the arm #
if self.moduleParent:
if (search.returnTagInfo(self.ModuleNull.nameShort,'cgmModuleType')) == 'arm':
if (search.returnTagInfo(self.moduleParent,'cgmModuleType')) == 'clavicle':
print '>>>>>>>>>>>>>>>>>>>>> YOU FOUND ME'
parentTemplatePosObjectsInfoNull = modules.returnInfoTypeNull(self.moduleParent,'templatePosObjects')
parentTemplatePosObjectsInfoData = attributes.returnUserAttrsToDict (parentTemplatePosObjectsInfoNull)
parentTemplateObjects = []
for key in parentTemplatePosObjectsInfoData.keys():
if (mc.attributeQuery (key,node=parentTemplatePosObjectsInfoNull,msg=True)) == True:
if search.returnTagInfo((parentTemplatePosObjectsInfoData[key]),'cgmType') != 'templateCurve':
parentTemplateObjects.append (parentTemplatePosObjectsInfoData[key])
closestParentObject = distance.returnClosestObject(rootName,parentTemplateObjects)
endConstraintGroup = rigging.groupMeObject(closestParentObject,maintainParent=True)
endConstraintGroup = NameFactory.doNameObject(endConstraintGroup)
mc.pointConstraint(handles[0],endConstraintGroup, maintainOffset=True)
mc.scaleConstraint(handles[0],endConstraintGroup, maintainOffset=True)
"""
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
#>> Final stuff
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
#>>> Set our new module rig process state
self.afTemplateState.set(1)
print ('%s done!'%self.ModuleNull.nameShort)
#>>> Tag our objects for easy deletion
children = mc.listRelatives (self.msgTemplateNull.get(), allDescendents = True,type='transform')
for obj in children:
attributes.storeInfo(obj,'cgmOwnedBy',self.msgTemplateNull.get())
#>>> Visibility Connection
"""
def initialize(self):
"""
Verifies the various components a masterNull for a character/asset. If a piece is missing it replaces it.
RETURNS:
success(bool)
"""
#Puppet null
if not attributes.doGetAttr(self.PuppetNull.nameShort, 'cgmName'):
return False
if attributes.doGetAttr(self.PuppetNull.nameShort,
'cgmType') != 'ignore':
return False
if attributes.doGetAttr(self.PuppetNull.nameShort,
'cgmModuleType') != 'master':
return False
self.msgModulesGroup = AttrFactory(self.PuppetNull, 'modulesGroup')
if not self.msgModulesGroup.get():
guiFactory.warning(
"'%s' looks to be missing. Go back to unreferenced file" %
self.msgModulesGroup.attr)
return False
else:
self.ModulesGroup = ObjectFactory(self.msgModulesGroup.get())
self.msgNoTransformGroup = AttrFactory(self.PuppetNull,
'noTransformGroup')
if not self.msgNoTransformGroup.get():
guiFactory.warning(
"'%s' looks to be missing. Go back to unreferenced file" %
self.msgNoTransformGroup.attr)
return False
else:
self.NoTransformGroup = ObjectFactory(
self.msgNoTransformGroup.get())
self.msgGeoGroup = AttrFactory(self.PuppetNull, 'geoGroup')
if not self.msgGeoGroup.get():
guiFactory.warning(
"'%s' looks to be missing. Go back to unreferenced file" %
self.msgGeoGroup.attr)
return False
else:
self.GeoGroup = ObjectFactory(self.msgGeoGroup.get())
self.msgPuppetInfo = AttrFactory(self.PuppetNull, 'info')
if not self.msgPuppetInfo.get():
guiFactory.warning(
"'%s' looks to be missing. Go back to unreferenced file" %
self.msgPuppetInfo.attr)
return False
else:
self.PuppetInfoNull = ObjectFactory(self.msgPuppetInfo.get())
self.msgModuleInfo = AttrFactory(self.PuppetInfoNull, 'modules')
if not self.msgModuleInfo.get():
guiFactory.warning(
"'%s' looks to be missing. Go back to unreferenced file" %
self.msgModuleInfo.attr)
return False
else:
#Initialize our modules null as a buffer
self.ModuleInfoNull = ObjectFactory(self.msgModuleInfo.get())
self.ModulesBuffer = BufferFactory(self.msgModuleInfo.get())
self.msgGeoInfo = AttrFactory(self.PuppetInfoNull, 'geo')
if not self.msgGeoInfo.get():
guiFactory.warning(
"'%s' looks to be missing. Go back to unreferenced file" %
self.msgGeoInfo.attr)
return False
else:
self.GeoInfoNull = ObjectFactory(self.msgGeoInfo.get())
self.msgSettingsInfo = AttrFactory(self.PuppetInfoNull, 'settings')
if not self.msgSettingsInfo.get():
guiFactory.warning(
"'%s' looks to be missing. Go back to unreferenced file" %
self.msgSettingsInfo.attr)
return False
else:
self.SettingsInfoNull = ObjectFactory(
self.msgSettingsInfo.get(), )
self.optionPuppetMode = AttrFactory(
self.SettingsInfoNull, 'optionPuppetTemplateMode')
self.optionAimAxis = AttrFactory(self.SettingsInfoNull,
'axisAim')
self.optionUpAxis = AttrFactory(self.SettingsInfoNull,
'axisUp')
self.optionOutAxis = AttrFactory(self.SettingsInfoNull,
'axisOut')
return True
