def mirror_controlShape(source=None, target=None, colorDirection='right', controlType='main'): _str_func = "mirror_controlShape" if target is None: _sel = mc.ls(sl=True) if len(_sel) == 2: return mirror_controlShape(_sel[0], _sel[1]) if not source: raise ValueError, "|{0}| >> Must have a source".format(_str_func) if not target: raise ValueError, "|{0}| >> Must have a target".format(_str_func) _dup_curve = mc.duplicate(source)[0] for child in TRANS.children_get(_dup_curve, True): mc.delete(child) ATTR.set_standardFlags(_dup_curve, lock=False, keyable=True, visible=True) _grp = mc.group(em=True) _dup_curve = TRANS.parent_set(_dup_curve, _grp) ATTR.set(_grp, 'scaleX', -1) _dup_curve = TRANS.parent_set(_dup_curve, False) mc.makeIdentity(_dup_curve, apply=True, translate=True, rotate=True, scale=False) return shapeParent_in_place(target, _dup_curve, True, True) mc.delete(_grp) colorControl(target, colorDirection, controlType) mc.select(target) return target
def push_controlResizeObj(target=None): _str_func = "push_controlResizeObj" if target is None: _sel = mc.ls(sl=True) if _sel: _res = [] for t in _sel: _res.append(push_controlResizeObj(t)) mc.select(_res) return _res if not target: raise ValueError, "|{0}| >> Must have a target".format(_str_func) if ATTR.has_attr(target, 'cgmControlResizerSource'): source = ATTR.get_message(target, 'cgmControlResizerSource') if not source: raise ValueError, "|{0}| >> no cgmControlResizerSource data on target: {1}".format( _str_func, target) source = source[0] shapeParent_in_place(source, target, keepSource=False, replaceShapes=True) if ATTR.has_attr(source, 'cgmControlResizer'): ATTR.delete(source, 'cgmControlResizer') ATTR.set(source, 'template', 0) mc.select(source) return source else: raise ValueError, "|{0}| >> no cgmControlResizerSource attr on target: {1}".format( _str_func, target)
def get_lights(self): _str_func = 'factory.get_lights' _profile = d_profiles.get(self.profile) self.ml_lights = [] self.ml_lightDags = [] for n,d in _profile.iteritems(): _type = d.get('type') try:_light = d_lightCalls[_type]() except: log.error("|{0}| >> Light create fail {1} | {2}".format(_str_func,n,_type)) continue mLight = cgmMeta.asMeta(_light) mLight.addAttr('cgmType','cgmLight',lock=True) mDag = mLight.getTransform(asMeta=True) mDag.rename("{0}_cgmLight".format(n)) for a,v in d['settings'].iteritems(): log.debug("|{0}| >> setting {1} | {2}:{3}".format(_str_func,n,a,v)) ATTR.set(mLight.mNode,a,v) mDag.p_position = d['dag']['position'] mDag.p_orient = d['dag']['orient'] log.debug("|{0}| >> setting {1} | position:{2}".format(_str_func,n,d['dag']['position'])) log.debug("|{0}| >> setting {1} | orient:{2}".format(_str_func,n,d['dag']['orient'])) self.ml_lightDags.append(mDag) self.ml_lights.append(mLight)
def set_attrs(self, attr=None, value=None, context='selection', mType=None, select=True): """ Get data for updating a transform :parameters self(instance): cgmMarkingMenu :returns info(dict) """ _str_func = "set_attr" _context = context.lower() _sl = mc.ls(sl=True) _l_context = get_list(_context, mType) log.debug( "|{0}| >> attr: {1} | value: {2} | mType: {3} | context: {4}".format( _str_func, attr, value, mType, _context)) for o in _l_context: try: #log.debug("|{0}| >> obj:{1} | attr:{2} | value:{3} ".format(_str_func,o,attr,value)) ATTR.set(o, attr, value) #cgmMeta.cgmNode(o).__setattr__(attr,value) except Exception, err: log.error( "|{0}| >> set fail. obj:{1} | attr:{2} | value:{3} | error: {4} | {5}" .format(_str_func, NAMES.get_short(o), attr, value, err, Exception))
def get_uv_normal(mesh, uvValue, asEuclid=False): """ Get a normal at a uv :parameters: mesh(string) | Surface uv resides on uValue(float) | uValue vValue(float) | vValue asEuclid(bool) - whether to return as Vector or not :returns pos(double3) """ _str_func = 'get_uv_position' _follicle = NODE.add_follicle(mesh) ATTR.set(_follicle[0], 'parameterU', uvValue[0]) ATTR.set(_follicle[0], 'parameterV', uvValue[1]) _normal = ATTR.get(_follicle[0], 'outNormal') mc.delete(_follicle) if asEuclid: log.debug("|{0}| >> asEuclid...".format(_str_func)) return EUCLID.Vector3(_normal[0], _normal[1], _normal[2]) return _normal
def uiFunc_valuesTweak(self, mode='+'): _str_func = 'uiFunc_valuesTweak' if mode == 'zero': log.info("|{0}| >> Zeroing ".format(_str_func)) for a in 'XYZ': self.__dict__['uiff_transformTweak{0}'.format(a)].setValue(0) for k, cb in self._d_transformCBs.iteritems(): cb.setValue(0) return _ml_targets = uiFunc_getTargets(self) if not _ml_targets: raise ValueError, "Must have targets" _l_toTweak = [] for k, cb in self._d_transformCBs.iteritems(): if cb.getValue(): _l_toTweak.append(k) _tweak = [] for a in 'XYZ': _tweak.append( self.__dict__['uiff_transformTweak{0}'.format(a)].getValue()) pprint.pprint([mode, _l_toTweak, _tweak]) if mode == '+': _tweak_call = MATH.list_add else: _tweak_call = MATH.list_subtract for mObj in _ml_targets: for attr in _l_toTweak: if attr in [ 'translate', 'rotate', 'scale', 'jointOrient', 'rotateAxis' ]: _v = ATTR.get(mObj.mNode, attr) log.info("|{0}| >> pre tweak: [{1}] ".format(_str_func, _v)) _v = _tweak_call(_v, _tweak) log.info("|{0}| >> post tweak: [{1}] ".format(_str_func, _v)) ATTR.set(mObj.mNode, attr, _v) elif attr == 'position': _v = TRANS.position_get(mObj.mNode) log.info("|{0}| >> pre tweak: [{1}] ".format(_str_func, _v)) _v = _tweak_call(_v, _tweak) log.info("|{0}| >> post tweak: [{1}] ".format(_str_func, _v)) TRANS.position_set(mObj.mNode, _v) elif attr == 'orient': _v = TRANS.orient_get(mObj.mNode) log.info("|{0}| >> pre tweak: [{1}] ".format(_str_func, _v)) _v = _tweak_call(_v, _tweak) log.info("|{0}| >> post tweak: [{1}] ".format(_str_func, _v)) TRANS.orient_set(mObj.mNode, _v) else: log.warning("|{0}| >> Haven't setup for {1}...".format( _str_func, _s)) pass
def get_uv_position(mesh, uvValue, asEuclid=False): """ Get a uv position in world space. UV should be normalized. :parameters: mesh(string) | Surface uv resides on uValue(float) | uValue vValue(float) | vValue asEuclid(bool) - whether to return as Vector or not :returns pos(double3) """ _str_func = 'get_uv_position' _follicle = NODE.add_follicle(mesh) ATTR.set(_follicle[0], 'parameterU', uvValue[0]) ATTR.set(_follicle[0], 'parameterV', uvValue[1]) _pos = get(_follicle[1]) mc.delete(_follicle) if asEuclid: log.debug("|{0}| >> asEuclid...".format(_str_func)) return EUCLID.Vector3(_pos[0], _pos[1], _pos[2]) return _pos
def profile_load(target = None, arg = None, module = dynFKPresets, clean = True): _str_func = 'profile_apply' mTar = cgmMeta.asMeta(target, noneValid = True) if not mTar: return log.error(cgmGEN.logString_msg(_str_func, "No valid target")) _type = mTar.getMayaType() _key = d_shortHand.get(_type,_type) log.info(cgmGEN.logString_msg(_str_func,"mTar: {0} | {1}".format(_type, mTar))) _d_profile = profile_get(arg,module) if not _d_profile: log.warning("Invalid profile: {0}".format(arg)) return False _d_type = _d_profile.get(_key) if not _d_type: log.warning("No {0} dat".format(_type)) return False if clean: d_use = profile_get('base',module).get(_key) d_use.update(_d_type) else: d_use = _d_type _node = mTar.mNode for a,v in d_use.iteritems(): log.debug("{0} || {1} | {2}".format(_type, a,v)) try: ATTR.set(_node, a, v) #mNucleus.__setattr__(a,v) except Exception,err: log.warning("{3} | Failed to set: {0} | {1} | {2}".format(a,v,err, _type))
def release_post_insert(self): _str_funcName = 'follicleAttach.release' """if not self.b_dragStoreMode:#If not on drag, do it here. Otherwise do it on update if self._posBuffer: self.l_return.extend(self._posBuffer) if self._posBufferRaw: self.l_returnRaw.extend(self._posBufferRaw) else: self.l_returnRaw.extend(self._posBuffer) if self._createModeBuffer: self.l_created.extend(self._createModeBuffer)""" for pos in self.l_returnRaw: log.debug("|{0}|...pos {1}".format(_str_funcName,pos)) for i,m in enumerate(self.d_meshPos.keys()): log.debug("|{0}|...mesh: {1}".format(_str_funcName,m)) for i2,h in enumerate(self.d_meshPos[m]): if h == pos: log.debug("Found follicle match!") try: _set = [m, self.d_meshUV[m][i2], "{0}_u{1}_v{2}".format(coreNames.get_short(m),"{0:.4f}".format(self.d_meshUV[m][i2][0]),"{0:.4f}".format(self.d_meshUV[m][i2][1]))] self._l_folliclesToMake.append(_set) log.debug("|{0}|...uv {1}".format(_str_funcName,_set)) except Exception,err: log.error("|{0}| >> Failed to query uv for hit {2} on shape {2} | err:{1}".format(_str_funcName,err,pos,m)) if self._l_folliclesToMake: for f_dat in self._l_folliclesToMake: _follicle = NODES.add_follicle(f_dat[0],f_dat[2]) log.info("|finalize| >> Follicle created: {0}".format(_follicle)) ATTR.set(_follicle[0],'parameterU',f_dat[1][0]) ATTR.set(_follicle[0],'parameterV',f_dat[1][1]) mc.parent(_loc, _follicle[0])
def create_controlResizeObj(target=None): _str_func = "create_controlResizeObj" if target is None: _sel = mc.ls(sl=True) if _sel: _res = [] for t in _sel: _res.append(create_controlResizeObj(t)) return _res if not target: raise ValueError, "|{0}| >> Must have a target".format(_str_func) if ATTR.get_message(target, 'cgmControlResizer'): return ATTR.get_message(target, 'cgmControlResizer') handle = create_at(target, 'null') ATTR.set_message(target, 'cgmControlResizer', handle) ATTR.set_message(handle, 'cgmControlResizerSource', target) handle = mc.rename(handle, NAMES.base(target) + '_cgmResizer') shapeParent_in_place(handle, target) ATTR.set(target, 'template', 1) return handle
def reset_channels(nodes=None,selectedChannels=False, transformsOnly=False, excludeChannels=None, keyableOnly=False): ''' Modified from Morgan Loomis' great reset call to expand options... ''' gChannelBoxName = mel.eval('$temp=$gChannelBoxName') _reset = {} if not nodes: nodes = mc.ls(sl=True) if not nodes: return if excludeChannels: if not isinstance(excludeChannels, (list, tuple)): excludeChannels = [excludeChannels] chans = None if selectedChannels: chans = mc.channelBox(gChannelBoxName, query=True, sma=True) l_trans = ['translateX','translateY','translateZ','rotateX','rotateY','rotateZ','scaleX','scaleY','scaleZ','tx','ty','yz','rx','ry','rz','sx','sy','sz'] for obj in nodes: #mObj = r9Meta.MetaClass(obj) attrs = chans if not chans: attrs = mc.listAttr(obj, keyable=True, unlocked=True) if excludeChannels: attrs = [x for x in attrs if x not in excludeChannels] if transformsOnly: attrs = [x for x in attrs if x in l_trans] if keyableOnly: attrs = [x for x in attrs if ATTR.is_keyable(obj,x)] d_defaults = {} for plug in ['defaultValues','transResets']: if ATTR.has_attr(obj, plug): d_defaults = getattr(r9Meta.MetaClass(obj),plug) if not attrs: log.warning("{0} resetAttrs | no attributes offered!".format(obj)) continue for a in attrs: try: if transformsOnly is not None and transformsOnly: if ATTR.get_nameLong(obj,a) not in l_trans: continue dVal = d_defaults.get(a) if dVal is not None: default = dVal else: default = mc.attributeQuery(a, listDefault=True, node=obj)[0] ATTR.set(obj,a,default) _reset[a] = default except Exception,err: log.error("{0}.{1} resetAttrs | error: {2}".format(obj, a,err))
def ik_base(self,ikBase = None, ml_baseJoints = None, ml_fkShapes = None): try: _str_func = 'segment_handles' log_start(_str_func) mBlock = self.mBlock mRigNull = self.mRigNull _offset = self.v_offset _jointOrientation = self.d_orientation['str'] ml_formHandles = self.ml_formHandles if ikBase == None: ikBase = mBlock.getEnumValueString('ikBase') if not ml_baseJoints: raise ValueError,"{0} | ml_baseJoints required".format(_str_func) log.debug("|{0}| >> {1} ...".format(_str_func,ikBase)) if ikBase in ['hips','simple']: if ikBase == 'hips': mIKBaseCrv = ml_baseJoints[1].doCreateAt(setClass=True) mIKBaseCrv.doCopyNameTagsFromObject(ml_baseJoints[0].mNode,ignore=['cgmType']) mIKBaseCrv.doStore('cgmName','hips') else: mIKBaseCrv = ml_baseJoints[0].doCreateAt(setClass=True) mIKBaseCrv.doCopyNameTagsFromObject(ml_baseJoints[0].mNode,ignore=['cgmType']) CORERIG.shapeParent_in_place(mIKBaseCrv.mNode, ml_fkShapes[0].mNode, True) else: log.debug("|{0}| >> default IK base shape...".format(_str_func)) mIK_formHandle = ml_formHandles[ 0 ] #bb_ik = mHandleFactory.get_axisBox_size(mIK_formHandle.mNode) bb_ik = POS.get_bb_size(mIK_formHandle.mNode,True,mode='max') _ik_shape = CURVES.create_fromName('cube', size = bb_ik) ATTR.set(_ik_shape,'scale', 1.1) mIKBaseShape = cgmMeta.validateObjArg(_ik_shape, 'cgmObject',setClass=True) mIKBaseShape.doSnapTo(mIK_formHandle) #pos_ik = POS.get_bb_center(mProxyHelper.mNode) #SNAPCALLS.get_special_pos(mEndHandle.p_nameLong, # 'axisBox','z+',False) #mIKBaseShape.p_position = pos_ik mIKBaseCrv = ml_baseJoints[0].doCreateAt() mIKBaseCrv.doCopyNameTagsFromObject(ml_baseJoints[0].mNode,ignore=['cgmType']) CORERIG.shapeParent_in_place(mIKBaseCrv.mNode, mIKBaseShape.mNode, False) mIKBaseCrv.doStore('cgmTypeModifier','ikBase') mIKBaseCrv.doName() self.mHandleFactory.color(mIKBaseCrv.mNode, controlType = 'main') self.mRigNull.connectChildNode(mIKBaseCrv,'controlIKBase','rigNull')#Connect except Exception,err:cgmGEN.cgmExceptCB(Exception,err,localDat=vars())
def define(self): _short = self.mNode ATTR.set(_short, 'translate', [0, 0, 0]) ATTR.set(_short, 'rotate', [0, 0, 0]) ATTR.set_standardFlags(self.mNode, attrs=['translate', 'rotate', 'sx', 'sz']) for a in ['x', 'z']: ATTR.connect("{0}.sy".format(_short), "{0}.s{1}".format(_short, a)) ATTR.set_alias(_short, 'sy', 'blockScale')
def copy_constraint(sourceConstraint=None, targetObj=None, constraintType=None, maintainOffset=True): """ Copy the constraint settings from a constraint to another object :parameters: node(str): node to query :returns list of constraints(list) """ _str_func = 'copy_constraint' log.debug("|{0}| >> constraint: {1} ".format(_str_func, sourceConstraint)) d_source = get_datDict(sourceConstraint) _type = d_source['type'] if constraintType is None: if targetObj is None: raise ValueError, "|{0}| >> Must have targetObject or constraintType ".format( _str_func) else: log.info( "|{0}| >> No constraintType passed. Using source's: '{1}' ". format(_str_func, _type)) constraintType = _type _call = _d_type_to_call.get(constraintType, False) if not _call: raise ValueError, "|{0}| >> {1} not a known type of constraint. node: {2}".format( _str_func, _type, sourceConstraint) if targetObj is None: targetObj = d_source['driven'] log.info( "|{0}| >> No target object passed. Using source's: '{1}' ".format( _str_func, targetObj)) cgmGEN.func_snapShot(vars()) result = _call(d_source['targets'], targetObj, maintainOffset=maintainOffset) d_result = get_datDict(result[0]) for i, a in enumerate(d_result['attrs']): if d_source['attrDrivers'][i]: ATTR.connect("{0}".format(d_source['attrDrivers'][i]), "{0}.{1}".format(result[0], d_result['attrs'][i])) else: ATTR.set(result[0], d_result['attrs'][i], d_source['attrWeights'][d_source['attrs'][i]]) return result
def setup_forCapture(state = 1): mel.eval('PreferencesWindow;') mel.eval('preferencesWnd "Display";') if state: mel.eval('ActivateViewport20;') else: mel.eval('setRendererInModelPanel base_OpenGL_Renderer modelPanel4;') ATTR.set('hardwareRenderingGlobals.lineAAEnable',state) ATTR.set('hardwareRenderingGlobals.multiSampleEnable',state) if state: mel.eval('updateLineWidth 2;') else: mel.eval('updateLineWidth 1;')
def scale_to_axisSize(arg=None, size=None): _str_func = 'scale_to_axisSize' log.debug(cgmGEN.logString_start(_str_func)) _currentSize = get_axisSize(arg) _currentScale = ATTR.get(arg, 'scale') _targetScale = [] for i, s in enumerate(size): if s is not None: v = (_currentScale[i] * s) / _currentSize[i] _targetScale.append(v) else: _targetScale.append(_currentScale[i]) #log.info(_targetScale) for i, a in enumerate('xyz'): if size[i]: ATTR.set(arg, 's{0}'.format(a), _targetScale[i])
def verify_aimAttrs(obj=None, aim=None, up=None, checkOnly=False): """ Make sure an object has aim attributes. :parameters: obj(str): Object to modify aim(arg): Value to set with on call up(arg): Value to set with on call out(arg): Value to set with on call checkOnly(bool): Check only, no adding attrs :returns success(bool) """ _str_func = 'verify_aimAttrs' _str_enum = 'x+:y+:z+:x-:y-:z-' _obj = VALID.objString(obj, noneValid=False, calledFrom=__name__ + _str_func + ">> validate obj") _l = [aim, up] _l_defaults = [aim or 2, up or 1] for i, a in enumerate(['axisAim', 'axisUp']): _d = ATTR.validate_arg(_obj, a) _good = False if mc.objExists(_d['combined']): if ATTR.get_type(_d) == 'enum': if ATTR.get_enum(_d) == _str_enum: _good = True if not _good: if checkOnly: return False log.debug("|{0}| >> {1} not a good attr. Must rebuild".format( _str_func, _d['combined'])) ATTR.delete(_d) ATTR.add(_d, 'enum', enumOptions=_str_enum, hidden=False) ATTR.set(_d, value=_l_defaults[i]) ATTR.set_keyable(_d, False) _v = _l[i] if _v is not None: ATTR.set(_d, value=_v) return True
def radius_modify(self, mode='+', factor=10): _str_func = 'radius_modify' _sel = MMCONTEXT.get_list(self.var_contextTD.value, 'joint') if not _sel: return log.error("|{0}| >> Nothing selected".format(_str_func)) for j in _sel: _r = ATTR.get(j, 'radius') if mode == '+': _r = _r + factor elif mode == '-': _r = _r - factor elif mode == '*': _r = _r * factor elif mode == '/': _r = _r / factor ATTR.set(j, 'radius', _r)
def shaderDat_set(dat={}, key=None, nodes=[]): _d = dat.get(key, False) if not _d: return False if not nodes: nodes = mc.ls(sl=1) _res = {} mNodes = cgmMeta.asMeta(nodes) for node in nodes: for a, v in _d.iteritems(): if a in ['color']: continue log.info(node) try: log.info('{0} --> {1}'.format(a, v)) ATTR.set(node, a, v) except Exception, err: log.error("{0} | {1}".format(node, err))
def modules_settings_set(self, **kws): try: _str_func = ' modules_settings_set'.format(self) log.debug("|{0}| >> ... [{1}]".format(_str_func, self) + '-' * 80) for mModule in modules_get(self): if mModule.rigNull.getMessage('settings'): mSettings = mModule.rigNull.settings _short_settings = mSettings.mNode for k, v in kws.iteritems(): try: ATTR.set(_short_settings, k, v) except Exception, err: #if mSettings.hasAttr(k): log.debug( "|{0}| >> Failed to set: mModule:{1} | k:{2} | v:{3} | {4}" .format(_str_func, mModule.mNode, k, v, err)) else: log.debug("|{0}| >> Missing settings: {1}".format( _str_func, mModule)) return True
def scaleLocal_set(node=None, new_scale = [1,1,1]): """ Set the local scale of a given obj :parameters: node(str): node to query new_scale(double3): Value to set. May be Euclid.Vector3 :returns rotation(vector/asEuclid.Vector3) """ _str_func = 'scaleLocal_set' _node = VALID.mNodeString(node) try:new_scale = VALID.euclidVector3List(new_scale) except:pass log.debug("|{0}| >> [{2}] = {1}".format(_str_func,new_scale,_node)) ATTR.set(_node,'scale',new_scale)
def rotate_set(node=None, new_rot = None): """ Set the local rotation/euler of a given obj :parameters: node(str): node to query new_rot(double3): Value to set. May be Euclid.Vector3 :returns rotation(vector/asEuclid.Vector3) """ _str_func = 'rotate_set' _node = VALID.mNodeString(node) try:new_rot = VALID.euclidVector3List(new_rot) except:pass log.debug("|{0}| >> [{2}] = {1}".format(_str_func,new_rot,_node)) ATTR.set(_node,'rotate',new_rot)
def set_weightsByDistance(constraint=None, vList=None): """ :parameters: node(str): node to query :returns list of constraints(list) """ _str_func = 'set_weightsByDistance' log.debug("|{0}| >> constraint: {1} ".format(_str_func, constraint)) #if vList: #raise NotImplementedError,'Not yet' _attrs = get_targetWeightsAttrs(constraint) if not vList: pos_obj = TRANS.position_get(get_driven(constraint)) targets = get_targets(constraint) _l_dist = [] for t in targets: _l_dist.append( DIST.get_distance_between_points(pos_obj, TRANS.position_get(t))) vList = MATH.normalizeList(_l_dist) log.debug("|{0}| >> targets: {1} ".format(_str_func, targets)) log.debug("|{0}| >> raw: {1} ".format(_str_func, _l_dist)) log.debug("|{0}| >> normalize: {1} ".format(_str_func, vList)) log.debug("|{0}| >> attrs: {1} ".format(_str_func, _attrs)) if len(_attrs) != len(vList): raise ValueError, "Len of attrs and valueList do not match: {0} | {1}".format( len(_attrs), len(vList)) for i, v in enumerate(vList): ATTR.set(constraint, _attrs[i], v) return vList
def patch_templateToForm(): try: _str_func = 'patch_templateToForm' log.debug(cgmGEN.logString_start(_str_func)) _l = mc.ls() _progressBar = CGMUI.doStartMayaProgressBar(stepMaxValue=len(_l)) for i, o in enumerate(_l): _str = "{0} | {1} ".format(i, o) log.debug(cgmGEN.logString_sub(_str_func, _str)) CGMUI.progressBar_set(_progressBar, step=1, status=_str) mObj = cgmMeta.asMeta(o) for a in mc.listAttr(o, ud=True) or []: log.debug(cgmGEN.logString_msg(_str_func, str(a))) if 'template' in a: log.info( cgmGEN.logString_msg( _str_func, "{0} | {1} | template in".format(_str, a))) ATTR.rename(o, a, a.replace('template', 'form')) elif 'Template' in a: log.info( cgmGEN.logString_msg( _str_func, "{0} | {1} | Template in".format(_str, a))) ATTR.rename(o, a, a.replace('Template', 'Form')) v = ATTR.get(o, a) if 'template' == str(v): log.info( cgmGEN.logString_msg( _str_func, "{0} | {1} | template value".format(_str, str(a)))) ATTR.set(o, a, 'form') except Exception, err: cgmGEN.cgmExceptCB(Exception, err)
def get_HSV_fromRGB(rValue=0, gValue=0, bValue=0, getNode=False): _node = mc.createNode('rgbToHsv') ATTR.set(_node, 'inRgbR', COREMATH.Clamp(float(rValue), 0, 1.0)) ATTR.set(_node, 'inRgbG', COREMATH.Clamp(float(gValue), 0, 1.0)) ATTR.set(_node, 'inRgbB', COREMATH.Clamp(float(bValue), 0, 1.0)) res = ATTR.get(_node, 'outHsv')[0] if getNode: return _node, res mc.delete(_node) return res
def get_RGB_fromHSV(rValue=0, gValue=0, bValue=0, getNode=False): _node = mc.createNode('hsvToRgb') ATTR.set(_node, 'inHsvB', COREMATH.Clamp(float(bValue), 0.0001, 1.0)) ATTR.set(_node, 'inHsvG', COREMATH.Clamp(float(gValue), 0.0001, 1.0)) ATTR.set(_node, 'inHsvR', COREMATH.Clamp(float(rValue), 0.000001, 360.0)) res = ATTR.get(_node, 'outRgb')[0] if getNode: return _node, res mc.delete(_node) return res
def optimize(nodeTypes='multiplyDivide'): _str_func = 'optimize' log.debug("|{0}| >> ".format(_str_func) + '-' * 80) _nodeTypes = VALID.listArg(nodeTypes) d_modeToNodes = {} d_modeToPlugs = {} l_oldNodes = [] for t in _nodeTypes: if t in ['plusMinusAverage']: raise ValueError, "Don't handle type: {0}".format(t) nodes = mc.ls(type=t) l_oldNodes.extend(nodes) for n in nodes: _mode = ATTR.get(n, 'operation') _operator = ATTR.get_enumValueString(n, 'operation') #d_operator_to_NodeType[t][_mode] if not d_modeToNodes.get(_mode): d_modeToNodes[_mode] = [] d_modeToNodes[_mode].append(n) d_plugs = {} d_plugValues = {} for i, inPlug in enumerate(d_node_to_input[t]['in']): d_plugs[i] = ATTR.get_children(n, inPlug) or [] for p in d_plugs[i]: c = ATTR.get_driver(n, p, False, skipConversionNodes=True) if c: d_plugValues[p] = c else: d_plugValues[p] = ATTR.get(n, p) l_outs = ATTR.get_children(n, d_node_to_input[t]['out']) or [] for p in l_outs: d_plugValues[p] = ATTR.get_driven(n, p, False, skipConversionNodes=True) #pprint.pprint(d_modeToNodes) #pprint.pprint(d_plugs) #print l_outs #print cgmGeneral._str_subLine #pprint.pprint(d_plugValues) for i in range(len(l_outs)): _out = d_plugValues[l_outs[i]] if _out: d_set = {'out': _out, 'in': []} log.debug("|{0}| >> Output found on: {1} ".format( _str_func, _out)) _keys = d_plugs.keys() _keys.sort() for k in _keys: d_set['in'].append(d_plugValues[d_plugs[k][i]]) #d_set['in'].append(d_plugs[k][i]) #pprint.pprint(d_set) if not d_modeToPlugs.get(_mode): d_modeToPlugs[_mode] = [] d_modeToPlugs[_mode].append(d_set) # if VALID.stringArg() l_inPlugs = ['input1', 'input2'] l_outplugs = [u'output'] l_new = [] _cnt = 0 for operator, d_sets in d_modeToPlugs.iteritems(): if operator == 1: for nodeSet in d_sets: newNode = mc.createNode('multDoubleLinear') newNode = mc.rename(newNode, 'optimize_{0}_mdNode'.format(_cnt)) _cnt += 1 l_new.append(newNode) _ins = d_set['in'] _outs = d_set['out'] for iii, inPlug in enumerate(_ins): if mc.objExists(inPlug): ATTR.connect(inPlug, "{0}.{1}".format(newNode, l_inPlugs[iii])) else: ATTR.set(newNode, l_inPlugs[iii], inPlug) for out in _outs: ATTR.connect("{0}.output".format(newNode), out) #pprint.pprint(d_setsSorted) print len(d_sets) #print len(d_setsSorted) """ l_inPlugs = {0: [u'input1X', u'input1Y', u'input1Z'], 1: [u'input2X', u'input2Y', u'input2Z']} l_outplugs = [u'outputX', u'outputY', u'outputZ'] for operator,d_sets in d_modeToPlugs.iteritems(): d_setsSorted = LISTS. get_chunks(d_sets,3) for nodeSet in d_setsSorted: newNode = mc.createNode('multiplyDivide') newNode = mc.rename(newNode,'optimize_{0}_mdNode'.format(_cnt)) _cnt+=1 l_new.append(newNode) ATTR.set(newNode,'operation',operator) for i,d_set in enumerate(nodeSet): _ins = d_set['in'] _outs = d_set['out'] for iii,inPlug in enumerate(_ins): if mc.objExists(inPlug): ATTR.connect(inPlug, "{0}.{1}".format(newNode, l_inPlugs[iii][i])) else: ATTR.set(newNode,l_inPlugs[iii][i], inPlug) for out in _outs: ATTR.connect("{0}.{1}".format(newNode, l_outplugs[i]), out) #pprint.pprint(d_setsSorted) print len(d_sets) print len(d_setsSorted) """ mc.delete(l_oldNodes) return len(l_new)
def get_closest_point(source=None, targetSurface=None, loc=False): """ Get the closest point on a target surface/curve/mesh to a given point or object. Evaluates to all sub shapes to get closest point for multi shape targets. :parameters: source(str/vector) -- source point or object targetSurface -- surface to check transform, nurbsSurface, curve, mesh supported loc -- whether to loc point found :returns position, distance, shape (list) """ _str_func = 'get_closest_point' _point = False if VALID.vectorArg(source) is not False: _point = source elif mc.objExists(source): _point = POS.get(source) if not _point: raise ValueError, "Must have point of reference" _loc = mc.spaceLocator(n='get_closest_point_loc')[0] POS.set(_loc, _point) if SEARCH.is_shape(targetSurface): _shapes = [targetSurface] elif VALID.is_component(targetSurface): _shapes = mc.listRelatives(VALID.get_component(targetSurface)[1], s=True, fullPath=True) else: _shapes = mc.listRelatives(targetSurface, s=True, fullPath=True) if not _shapes: log.error("|{0}| >> No shapes found. Skipping: {1}".format( _str_func, targetSurface)) mc.delete(_loc) return False _l_res_positions = [] _l_res_shapes = [] _l_res_distances = [] for s in _shapes: _type = VALID.get_mayaType(s) if _type not in ['mesh', 'nurbsSurface', 'nurbsCurve']: log.error( "|{0}| >> Unsupported target surface type. Skipping: {1} |{2} | {3}" .format(_str_func, s, _type)) _l_res_positions.append(False) continue if _type == 'mesh': _node = mc.createNode('closestPointOnMesh') ATTR.connect((_loc + '.translate'), (_node + '.inPosition')) ATTR.connect((s + '.worldMesh'), (_node + '.inMesh')) ATTR.connect((s + '.worldMatrix'), (_node + '.inputMatrix')) _pos = ATTR.get(_node, 'position') _tmpLoc = mc.spaceLocator(n='tmp')[0] ATTR.connect((_node + '.position'), (_tmpLoc + '.translate')) _l_res_positions.append(POS.get(_tmpLoc)) mc.delete(_node) mc.delete(_tmpLoc) elif _type == 'nurbsSurface': closestPointNode = mc.createNode('closestPointOnSurface') ATTR.set(closestPointNode, 'inPositionX', _point[0]) ATTR.set(closestPointNode, 'inPositionY', _point[1]) ATTR.set(closestPointNode, 'inPositionZ', _point[2]) ATTR.connect((s + '.worldSpace'), (closestPointNode + '.inputSurface')) _l_res_positions.append(ATTR.get(closestPointNode, 'position')) mc.delete(closestPointNode) elif _type == 'nurbsCurve': _node = mc.createNode('nearestPointOnCurve') p = [] distances = [] mc.connectAttr((_loc + '.translate'), (_node + '.inPosition')) mc.connectAttr((s + '.worldSpace'), (_node + '.inputCurve')) p = [ mc.getAttr(_node + '.positionX'), mc.getAttr(_node + '.positionY'), mc.getAttr(_node + '.positionZ') ] _l_res_positions.append(p) mc.delete(_node) mc.delete(_loc) if not _l_res_positions: raise ValueError, "No positions found" for p in _l_res_positions: if p: _l_res_distances.append(get_distance_between_points(_point, p)) else: _l_res_distances.append('no') closest = min(_l_res_distances) _idx = _l_res_distances.index(closest) _pos = _l_res_positions[_idx] if not _pos: return False #raise ValueError,"Failed to find point" if loc: _loc = mc.spaceLocator(n='get_closest_point_loc')[0] POS.set(_loc, _pos) return _pos, _l_res_distances[_idx], _shapes[_idx]
def snap(obj=None, targets=None, position=True, rotation=True, rotateAxis=False, rotateOrder=False, rotatePivot=False, scalePivot=False, objPivot='rp', objMode=None, objLoc=False, targetPivot='rp', targetMode=None, targetLoc=False, queryMode=False, space='w', mark=False, **kws): """ Core snap functionality. :parameters: obj(str): Object to modify target(str): Objects to snap to objPivot targetPivot objMode = targetMode position rotation rotateAxis rotateOrder scalePivot space mark :returns success(bool) """ try: _str_func = 'snap' try: obj = obj.mNode except: pass _obj = VALID.mNodeString(obj) if targets is None: log.debug("|{0}| >> self target... ".format(_str_func)) _targets = [_obj] else: _targets = VALID.mNodeStringList(targets) reload(VALID) _pivotObj = VALID.kw_fromDict(objPivot, SHARED._d_pivotArgs, noneValid=True) _pivotTar = VALID.kw_fromDict(targetPivot, SHARED._d_pivotArgs, noneValid=True) _space = VALID.kw_fromDict(space, SHARED._d_spaceArgs, noneValid=False, calledFrom=__name__ + _str_func + ">> validate space") log.debug( "|{0}| >> obj: {1}({2}-{3}) | target:({4}-{5})({6}) | space: {7}". format(_str_func, _obj, _pivotObj, objMode, _pivotTar, targetMode, _targets, _space)) log.debug( "|{0}| >> position: {1} | rotation:{2} | rotateAxis: {3} | rotateOrder: {4}" .format(_str_func, position, rotation, rotateAxis, rotateOrder)) kws_xform = {'ws': False, 'os': False} if _space == 'world': kws_xform['ws'] = True else: kws_xform['os'] = True #Mode type defaults... if objMode is None: if _pivotObj is 'boundingBox': objMode = 'center' elif _pivotObj in ['castCenter', 'castFar', 'castNear', 'axisBox']: objMode = 'z+' if targetMode is None: if _pivotTar is 'boundingBox': targetMode = 'center' elif _pivotTar in ['castCenter', 'castFar', 'castNear', 'axisBox']: targetMode = 'z+' if _pivotTar in ['castFar', 'castAllFar', 'castNear', 'castAllNear']: if targetMode == 'center': log.debug( "|{0}| >> Center target mode invalid with {1}. Changing to 'z+' " .format(_str_func, _pivotTar)) targetMode = 'z+' #cgmGEN.func_snapShot(vars()) if position or objLoc or targetLoc or rotatePivot or scalePivot: kws_xform_move = copy.copy(kws_xform) if _pivotTar == 'sp': kws_xform_move['spr'] = True else: kws_xform_move['rpr'] = True #>>>Target pos ------------------------------------------------------------------------------ log.debug( "|{0}| >> Position True. Getting target pivot pos {1} ".format( _str_func, _pivotTar)) l_nameBuild = [ '_'.join([NAMES.get_base(o) for o in _targets]), _pivotTar ] if targetMode and _pivotTar not in [ 'sp', 'rp', 'closestPoint', 'groundPos' ]: l_nameBuild.append(targetMode) l_pos = [] if _pivotTar in ['sp', 'rp']: log.debug("|{0}| >> xform query... ".format(_str_func)) for t in _targets: l_pos.append(POS.get(t, _pivotTar, _space)) pos_target = DIST.get_average_position(l_pos) elif _pivotTar == 'closestPoint': log.debug("|{0}|...closestPoint...".format(_str_func)) pos_target = DIST.get_by_dist(_obj, _targets, resMode='pointOnSurface') else: log.debug("|{0}| >> special query... ".format(_str_func)) _targetsSpecial = copy.copy(_targets) if _pivotTar not in [ 'axisBox', 'groundPos', 'castCenter', 'boundingBox' ]: _targetsSpecial.insert(0, _obj) pos_target = get_special_pos(_targetsSpecial, _pivotTar, targetMode) if not pos_target: return log.error("No position detected") if targetLoc: _loc = mc.spaceLocator()[0] mc.move(pos_target[0], pos_target[1], pos_target[2], _loc, ws=True) mc.rename(_loc, '{0}_loc'.format('_'.join(l_nameBuild))) log.debug("|{0}| >> Target pivot: {1}".format( _str_func, pos_target)) #>>>Obj piv ------------------------------------------------------------------------------ log.debug("|{0}| >> Getting obj pivot pos {1} ".format( _str_func, _pivotObj)) l_nameBuild = [NAMES.get_base(_obj), _pivotObj] if objMode and _pivotObj not in [ 'sp', 'rp', 'closestPoint', 'groundPos' ]: l_nameBuild.append(objMode) l_pos = [] if _pivotObj in ['sp', 'rp']: log.debug("|{0}| >> xform query... ".format(_str_func)) pos_obj = POS.get(_obj, _pivotObj, _space) elif _pivotObj == 'closestPoint': log.debug("|{0}|...closestPoint...".format(_str_func)) pos_obj = DIST.get_by_dist(_targets[0], _obj, resMode='pointOnSurface') else: log.debug("|{0}| >> special query... ".format(_str_func)) pos_obj = get_special_pos(_obj, _pivotObj, objMode) if objLoc: _loc = mc.spaceLocator()[0] mc.move(pos_obj[0], pos_obj[1], pos_obj[2], _loc, ws=True) mc.rename(_loc, '{0}_loc'.format('_'.join(l_nameBuild))) log.debug("|{0}| >> Obj pivot: {1}".format(_str_func, pos_obj)) if queryMode: pprint.pprint(vars()) log.warning("|{0}| >> Query mode. No snap".format(_str_func)) mc.select([_obj] + _targets) return True #>>>Obj piv ------------------------------------------------------------------------------ if position: log.debug("|{0}| >> Positioning... ".format(_str_func)) if _pivotObj == 'rp': TRANS.position_set(obj, pos_target) #POS.set(_obj, pos_target) else: p_start = TRANS.position_get(_obj) _vector_to_objPivot = COREMATH.get_vector_of_two_points( p_start, pos_obj) _dist_base = DIST.get_distance_between_points( p_start, pos_obj) #...get our base distance p_result = DIST.get_pos_by_vec_dist( pos_target, _vector_to_objPivot, -_dist_base) cgmGEN.func_snapShot(vars()) POS.set(_obj, p_result) if rotateAxis: log.debug("|{0}|...rotateAxis...".format(_str_func)) mc.xform(obj, ra=mc.xform(_targets[0], q=True, ra=True, **kws_xform), p=True, **kws_xform) if rotateOrder: log.debug("|{0}|...rotateOrder...".format(_str_func)) mc.xform(obj, roo=mc.xform(_targets[0], q=True, roo=True), p=True) if rotation: log.debug("|{0}|...rotation...".format(_str_func)) _t_ro = ATTR.get_enumValueString(_targets[0], 'rotateOrder') _obj_ro = ATTR.get_enumValueString(obj, 'rotateOrder') if _t_ro != _obj_ro: #Creating a loc to get our target space rotateOrder into new space log.debug( "|{0}|...rotateOrders don't match...".format(_str_func)) _loc = mc.spaceLocator(n='tmp_roTranslation')[0] ATTR.set(_loc, 'rotateOrder', _t_ro) rot = mc.xform(_targets[0], q=True, ro=True, **kws_xform) mc.xform(_loc, ro=rot, **kws_xform) mc.xform(_loc, roo=_obj_ro, p=True) rot = mc.xform(_loc, q=True, ro=True, **kws_xform) mc.delete(_loc) else: rot = mc.xform(_targets[0], q=True, ro=True, **kws_xform) mc.xform(_obj, ro=rot, **kws_xform) if rotatePivot: log.debug("|{0}|...rotatePivot...".format(_str_func)) mc.xform(obj, rp=pos_target, p=True, **kws_xform) if scalePivot: log.debug("|{0}|...scalePivot...".format(_str_func)) mc.xform(obj, sp=pos_target, p=True, **kws_xform) except Exception, err: cgmGEN.cgmExceptCB(Exception, err)
def orientByPlane(joints = None, axisAim = 'z+', axisUp = 'y+', worldUpAxis = [0,1,0], planarMode = 'up', relativeOrient = True, progressBar=None, baseName = None, cleanUp = True, asMeta = True): """ Given a chain of joints, setup :parameters: planarMode - up/out - What plane to use :returns created(list) """ _str_func = 'orientPlane' ml_joints = cgmMeta.validateObjListArg(joints,mayaType=['joint'],noneValid=False) ml_joints = LISTS.get_noDuplicates(ml_joints) mAxis_aim = VALID.simpleAxis(axisAim) mAxis_up = VALID.simpleAxis(axisUp) str_aim = mAxis_aim.p_string str_up = mAxis_up.p_string ml_delete = [] if str_aim == str_up: raise ValueError,"axisAim and axisUp cannot be the same" if len(ml_joints) < 3: raise ValueError,"{0} > Need more than 3 joints".format(_str_func) #First setup a dup chain of first and end, orient those ---------------------------------------------------------------- log.debug("|{0}| >> Setup tmp chain...".format(_str_func)) mStart = ml_joints[0].doDuplicate(parentOnly = True) mEnd = ml_joints[-1].doDuplicate(parentOnly = True) mEnd.parent = mStart orientChain([mStart,mEnd], axisAim, axisUp, worldUpAxis, relativeOrient) #Setup Loft curves and plane ---------------------------------------------------------------- log.debug("|{0}| >> Setup curves...".format(_str_func)) if planarMode == 'up': crvUp = mAxis_up.p_string crvDn = mAxis_up.inverse.p_string else: for a in 'xyz': if a not in str_aim and a not in str_up: mAxisCrv_tmp = VALID.simpleAxis(a+'+') crvUp = mAxisCrv_tmp.p_string crvDn = mAxisCrv_tmp.inverse.p_string d_distance = DIST.get_distance_between_targets([mStart.mNode,mEnd.mNode]) l_crvs = [] for mObj in [mStart,mEnd]: crv = mc.curve (d=1, ep = [DIST.get_pos_by_axis_dist(mObj.mNode, crvUp, d_distance), DIST.get_pos_by_axis_dist(mObj.mNode, crvDn, d_distance)], os=True) log.debug("|{0}| >> Created: {1}".format(_str_func,crv)) l_crvs.append(crv) _res_body = mc.loft(l_crvs, o = True, d = 1, po = 1 ) _inputs = mc.listHistory(_res_body[0],pruneDagObjects=True) _tessellate = _inputs[0] _d = {'format':2,#General 'polygonType':1,#'quads' } for a,v in _d.iteritems(): ATTR.set(_tessellate,a,v) #Snap our joints --------------------------------------------------------------------------------- for mJnt in ml_joints[1:-1]: ml_children = mJnt.getChildren(asMeta=True) for mChild in ml_children: mChild.parent = False SNAP.go(mJnt, _res_body[0], rotation=False, pivot='closestPoint') for mChild in ml_children: mChild.parent = mJnt #Cleanup -------------------------------------------------------------------------------------------- if cleanUp: mc.delete(_res_body + l_crvs) mStart.delete() orientChain(ml_joints, axisAim, axisUp, worldUpAxis, relativeOrient,progressBar) return l_start = [] l_end = [] mStartCrv = mc.curve() mc.curve (d=1, ep = posList, os=True)