as_HyperSkin#

as_HyperSkin.__aboutHyperSkin(self)#
as_HyperSkin.__confirmAction(self, action)#
try:

deleteUI (‘as_HyperSkinWin’)

except:

pass

as_HyperSkin.__init__(self, filePath=None)#

“Advanced Hyper Skinning” based on “Art & Technology” Combination

as_HyperSkinMain_v3.0

About :#

Author: (Subbaiah) Subbu Addanki Character Supervisor (Rigging) & Programmer

Contact :#

Mail Id: subbu.add@gmail.com

as_HyperSkin._check4Author(self)#
as_HyperSkin._compileAHSS(self, userFolder='$_Free_AHSS_v3.5')#
as_HyperSkin._createVtxSet_Solved(self)#
as_HyperSkin._isInTime(self, startDate=[2017, 1, 1], endDate=[2018, 1, 1], onlineTime=1, showDaysLeft=1, bufferTime=1)#
as_HyperSkin._isNum(self, obj)#
as_HyperSkin._isPosList(self, posList)#

if posList == [1, 3, 10.5] | [0.1, 10, 9.5] | [0, 0, 0] | (0, 10, 5): return True else: return False

as_HyperSkin._mayaVer(self)#
as_HyperSkin._selectEndVertices_4Solving(self)#
as_HyperSkin._selectNearestFaces(self)#
as_HyperSkin._snap2NearestFaces(self)#
as_HyperSkin.addInfluences_skinClust(self, infList=None, skinMesh=None, useGeoInf=True, useProgress=1)#

Purpose:#

Adds given infList to given skinMesh

Args:#

infList =infList to be added to skinMesh skinMesh = infList[-1], if skinMesh not given useGeoInf = True | False (for ‘useGeometry’ arg)

Args (from selection):#

If both Args are not given:

infList =hsN._selected()[0:-1] skinMesh =hsN._selected()[-1]

as_HyperSkin.add_CharPrefix(self, txtFldName)#
as_HyperSkin.add_NoDiscAttrs(self)#
as_HyperSkin.add_Selection(self, textFld, multiSelect=False)#

Adds selected object’s name as Input in any Window for <== button Usage: —— obj10 # Adds ‘obj10’ While pressing Enter.. <== button box25 # Adds ‘box25’ While pressing Enter.. <== button

as_HyperSkin.add_SidePrefix(self, rePattern, txtFldName)#
as_HyperSkin.add_SkinMesh(self, textFld)#
as_HyperSkin.applyObjColor(self, ctrlList=None, colorNum=None, LPrefix=None, RPrefix=None, CPrefix=None, **shortArgs)#

Purpose : Changes control colors based on prefix, colorVal

Args: [**shortArgs : ctrlList =cl, colorNum =cn, LPrefix =lp, RPrefix =rp, CPrefix =cp]#

ctrlList : ctrl(str) | ctrlList(strList) #_ ctrlList =[ctrlList] if type(ctrlList) != list else ctrlList colorNum : colorVal(int) #_ if number of color is given, LPrefix and other Prefixes will be neglected LPrefix : [prefix(str), colorVal(int)] #_ Left side prefix and its value RPrefix : [prefix(str), colorVal(int)] #_ Right side prefix and its value CPrefix : [prefix(str), colorVal(int)] #_ Right side prefix and its value

Returns : None

as_HyperSkin.as_AboutHyperSkin(self)#
as_HyperSkin.as_BakeDeformers(self)#
as_HyperSkin.as_CreateGCMs(self)#
as_HyperSkin.as_DeleteGCMs(self)#
as_HyperSkin.as_DoReSkin(self)#
as_HyperSkin.as_EasySmooth(self, vtx=None)#
as_HyperSkin.as_Generate_HyperSkin(self)#
as_HyperSkin.as_Generate_HyperSkin_Disc(self)#
as_HyperSkin.as_Generate_HyperSkin_NoDisc(self)#
as_HyperSkin.as_Generate_HyperSmooth(self, smoothAll=False, vtxList=None, jntList=None, pruneWgts=True, skinSide=None, **shortArgs)#
as_HyperSkin.as_Generate_LipsSkin(self, jntList=None, vtxList=None, bodyMesh=None)#
as_HyperSkin.as_GetJntList_OutsideBB(self, skinMesh)#
as_HyperSkin.as_HyperSkin(self)#
as_HyperSkin.as_ImportSkinDeformer(self)#
as_HyperSkin.as_LockJoints(self, jntList=None, skinMesh=None, lockAll=0, unlockAll=0, invLock=1)#
as_HyperSkin.as_MakeVisibleGCM(self, endSuffix, makeVis=True)#
as_HyperSkin.as_MirrorGCMs(self)#
as_HyperSkin.as_MirrorSelectedGCMs(self)#
as_HyperSkin.as_PruneOppJntWeights(self)#
as_HyperSkin.as_ReplaceGCMs(self, snapRot=True)#
as_HyperSkin.as_ToggleInMesh(self, endSuffix)#
as_HyperSkin.as_ToggleSkinJnts(self)#
as_HyperSkin.as_ToggleSkinMesh(self)#
as_HyperSkin.as_UpdateGCMs(self)#
as_HyperSkin.as_VisitBlog(self)#
as_HyperSkin.as_VisitPythonScripting(self)#
as_HyperSkin.averageSelectedVtx(self)#
as_HyperSkin.averageVtxWeight(self, vtxName, skinMesh, skinClust, allJntList)#
as_HyperSkin.centerPiv(self, objName)#
as_HyperSkin.changeOptions_AdvancedGCMs(self)#
as_HyperSkin.checkInAHSSUsers(self)#
as_HyperSkin.checkPosIn_BB(self, pos, bbObj)#
as_HyperSkin.computeTime(self, killTime=False, processName=None, runCompute=True)#

Returns:#

[[progressHour, progressMinute, progressSecond], ‘%dHr %dMin %dSec’ % (progressHour, progressMinute, progressSecond)]

For Ex, Returns: [[0, 10, 25], ‘0Hr 10Min 25Sec’]

as_HyperSkin.confirmAction(self, action, raiseErr=False, trueVal='Yes', falseVal='No', ex1Btn=None, ex1Action=None, **shortArgs)#

Requests User to confirm an action shown in confirmDialog window

as_HyperSkin.confirmSkinMesh(self, skinMesh=None)#

return [skinMesh, skinClust[0]]

as_HyperSkin.create_PolyDisc(self, discName, cRadius, jntAxis=None, hideGuides=False, deleteInnerGuide=False)#
as_HyperSkin.dafaultSkin(self)#
as_HyperSkin.deleteEdgeLoops(self)#
as_HyperSkin.deleteUnwanted(self)#
as_HyperSkin.endProgressWin(self, numItems=None, stopProgress=False, useProgress=1, **shArgs)#
as_HyperSkin.error(self, errorMsg)#

Sends a given error message through confirmDialog window. After closing the window, RuntimeError will be raised

as_HyperSkin.executeFile(self, filePath, fileName=None)#
as_HyperSkin.expandSkinArea(self, vtxList, valList, infName, skinClust=None, smoothCount=1, prevVtxList=None, **shortArgs)#
as_HyperSkin.exportAttributes(self, objList, attrList, filePath, fileName=None)#
as_HyperSkin.exportAttrs_DSCs(self)#
as_HyperSkin.exportBlendWeights(self, skinMesh=None, filePath=None, fileName=None)#
as_HyperSkin.exportDSCs_2File(self)#
as_HyperSkin.exportSkinDeformer(self, filePath, meshList)#
as_HyperSkin.exportSkinWeights(self, vtxList=None, filePath=None, fileName=None, advExport=False)#
as_HyperSkin.exportSkinWeights2(self, vtxList=None, filePath=None, fileName=None)#
as_HyperSkin.exportSkinWeights_Deformer(self, fileName=None)#
as_HyperSkin.exportSkinWeights_Sides(self, vtxList=None, filePath=None, fileName=None)#
as_HyperSkin.export_DSCsOrAttrs(self)#
as_HyperSkin.extractNum(self, objName, fromEnd=True, skipCount=0)#

Returns:#

the extracted number from end of the object name

Usage:#

obj.vtx[105] # Returns 105 obj.e[206] # Returns 206

as_HyperSkin.generateCurv(self, curvName, deg=3, step=1, objOrPosList=None, showCVs=True)#
as_HyperSkin.getCVList(self, curv, get_asNodes=0, getEditPoints=0, **shArgs)#

Returns(asNodes):#

if self.isNodeType(‘nurbsCurve’):

return [cvList, numCVs]

elif self.isNodeType(‘mesh’):

return [vtxList, numVtx]

elif self.isNodeType(‘nurbsSurface’):

return [cvList, numCVs]

as_HyperSkin.getChild_DSC(self, obj)#

doc

as_HyperSkin.getClosestDist(self, vtxName, geoObj)#
as_HyperSkin.getClosestDist_Obj(self, vtxName, meshObj)#
as_HyperSkin.getClosestPos_Dir(self, posLoc, dirLoc, meshObj, giveLoc=True)#
as_HyperSkin.getDupeNode(self, srcNode, dupName, centerPiv=False, grpDupNode=False, grpLevel=1)#
as_HyperSkin.getFaceList(self, objName, sidePos=None, mirrAxis='x')#

Available sidePos : ‘L_’, ‘R_’

as_HyperSkin.getJntFromDisc(self)#
as_HyperSkin.getJntNum_fromEnd(self, jnt, jntCount=0, is_hsNode=0)#
as_HyperSkin.getLongestObj(self, src, objList, objType='obj')#
as_HyperSkin.getMBBox(self, bbObj)#
as_HyperSkin.getMPathDg(self, obj)#
as_HyperSkin.getMPoint(self, objOrPos)#
as_HyperSkin.getMeshFn(self, obj)#
as_HyperSkin.getMeshVtx(self, meshObj, sidePos=None, mirrAxis='x', includeMidVtx=True)#
as_HyperSkin.getMeshVtx_Overlap(self, outerMesh, innerMesh, checkType='in', inMeshDir='L_', outMeshDir='L_', outTolerance=None)#

Args: outerMesh = mesh placed outer side with respect to innerMesh [For Ex: part of pant on top of shoe] innerMesh = mesh placed inside with respect to outerMesh [For Ex: part of shoe inside the pant] checkType = ‘in’ or ‘In’ | ‘out’ or ‘Out’

[‘in’ –> innerMesh vertices (overlapped) will be returned] [‘out’ –> outerMesh vertices (overlapped) will be returned]

innerMeshDir = ‘L_’ | ‘R_’ | None outerMeshDir = ‘L_’ | ‘R_’ | None outTolerance = None | any number

as_HyperSkin.getNearestCurv(self, vtx, curvList)#
as_HyperSkin.getNearestGeo(self, vtx, geoList)#
as_HyperSkin.getNearestGeo_orig(self, vtx, geoList)#
as_HyperSkin.getNearestObj(self, srcObj, destList, srcType='obj', destType='obj', nearCount=1)#
as_HyperSkin.getPos(self, objList, objType='obj')#

Returns[list Of Poses]:#

List of Poses. get single pos with : HyperSkin.getPos(obj)[0] For Ex: [[0, 2, 1]] or [[0, 2, 1], [1, 0, 1], ..] etc

as_HyperSkin.getRootJnt_FromJntsList(self, jntList=None)#
as_HyperSkin.getRot(self, objList)#
as_HyperSkin.getSkinJnts(self, skinMesh, allInfs=False)#
as_HyperSkin.getSkinJntsList(self, vtxList)#
as_HyperSkin.getSkinWeights(self, vtxMesh, vtxName, skinClust, get_hsNodes=False)#
as_HyperSkin.getSolvedJntsNGCMs(self, skinJntList, nonSknEndJnts, gcmSuffix=None)#
as_HyperSkin.getVisVolume(self)#
as_HyperSkin.getVtxList(self, objName)#

Returns(hsNodes):#

if self.isNodeType(‘nurbsCurve’):

return cvList

elif self.isNodeType(‘mesh’):

return vtxList

elif self.isNodeType(‘nurbsSurface’):

return cvList

as_HyperSkin.get_2PosExtn(self, sel01, sel02, ratioAmount, locName='Extn_Loc', getLoc=True)#
as_HyperSkin.get_2PosVect(self, srcObj, destObj)#
as_HyperSkin.get_ClosestGeoLoc(self, loc, mesh, locName='Geo_Loc', giveLoc=True)#

Note: Mesh should be freezed for correct snapping

as_HyperSkin.get_GeoCentricLoc(self, baseLoc, baseGeo, giveLoc=True, gcmSuffix='_asSC1000GCM')#
as_HyperSkin.get_NormLoc(self, obj_Piv, obj_Vec1, obj_Vec2, locName='Norm_Loc', giveLoc=True)#
as_HyperSkin.grpIt(self, objName, grpLevel=1, snapPiv=True, grpSufxList=None)#

Returns:(hsNodes)#

if len(grpList) > 1:

return grpList # grp1, grp2, ….grpTop

else:

return grpList[0]

as_HyperSkin.hasMeshContainsPoint(self, checkMesh, checkPointOrObj, precision=5)#
as_HyperSkin.hideNodes(self, nodeList)#
class as_HyperSkin.hyperSkinDeformer(jointList=None, shape=None, skin=None, vtxList=None)#

Bases: object

__init__(jointList=None, shape=None, skin=None, vtxList=None)#
as_HyperSkin.importAttrs_DSCs(self)#
as_HyperSkin.importBlendWeights(self, skinMesh=None, filePath=None, fileName=None)#
as_HyperSkin.importDSCs_FromFile(self)#
as_HyperSkin.importSkinDeformer(self, fileName=None, filePath=None)#
as_HyperSkin.importSkinWeights(self, advImport=False)#
as_HyperSkin.importSkinWeights_Deformer(self, filePath=None, fileName=None, showMessage=True)#
as_HyperSkin.importSkinWeights_Sides(self, filePath=None, fileName=None, showMessage=True)#
as_HyperSkin.import_DSCsOrAttrs(self)#
as_HyperSkin.isIt_LastSkinJnt(self, jnt, skinJntList, numFromEnd=0, useSeries=False, hsNodes_given=False)#
as_HyperSkin.isJnt(self, obj)#
as_HyperSkin.isLastJnt(self, jnt, numFromEnd=0, childImplied=True)#
as_HyperSkin.isMesh(self, obj)#
as_HyperSkin.isSkinJnt(self, jnt, skinMesh)#
as_HyperSkin.isSkinned(self, obj)#
as_HyperSkin.isolateHyperDiscGrps(self)#
as_HyperSkin.mConstrain(self, objList, conList, offSet=True, wVal=1, **kwargs)#

Args:#

conList = ‘point’ | ‘orient’ | ‘parent’ | ‘scale’ | ‘geometry’ | ‘normal | ‘tangent’ | ‘aim’ | ‘poleVector’ |

aimConstrain Example:#

aimConstraint(worldUpType=”none”, aimVector=(0, 0, 1), upVector=(0, 1, 0), weight=1, offset=(0, 0, 0))

Returns:#

if len(conList) == 1 and len(objList) > 2:

return [conNode, conNode.getWeightAliasList()]

else:

return [conNode]

as_HyperSkin.mDistance(self, srcObj, destObj, srcType='obj', destType='obj', giveNode=False)#

Objective:#

To measure the distance between (two objects) or (two positions) or (one obj and one position or veceversa)

Return Stmnt:#

return [mDist, locList, distNode, distShape, distAttr] #_ If giveNode is True return [mDist] #_ If giveNode is False

as_HyperSkin.mFreeze(self, objName, t=1, r=1, s=1)#
as_HyperSkin.mapRange(self, inputVal, minIN, maxIN, minOUT, maxOUT)#

Now Supports inverted / reverse out put range where maxOUT is less than minOUT

Examples: Normal Range: ============= HyperSkin.mapRange(0.95, 0.90, 1.65, 0.50, 0.99) #_ [0.95, [0.90 -> 1.65], [0.50 -> 0.99]] HyperSkin.mapRange(0.95, 0.90, 1.65, 0.50, 0.99) # 0.5326 HyperSkin.mapRange(1.60, 0.90, 1.65, 0.50, 0.99) # 0.9573 HyperSkin.mapRange(inputVal=1.60, minIN=0.9, maxIN=1.65, minOUT=0.5, maxOUT=0.99)

Inverse In Range:#

HyperSkin.mapRange(0.95, 1.65, 0.90, 0.50, 0.99) # 0.9573 HyperSkin.mapRange(1.60, 1.65, 0.90, 0.50, 0.99) # 0.5326 HyperSkin.mapRange(inputVal=1.60, minIN=1.65, maxIN=0.90, minOUT=0.50, maxOUT=0.99)

Inverse Out Range:#

HyperSkin.mapRange(0.95, 0.90, 1.65, 0.99, 0.50) # 0.9573 HyperSkin.mapRange(1.60, 0.90, 1.65, 0.99, 0.50) # 0.5326 HyperSkin.mapRange(inputVal=0.95, minIN=0.90, maxIN=1.65, minOUT=0.99, maxOUT=0.5) HyperSkin.mapRange(inputVal=1.60, minIN=0.90, maxIN=1.65, minOUT=0.99, maxOUT=0.5)

Inverse In & Out Ranges:#

HyperSkin.mapRange(0.95, 1.65, 0.90, 0.99, 0.50) #_ 0.5326 HyperSkin.mapRange(1.60, 1.65, 0.90, 0.99, 0.50) #_ 0.9573

as_HyperSkin.message(self, messageTxt)#

Sends a given message through confirmDialog window

as_HyperSkin.mirrorSkin(self, LPrfx='L_', RPrfx='R_', left2right=True, dirAxis='x')#
as_HyperSkin.move2ClosestPoint(self, loc, mesh)#

Note: Mesh should be freezed for correct snapping

as_HyperSkin.name(self, mNode)#

Returns the name of the object from last the vertical bar ‘|’ i.e. Returns the name of obj excluding full path

as_HyperSkin.nearestVtxOnMesh_vtxList(self, srcObjOrPos='srcObjOrPos', trgtMesh='trgtMesh', excludeList=None, skipDir=None, precision=1, vtxList=None)#

Returns:#

return [hsNode(nVtx), int(nNum)]

as_HyperSkin.nearestVtx_OnMesh(self, srcObjOrPos='srcObjOrPos', trgtMesh='trgtMesh', excludeList=None, skipDir=None, precision=1)#

Returns:#

return [hsNode(nVtx), int(nNum)]

as_HyperSkin.old_extractNum(self, objName)#

Returns:#

the extracted number from end of the object name

Usage:#

obj.vtx[105] # Returns 105 obj.e[206] # Returns 206

as_HyperSkin.old_getMDagPath(self, obj)#
as_HyperSkin.old_getMPoint(self, obj)#
as_HyperSkin.old_progressWin(self, currentItem=None, endProgress=0, showProgressTime=1, useProgress=1, **shArgs)#
as_HyperSkin.old_startProgressWin(self, numObjs, winTitle='Please Wait ..!', progressNote='Progress : 0%', doInterrupt=True, useProgress=1, **shArgs)#
as_HyperSkin.openPythonScripting(self)#
as_HyperSkin.parentChild_ByImplied(self, chd=None, prnt=None, removeAttrs=False, dscChd=False, **shArgs)#

Usage:#

#_ Select child joint(implied) first and then parent joint (implied) HyperSkin.parentChild_ByImplied(hsN._selected()[0], hsN._selected()[1])

as_HyperSkin.progressReset(self)#
as_HyperSkin.progressWin(self, currentItem=None, endProgress=0, showProgressTime=0, innerObjs=False, innerList=None, refreshView=0, useProgress=1, outerList=None, **shArgs)#
as_HyperSkin.refreshView(self, num)#
as_HyperSkin.removeImpliedChild(self, jnt)#
as_HyperSkin.removeImpliedParent(self, jnt)#
as_HyperSkin.removeInfluences_skinClust(self, infList=None, skinMesh=None)#

Purpose:#

Adds given infList to given skinMesh

Args:#

infList =infList to be added to skinMesh skinMesh = infList[-1], if skinMesh not given useGeoInf = True | False (for ‘useGeometry’ arg)

Args (from selection):#

If both Args are not given:

infList =hsN._selected()[0:-1] skinMesh =hsN._selected()[-1]

as_HyperSkin.removeParentChild_ImpliedInfo(self, jntList=None)#
as_HyperSkin.resetSkinnedJoints(self, skinJnts=None)#

Reset skin deformation for selected joints

as_HyperSkin.restrictedZone_FreeTool(self)#
as_HyperSkin.scaleDisc_AfterImportAttrs(self, trgtMesh='body')#
as_HyperSkin.scaleTillInsideMesh(self, srcObj, cvList, trgtMesh, stepVal=0.01, scaleDir='y')#

HP.adjustTillInsideMesh(‘L_Palm_HndCtrl’, ‘L_Palm_Curve_5_HndCtrl’, ‘body’, stepVal=-0.001, action=’scale’)

as_HyperSkin.searchReplaceAll(self, objList, searchWord, replaceWord, topSelect=True, selectHI=True)#

Objective:#

Search and replaces the words under the given object

Return Stmnt:#

return allNodes #_ All nodes with replaced / renamed words under given obj.

as_HyperSkin.selectFromTF(self, textFld)#

Adds selected object’s name as Input in any Window for <== button Usage: —— obj10 # Adds ‘obj10’ While pressing Enter.. <== button box25 # Adds ‘box25’ While pressing Enter.. <== button

as_HyperSkin.selectHI(self, objName, objType='jnt', topSelect=True, includeShapes=False, childImplied=True)#

Objective:#

Selects all objects of given type under the given object

Returns:#

selected() #_ As per the objType

as_HyperSkin.selectLastSelectedVtx(self)#
as_HyperSkin.selectSkinJnts(self)#
as_HyperSkin.selectSkinVertices(self, sidePrefix=None)#
as_HyperSkin.setSkinWeights(self, vtxName, jntValDict, addInf=False, skinClust=None, keepLockState=False)#
as_HyperSkin.smoothEdgeLoops(self)#
as_HyperSkin.smoothNearest(self)#
as_HyperSkin.smoothSkinWeights(self, vtxListOrMesh=None, jntList=None, smoothCount=1, prefixSide=None, **shortArgs)#
as_HyperSkin.snapDisc2SkinMesh(self, jntDisc, skinMesh, snapRotateTo=None, refineDisc=False)#
as_HyperSkin.snapPiv_Obj(self, srcObj, destObj=[0, 0, 0])#
as_HyperSkin.snapRot(self, src, destObj, dirUpObj=None, aimAxis=[1, 0, 0], upAxis=[0, 1, 0])#

src = src or srcList | obj or objList

More features:#

Aim Constraint can be used while snapping rotaion of src

as_HyperSkin.snapTo_Obj(self, srcObjList, destObj=[0, 0, 0], snapRot=False)#

Args:#

srcObjList = srcObj | srcObjList (list of srcObjs) destObj = destObj | destPos[0, 1, 0]

if snapRot : Snaps srcObj’s rotation to destObj #_ destObj needs to be given

as_HyperSkin.snapTo_Vtx(self, srcList, vtx=[0, 0, 0])#

Args:#

srcList = srcObj | srcObjList (list of srcObjs)

as_HyperSkin.solveEndJnts(self)#
as_HyperSkin.sortByDict(self, dictName, sortType='up', returnType='keys')#

HyperSkin.sortedByDict({‘j1’:10, ‘j2’:2, ‘j3’:-1.0, ‘j4’:50.0, ‘j5’:0, ‘j6’:10}, ‘up’)

as_HyperSkin.startProgressWin(self, numObjs=0, winTitle=None, progressNote=None, doInterrupt=True, innerObjs=None, innerList=None, refreshView=0, useProgress=1, innerNote='Inner Progress', **shArgs)#

Usage (If inner loop exist): HyperSkin.startProgressWin(jntList_outer, ‘Solving Joints !!’, ‘Please Wait’, innerObjs=vtxList_someList)

HyperSkin.startProgressWin(innerList=vtxList_inner)

HyperSkin.progressWin(ci=vtx, innerList=vtxList_inner, ep=0, spt=__showProgressTime)

HyperSkin.progressWin(ci=jnt)

HyperSkin.endProgressWin(jntList, 1)

as_HyperSkin.startTime(self, runCompute=True)#

This function needs to be initiated to use ‘HyperSkin.computeTime()’

as_HyperSkin.test(self)#
as_HyperSkin.transferSkin(self, srcMesh_Or_VtxList=None, destMesh_Or_VtxList=None, removeSrcClust=False, removeDestClust=True, trgtPrfx=None)#

Alternative One which is tested and proven one srcMesh_Or_VtxList =selected()[0] destMesh_Or_VtxList =selected()[1]

Testing:#

HyperSkin.transferSkin(trgtPrfx=’Trgt_’)

as_HyperSkin.transferSkin_Jnt2Jnt(self, skinMesh=None, srcJnt=None, trgtJnt=None, trgtPrefix=None)#
as_HyperSkin.transferSkin_Jnts2Jnts(self, prefix=None, skinMesh=None, transferType=None, **shArgs)#

Useful for creating single hierarchy joint chain for MoCap purpose

as_HyperSkin.transferSkin_ManyToMany_Mesh(self, transferType=2, **shArgs)#
as_HyperSkin.transferSkin_ManyToOne_Mesh(self)#
as_HyperSkin.transferSkin_ManyVtx2ManyVtx(self)#
as_HyperSkin.transferSkin_Mesh2Mesh(self, fromMesh=None, toMesh=None, transferType=2, showProgress=False, **shArgs)#
as_HyperSkin.transferSkin_MeshToVtxList(self)#
as_HyperSkin.transferSkin_NearestJnts2Jnts(self, skinMeshes=None, trgtJnts=None, transferAll=False, **shArgs)#
Parameters:

  • self –

  • skinMeshes – Transfer skin for selected/ given skinMeshes

  • trgtJnts – Transfer skin for selected (non-skinned)/ given joints

  • transferAll – Transfer skin for selected number of non-skinned joints or for all skinned joints

Returns:

as_HyperSkin.transferSkin_OneToMany_Mesh(self, transferType=2, **shArgs)#
as_HyperSkin.transferSkin_Overlap(self, srcMesh=None, destMesh=None, transferType='I2O')#
as_HyperSkin.transferSkin_Vtx2ManyVtx(self)#
as_HyperSkin.transferSkin_Vtx2Vtx(self, src=None, dest=None)#
as_HyperSkin.transferSkin_VtxDist(self, skinObjs, distVal='BB')#
as_HyperSkin.transferSkinning(self, transferType=2, **shArgs)#
as_HyperSkin.transferUVs(self, srcMesh=None, trgtMesh=None, spaceVal=1, delHistory=True, getMatchPercent=0, bestMatch=0, deleteMap=False)#
as_HyperSkin.unfreezeRotation(self, objList, grpLevel, vtxNumOrObj, trgtType='vtx')#
as_HyperSkin.updateDSCs(self)#
as_HyperSkin.updateSkinWeights(self, filePath)#
as_HyperSkin.updateUI_Options(self)#
as_HyperSkin.updateVtxCount(self)#