MAYA绑定归档 - 喵喵动画屋

Maya Curve Rigger｜线条类道具一键绑定（Rope / Tail / Tentacle Rig）

喵喵动画屋 — Sun, 14 Dec 2025 15:39:19 +0000

import maya.cmds as cmds
import maya.mel as mel
import math
import sys
from maya.cmds import*
class Curve_Rigger:
    def __init__(self):
        print("请选择起始和结束定位器 / Select start and end locators")
        pass

    def FolRivet(self):
        sel=ls(sl=1)
        index=len(sel)
        shape=listRelatives(sel[-1],type='shape')[0]
        if objExists("Rivet_Fol_Group"):
            grp="Rivet_Fol_Group"
        else:
            grp=group(em=1,n="Rivet_Fol_Group")
        for i in range(0,index-1):
            loc=sel[i]
            decompNode=shadingNode('decomposeMatrix',au=1)
            if nodeType(shape)=='mesh':
                cposNode=shadingNode('closestPointOnMesh',au=1)
                connectAttr(shape+'.worldMatrix[0]',cposNode+'.inputMatrix')
                connectAttr(shape+'.outMesh',cposNode+'.inMesh')
            elif nodeType(shape)=='nurbsSurface':
                cposNode=shadingNode('closestPointOnSurface',au=1)
                connectAttr(shape+'.worldSpace',cposNode+'.inputSurface')
            connectAttr(loc+'.worldMatrix[0]',decompNode+'.inputMatrix')
            connectAttr(decompNode+'.outputTranslate',cposNode+'.inPosition')
            UVal=getAttr(cposNode+'.parameterU')
            VVal=getAttr(cposNode+'.parameterV')
            follicle_name = loc + "_fol"
            follicle_shape_name = follicle_name + "Shape"
            # 创建毛囊 / Create follicle
            follicle_shape = createNode("follicle", name=follicle_shape_name)
            follicle = listRelatives(follicle_shape, p=1)[0]
            rename(follicle,follicle_name)
            if nodeType(shape)=='mesh':
                connectAttr(shape + ".worldMesh[0]", follicle_shape + ".inputMesh")
                connectAttr(shape+'.worldMatrix[0]',follicle_shape+'.inputWorldMatrix')
            elif nodeType(shape)=='nurbsSurface':
                connectAttr(shape + ".local", follicle_shape + ".inputSurface")
                connectAttr(shape+'.worldMatrix[0]',follicle_shape+'.inputWorldMatrix')
            setAttr(follicle_shape+'.parameterU',UVal)
            setAttr(follicle_shape+'.parameterV',VVal)
            connectAttr(follicle_shape+'.outTranslate',follicle+'.t')
            connectAttr(follicle_shape+'.outRotate',follicle+'.r')
            parentConstraint(follicle,loc,mo=1)
            parent(follicle,grp)
            delete(cposNode,decompNode)
    def create_cylinder_with_locators(self,name, start_locator, end_locator, radius=0.5, divisions=20):
        # 获取定位器的位置 / Get the positions of the locators
        start_position = cmds.xform(start_locator, query=True, translation=True, worldSpace=True)
        end_position = cmds.xform(end_locator, query=True, translation=True, worldSpace=True)
    
        # 计算圆柱体的高度和方向向量 / Calculate the height and direction vector of the cylinder
        height = math.sqrt(sum((end - start) ** 2 for start, end in zip(start_position, end_position)))
        direction = [(end - start) / height for start, end in zip(start_position, end_position)]
    
        # 使用指定参数创建圆柱体 / Create a cylinder with the specified parameters
        cylinder = cmds.polyCylinder(n=name, radius=radius, height=height, subdivisionsY=divisions, axis=direction)[0]
    
        # 将圆柱体定位在两个定位器的中点 / Position the cylinder at the midpoint between the locators
        midpoint = [(start + end) / 2 for start, end in zip(start_position, end_position)]
        cmds.move(midpoint[0], midpoint[1], midpoint[2], cylinder)
    
        return cylinder
    
    def create_curve_from_objects(self,objects):
        store_positions = [cmds.xform(obj, query=True, worldSpace=True, translation=True) for obj in objects]
        degree = 3  # 如需更改度数请在此修改 / Change the degree here if needed
        
        build_curve = "curve -d {} ".format(degree)
        for pos in store_positions:
            build_curve += "-p {} {} {} ".format(pos[0], pos[1], pos[2])
        
        return mel.eval(build_curve)
    
    def create_locator_in_direction(self,locator1, locator2):
        pos1 = cmds.pointPosition(locator1)
        pos2 = cmds.pointPosition(locator2)
        # 计算方向和距离 / Calculate direction and distance
        direction_vector = [(pos2[0] - pos1[0]), (pos2[1] - pos1[1]), (pos2[2] - pos1[2])]
        direction_length = math.sqrt(sum(v ** 2 for v in direction_vector))
        normalized_direction = [(v / direction_length) * 10 * direction_length for v in direction_vector]
        new_locator_pos = [pos1[i] + normalized_direction[i] for i in range(3)]
        
        # 创建新定位器 / Create new locator
        new_locator = cmds.spaceLocator(name="new_locator")[0]
        cmds.move(new_locator_pos[0], new_locator_pos[1], new_locator_pos[2], new_locator)
        return new_locator
    
    def create_control_curve(self,pref, shape_type,obj,col):
        if shape_type == 'circle':
            ctrl = cmds.circle(ch=0, n=pref +obj.replace('Jnt','Ctrl'), r=0.5, nr=(1, 0, 0))[0]
        elif shape_type == 'cube':
            mel.eval('$ctrl =`curve -d 1 -p 0.5 0.5 0.5 -p 0.5 0.5 -0.5 -p -0.5 0.5 -0.5 -p -0.5 -0.5 -0.5 -p 0.5 -0.5 -0.5 -p 0.5 0.5 -0.5 -p -0.5 0.5 -0.5 -p -0.5 0.5 0.5 -p 0.5 0.5 0.5 -p 0.5 -0.5 0.5 -p 0.5 -0.5 -0.5 -p -0.5 -0.5 -0.5 -p -0.5 -0.5 0.5 -p 0.5 -0.5 0.5 -p -0.5 -0.5 0.5 -p -0.5 0.5 0.5 -k 0 -k 1 -k 2 -k 3 -k 4 -k 5 -k 6 -k 7 -k 8 -k 9 -k 10 -k 11 -k 12 -k 13 -k 14 -k 15 -n "'+pref +obj.replace('Jnt','Ctrl')+'" `;')  # 立方体曲线定义 / Replace with cube curve definition
            ctrl = cmds.rename(pref +obj.replace('Jnt','Ctrl'))
            shape = cmds.pickWalk(d="down")[0]
            cmds.rename(shape, ctrl + "Shape")
        
        ctrl_sdk_grp = cmds.group(n=pref +obj.replace('Jnt','Ctrl')+'_SdkGrp')
        ctrl_off_grp = cmds.group(n=pref +obj.replace('Jnt','Ctrl')+'_OffGrp')
        
        # 自定义控制器外观 / Customize control appearance
        cmds.setAttr(ctrl + '.overrideEnabled', 1)
        cmds.setAttr(ctrl + '.overrideColor', col)
        
        sub_ctrl = cmds.circle(ch=0, n=pref +obj.replace('Jnt','Sub_Ctrl'))[0]
        sub_ctrl_sdk_grp = cmds.group(n=pref +obj.replace('Jnt','Sub_Ctrl')+'_SdkGrp')
        sub_ctrl_off_grp = cmds.group(n=pref +obj.replace('Jnt','Sub_Ctrl')+'_OffGrp')
        
        # 自定义子控制器外观 / Customize sub control appearance
        cmds.setAttr(sub_ctrl + '.overrideEnabled', 1)
        cmds.setAttr(sub_ctrl + '.overrideColor', 13)
        
        cmds.parent(sub_ctrl_off_grp, ctrl)
        cmds.addAttr(ctrl, ln='Sub_Ctrl_Vis', at='bool', h=0, k=1, r=1)
        cmds.connectAttr(ctrl + '.Sub_Ctrl_Vis', sub_ctrl_off_grp + '.v')
        delete(parentConstraint(obj,ctrl_off_grp,mo=0))
        return ctrl
    
    def create_joints_between_objects(self,num_joints, prefix=''):
        joints = []
        selObj=ls(sl=1)
        start_obj = selObj[0]
        end_obj = selObj[1]
        for i in range(num_joints + 2):
            select(cl=1)
            t = float(i) / float(num_joints + 1)
            joint_name = '{}_{:02d}_Jnt'.format(prefix, i)
            new_joint = cmds.joint(name=joint_name)
            
            start_pos = cmds.xform(start_obj, q=1, t=1, worldSpace=True)
            end_pos = cmds.xform(end_obj, q=1, t=1, worldSpace=True)
            joint_pos = [
                start_pos[0] + (end_pos[0] - start_pos[0]) * t,
                start_pos[1] + (end_pos[1] - start_pos[1]) * t,
                start_pos[2] + (end_pos[2] - start_pos[2]) * t
            ]
            cmds.xform(new_joint, translation=joint_pos, worldSpace=True)
            if not i ==  num_joints + 1:
                delete(aimConstraint(end_obj,new_joint,aim=(1,0,0),u=(0,1,0),wut='vector',wu=(0,1,0)))
            else:
                delete(aimConstraint(start_obj,end_obj,new_joint,aim=(-1,0,0),u=(0,1,0),wut='vector',wu=(0,1,0)))
            select(new_joint)
            if i>>0:
                makeIdentity( a = True, t =0, r= 1, s =0, n= 0, pn= 1);
            joints.append(new_joint)
        
        return joints
    
    def create_ui(self,path=''):
        window_name = "RigNet_Tools"
        if cmds.window(window_name, exists=True):
            cmds.deleteUI(window_name)
        cmds.window(window_name, title="曲线绑定工具 / Curve Rigger Tools",w=350,h=430)
        
        form=cmds.formLayout(numberOfDivisions=100,w = 350)
        txt=cmds.text(label="蒙皮关节数量 / Number of Skn Joints:")
        skn_joints_field = cmds.intField(minValue=1, value=10,w=80)
        
        FkTxt=cmds.text(label="控制器数量 / Number of Controls:")
        flst_field = cmds.intField(minValue=1, value=5,w=80)
        IKChk=cmds.checkBox(label="IK控制器 / IK Controls")
        TwistChk=cmds.checkBox(label="启用扭曲 / Enable Twist")
        FKChk=cmds.checkBox(label="FK控制器 / FK Controls")
        RevChk=cmds.checkBox(label="反向FK控制器 / RevFK Controls")
        PathChk=cmds.checkBox(label="路径控制器 / Path Controls",cc=lambda state: self.enable_flst_field(state,path_joints_field))
        PText = cmds.text(label="路径控制器数量 / Number of Path Controls:",)
        path_joints_field = cmds.intField(minValue=1, value=50,en=0,w=80)
        but=cmds.button(label="创建绑定 / Create Rig", command=lambda args: self.create_rig(skn_joints_field, flst_field,path_joints_field,IKChk,FKChk,RevChk,PathChk,TwistChk),bgc=(0.15,0.15,0.15),w=310,h=40)
        transfer_but=cmds.button(label="转移蒙皮权重 / Transfer Skin Weights", command=lambda args: self.transfer_skin_weights(),bgc=(0.2,0.3,0.2),w=310,h=40)
        cmds.formLayout( form, edit=True,
    	
    	attachForm=[
    	(txt, 'top',20),
    	
    	(txt, 'left',20),
    	
    	(skn_joints_field, 'top',17),
    	
    	(skn_joints_field, 'left',260),
    	(flst_field, 'top',37),
    	
    	(flst_field, 'left',260),
        (IKChk, 'top', 65),
    	(IKChk, 'left', 20),
    	
    	(TwistChk, 'top', 65),
    	
    	(TwistChk, 'left', 200),
    	
    	(FkTxt, 'top', 40),
    	
    	(FkTxt, 'left', 20),
    	(FKChk, 'top', 90),
    	
    	(FKChk, 'left', 20),
    	(RevChk, 'top', 90),
    	
    	(RevChk, 'left', 200),
    	
    	(PathChk, 'top', 140),
    	
    	(PathChk, 'left', 20),
    	(PText, 'top', 115),
    	
    	(PText, 'left', 20),
    	(path_joints_field, 'top', 112),
    	
    	(path_joints_field, 'left', 260),
    	(but, 'top', 170),
    	
    	(but, 'left', 20),
    	(transfer_but, 'top', 220),
    	
    	(transfer_but, 'left', 20)
    
    
    
    
    
    	])
        cmds.showWindow(window_name)
    def enable_flst_field(self,state, path_joints_field):
        cmds.intField(path_joints_field, edit=True, enable=state,bgc=(0.0,0.0,0.0))
    
    def transfer_skin_weights(self):
        # 获取选择的模型 / Get selected model
        selection = cmds.ls(sl=True)
        if not selection:
            cmds.warning("请先选择目标模型 / Please select target model first")
            return
        
        # 检查源模型是否存在 / Check if source model exists
        source_mesh = "Dummy_Mesh"
        if not cmds.objExists(source_mesh):
            cmds.warning("源模型 'Dummy_Mesh' 不存在 / Source model 'Dummy_Mesh' does not exist")
            return
        
        # 获取源模型的蒙皮簇 / Get skin cluster from source mesh
        source_skin_cluster = None
        # 获取网格的shape节点 / Get mesh shape node
        source_shapes = cmds.listRelatives(source_mesh, shapes=True, type='mesh')
        if not source_shapes:
            cmds.warning("源模型没有网格形状 / Source model has no mesh shape")
            return
        
        source_shape = source_shapes[0]
        # 从shape节点查找蒙皮簇 / Find skin cluster from shape node
        skin_clusters = cmds.listConnections(source_shape, type='skinCluster', source=True, destination=False)
        if not skin_clusters:
            # 尝试从历史记录中查找 / Try to find from history
            history = cmds.listHistory(source_shape, pruneDagObjects=True)
            if history:
                for node in history:
                    if cmds.nodeType(node) == 'skinCluster':
                        skin_clusters = [node]
                        break
        
        if skin_clusters:
            source_skin_cluster = skin_clusters[0]
        else:
            cmds.warning("源模型没有蒙皮簇 / Source model has no skin cluster")
            return
        
        # 获取蒙皮关节 / Get skin joints
        skin_joints = cmds.skinCluster(source_skin_cluster, query=True, influence=True)
        if not skin_joints:
            cmds.warning("无法获取蒙皮关节 / Cannot get skin joints")
            return
        
        # 处理每个选择的对象 / Process each selected object
        for target_mesh in selection:
            # 检查是否为网格 / Check if it's a mesh
            target_shapes = cmds.listRelatives(target_mesh, shapes=True, type='mesh')
            if not target_shapes:
                cmds.warning("'{}' 不是网格对象 / '{}' is not a mesh object".format(target_mesh, target_mesh))
                continue
            
            target_shape = target_shapes[0]
            
            # 检查目标模型是否已有蒙皮簇 / Check if target already has skin cluster
            target_skin_cluster = None
            target_skin_clusters = cmds.listConnections(target_shape, type='skinCluster', source=True, destination=False)
            if not target_skin_clusters:
                # 尝试从历史记录中查找 / Try to find from history
                history = cmds.listHistory(target_shape, pruneDagObjects=True)
                if history:
                    for node in history:
                        if cmds.nodeType(node) == 'skinCluster':
                            target_skin_clusters = [node]
                            break
            if target_skin_clusters:
                target_skin_cluster = target_skin_clusters[0]
            
            # 如果目标模型没有蒙皮簇，创建一个 / Create skin cluster if target doesn't have one
            if not target_skin_cluster:
                # 创建新的蒙皮簇 / Create new skin cluster
                target_skin_cluster = cmds.skinCluster(skin_joints, target_mesh, tsb=True, mi=1)[0]
            
            # 转移蒙皮权重 / Transfer skin weights
            try:
                cmds.copySkinWeights(
                    sourceSkin=source_skin_cluster,
                    destinationSkin=target_skin_cluster,
                    noMirror=True,
                    surfaceAssociation='closestPoint',
                    influenceAssociation=['oneToOne', 'closestJoint']
                )
                print("成功转移蒙皮权重: {} / Successfully transferred skin weights: {}".format(target_mesh, target_mesh))
            except Exception as e:
                cmds.warning("转移蒙皮权重失败: {} / Failed to transfer skin weights: {}".format(str(e), str(e)))
        
        cmds.select(selection, r=True)
    def create_rig(self,skn_joints_field, flst_field,path_joints_field,IKChk,FKChk,RevChk,PathChk,TwistChk):
        IK=cmds.checkBox(IKChk,q=1,v=1)
        FK=cmds.checkBox(FKChk,q=1,v=1)
        Rev=cmds.checkBox(RevChk,q=1,v=1)
        Path=cmds.checkBox(PathChk,q=1,v=1)
        Twst=cmds.checkBox(TwistChk,q=1,v=1)
        print (IK,FK,Rev,Path)
        num_skn_joints = cmds.intField(skn_joints_field, query=True, value=True)
        num_flst = cmds.intField(flst_field, query=True, value=True)
        pth_jnt=cmds.intField(path_joints_field,q=1,value=1)
        initLoc=ls(sl=1)
        
        # 创建蒙皮关节 / Create SKn Jnt #
        Jlst=self.create_joints_between_objects(num_skn_joints-2,'Skn')
        select(Jlst[0])
        FreezeTransformations()
        
        # 将'locator1'和'locator2'替换为你的定位器名称 / Replace 'locator1' and 'locator2' with the names of your locators
        start_locator = initLoc[0]
        end_locator = initLoc[1]
        
        # 调用函数创建圆柱体 / Call the function to create the cylinder
        cylinder = self.create_cylinder_with_locators("Dummy_Mesh", start_locator, end_locator, radius=0.3, divisions=num_skn_joints-1)
        select(Jlst,cylinder)
        SmoothBindSkin()
        a=-1
        select(cl=1)
        for i in range(len(Jlst)):
            jj=cmds.duplicate(Jlst[a],n='IK_'+Jlst[a])
            grp = group(em=1,n= Jlst[a]+'_Conn_Grp')
            delete(parentConstraint(Jlst[a],grp,mo=0))
            parent(Jlst[a],grp)
            if i>0:
                parent('IK_'+Jlst[a+1],'IK_'+Jlst[a])
                #parent(Jlst[a+1]+'_Conn_Grp',Jlst[a])
            parentConstraint('IK_'+Jlst[a],grp,mo=1)
            #connectAttr('IK_'+Jlst[a]+'.r',grp+'.r')
            a=a-1
        Ik_OffGrp=group(em=1,n='IK_Offset_Val_Grp')
        delete(parentConstraint(Jlst[0],Ik_OffGrp,mo=0))        
        select(initLoc)
        
        # 创建驱动IK关节 / Create Drv IK Jnt #
        Dlst=self.create_joints_between_objects(num_flst-2,'Drv')  
        self.create_curve_from_objects(Dlst)
        crv=ls(sl=1)[0]
        refresh()
        select('IK_'+Jlst[0])
        FreezeTransformations()
        select('IK_'+Jlst[0],'IK_'+Jlst[-1])
        refresh()    
        
        # 创建IK样条 / Create IK Spline #
        ik=ikHandle(sol = 'ikSplineSolver', pcv=0, c=crv, ccv= 0)
        select(Dlst,crv)
        SmoothBindSkin()
        main_Ctrl = circle(ch=0,n='Main_Ctrl',r=5,nr=(0,1,0))[0]
        main_grp = group(n='Main_Ctrl_Grp')
        #delete(parentConstraint(initLoc[0],initLoc[1],main_grp,mo=0))  
        parent('IK_'+Jlst[0],Ik_OffGrp)
        for jJnt in Jlst:
            parent(jJnt+'_Conn_Grp',Ik_OffGrp)
        # 添加拉伸功能 / Adding Stretch #
        addAttr(main_Ctrl,ln='Maintain_Length',min=0,max=1,k=1,at='float')
        crvInfo=arclen(crv,ch=1)
        dis=getAttr(crvInfo+'.arcLength')
        StrGlMD=createNode('multiplyDivide',n='Wire_StrVGlobal_MD')
        connectAttr(crvInfo+'.arcLength',StrGlMD+'.input1X')
        connectAttr(main_Ctrl+'.sx',StrGlMD+'.input2X')
        setAttr(StrGlMD+'.operation',2)
        StrMD=createNode('multiplyDivide',n='Wire_StrVal_MD')
        setAttr(StrMD+'.input2X',dis)
        connectAttr(StrGlMD+'.outputX',StrMD+'.input1X')
        setAttr(StrMD+'.operation',2)
        Tval=getAttr('IK_'+Jlst[-1]+'.tx')
        StrValMD=createNode('multiplyDivide',n='Wire_Stretchy_MD')
        setAttr(StrValMD+'.input1X',Tval)
        connectAttr(StrMD+'.outputX',StrValMD+'.input2X')
        setAttr(StrValMD+'.operation',1)
        StrcBlnd=createNode('blendColors',n='Wire_StrSwitch_MD')
        setAttr('Wire_StrSwitch_MD.color2R',Tval)
        connectAttr(StrValMD+'.outputX','Wire_StrSwitch_MD.color1R')
        connectAttr(main_Ctrl+'.Maintain_Length',StrcBlnd+'.blender')
        for i in range(1,len(Jlst)):
            connectAttr(StrcBlnd+'.outputR','IK_'+Jlst[i]+'.tx')
        FkLst=[]
        IKCtrl=[]
        RevLst=[]
        ConsLst=[]
        IKGrp=[]
        pthLst=[]
        i=0
        if FK == True:
            if Rev == True:
                IK = True
        if IK == True:
            for DJnt in Dlst:
                Ctrl = self.create_control_curve('IK_', 'circle',DJnt,17)
                IKCtrl.append(Ctrl)
        if FK == True:
            Flst=list(Dlst)  
            print(Dlst) 
            Flst.reverse()
            print(Flst)  
            for DJnt in Flst:
                Ctrl = self.create_control_curve('FK_', 'cube',DJnt,20)
                FkLst.append(Ctrl)
                Grp=group(em=1,n=Ctrl.replace('Ctrl','Drv_OffGrp'))
                delete(parentConstraint(Ctrl,Grp,mo=0))
                if i>>0:
                    parent(FkLst[i-1].replace('Ctrl','Ctrl_OffGrp'),Ctrl)
                    parent(FkLst[i-1].replace('Ctrl','Drv_OffGrp'),Grp)
                i=i+1
                connectAttr(Grp+'.t',Ctrl.replace('Ctrl','Ctrl_OffGrp')+'.t')
                connectAttr(Grp+'.r',Ctrl.replace('Ctrl','Ctrl_OffGrp')+'.r')
                connectAttr(Grp+'.s',Ctrl.replace('Ctrl','Ctrl_OffGrp')+'.s')
        i=0
        if Rev == True:
            Revlst=list(Dlst)   
            print(Revlst)     
            for DJnt in Revlst:
                Ctrl = self.create_control_curve('RevFK_', 'cube',DJnt,21)
                RevLst.append(Ctrl)
                Grp=group(em=1,n=Ctrl.replace('Ctrl','Drv_OffGrp'))
                delete(parentConstraint(Ctrl,Grp,mo=0))
                if i>>0:
                    parent(RevLst[i-1].replace('Ctrl','Ctrl_OffGrp'),Ctrl)
                    parent(RevLst[i-1].replace('Ctrl','Drv_OffGrp'),Grp)
                i=i+1
                connectAttr(Grp+'.t',Ctrl.replace('Ctrl','Ctrl_OffGrp')+'.t')
                connectAttr(Grp+'.r',Ctrl.replace('Ctrl','Ctrl_OffGrp')+'.r')
                connectAttr(Grp+'.s',Ctrl.replace('Ctrl','Ctrl_OffGrp')+'.s')
        if IK ==  True:
            i=0
            for DJnt in Dlst:
                parentConstraint(IKCtrl[i].replace('Ctrl','Sub_Ctrl'),DJnt,mo=1)
                i=i+1
        elif FK == True:
            i=0
            for DJnt in Flst:
                parentConstraint(FkLst[i].replace('Ctrl','Sub_Ctrl'),DJnt,mo=1)
                i=i+1
        elif Rev == True:
            i=0
            for DJnt in Dlst:
                parentConstraint(RevLst[i].replace('Ctrl','Sub_Ctrl'),DJnt,mo=1)
                i=i+1
        
        # 其余绑定创建代码 / Rest of the rig creation code #
        a=0
        b=-1
        if IK:
         for ikctrl in IKCtrl:
            IKGrp.append(ikctrl.replace('Ctrl','Ctrl_OffGrp'))
            par=[]
            if FkLst:
                par.append(FkLst[b])
            if RevLst:
                par.append(RevLst[a])
            if par:
                constraint = cmds.parentConstraint(par, ikctrl.replace('Ctrl','Ctrl_OffGrp'),mo=1)[0]
                ConsLst.append(constraint)
            a=a+1
            b=b-1    
        
        if FK and Rev == True:
            addAttr(main_Ctrl,ln='RevFK',min=0,max=10,k=1,at='float')
            inVal=0
            val=10.0/len(Dlst)
            sel =list(IKCtrl)
            for obj in sel:    
                Nobj=obj
                obj = obj.replace('Ctrl','Ctrl_OffGrp')
                par=parentConstraint(Nobj.replace('IK_','FK_'),Nobj.replace('IK_','RevFK_'),obj,mo=1)[0]
                select(par)
                setDrivenKeyframe(cd="Main_Ctrl.RevFK",at=Nobj.replace('IK_','FK_')+'W0',dv=inVal,v=1)
                setDrivenKeyframe(cd="Main_Ctrl.RevFK",at=Nobj.replace('IK_','FK_')+'W0',dv=inVal+val,v=0)
                select(Nobj.replace('IK_','FK_')+'Shape')
                setDrivenKeyframe(cd="Main_Ctrl.RevFK",at='.v',dv=inVal,v=1)
                setDrivenKeyframe(cd="Main_Ctrl.RevFK",at='.v',dv=inVal+val,v=0)
                select(par)
                setDrivenKeyframe(cd="Main_Ctrl.RevFK",at=Nobj.replace('IK_','RevFK_')+'W1',dv=inVal,v=0)
                setDrivenKeyframe(cd="Main_Ctrl.RevFK",at=Nobj.replace('IK_','RevFK_')+'W1',dv=inVal+val,v=1)
                select(Nobj.replace('IK_','RevFK_')+'Shape')
                setDrivenKeyframe(cd="Main_Ctrl.RevFK",at='.v',dv=inVal,v=0)
                setDrivenKeyframe(cd="Main_Ctrl.RevFK",at='.v',dv=inVal+val,v=1)
                inVal=inVal+val
        select (Jlst)
        sets(n='Bind_Skin')
        pJnt=listRelatives(Jlst[0],p=1)[0]
        select(Dlst)
        group(n='Jnt_Grp')
        scaleConstraint('Main_Ctrl','Jnt_Grp',mo=1)
        select(crv,ik[0])
        group(n='Extra_Grp')
        dGrp=group(em=1,n='Drv_Null_Group')
        parent(dGrp,'Extra_Grp')
        parentConstraint('Main_Ctrl',dGrp,mo=1)
        scaleConstraint('Main_Ctrl',dGrp,mo=1)
        if IK == True:
            addAttr(main_Ctrl,ln='IK_Ctrl_Vis',at='bool',k=1)
            group(IKGrp,n='IK_Ctrl_Grp')
            connectAttr('Main_Ctrl.IK_Ctrl_Vis','IK_Ctrl_Grp.v')
            parent('IK_Ctrl_Grp','Main_Ctrl')
        if FK == True:
            
            select(FkLst[-1].replace('Ctrl','Ctrl_OffGrp'))
            FkGrp=group(n='Fk_Ctrl_Group')
            addAttr(main_Ctrl,ln='FK_Ctrl_Vis',at='bool',k=1)
            connectAttr('Main_Ctrl.FK_Ctrl_Vis',FkGrp+'.v')
            parent(FkGrp,'Main_Ctrl')
            parent("FK_Drv_00_Drv_OffGrp",dGrp)         
        if Rev == True:
            select(RevLst[-1].replace('Ctrl','Ctrl_OffGrp'))
            RevFkGrp=group(n='RevFk_Ctrl_Group')
            try:
                addAttr(main_Ctrl,ln='FK_Ctrl_Vis',at='bool',k=1)
            except: pass
            connectAttr('Main_Ctrl.FK_Ctrl_Vis',RevFkGrp+'.v')
            parent(RevFkGrp,'Main_Ctrl')
            parent(RevLst[-1].replace('Ctrl','Drv_OffGrp'),dGrp)                
        if Path == True:
            addAttr(main_Ctrl,ln='Path_Ctrl_Vis',at='bool',k=1)
            self.create_locator_in_direction(initLoc[0],initLoc[1])
            select(initLoc[0],"new_locator")
            PathLst=self.create_joints_between_objects(pth_jnt-2,'Path')
            select(PathLst)
            Pcrv=self.create_curve_from_objects(PathLst)
            noCv=len(PathLst)-1
            rebuildCurve(Pcrv,ch=1,rpo=1,rt=0,end=1,kr=0,kcp=0,kep=1,kt=0,s=noCv,d=3,tol=0.01)
            i=0
            PathLst.reverse()
            for PJnt in PathLst:
                Ctrl = self.create_control_curve('', 'circle',PJnt,13)
                pthLst.append(Ctrl)
                parent(PJnt,Ctrl.replace('Ctrl','Sub_Ctrl'))
                if i>>0:
                    try:
                        parent(pthLst[i-1].replace('Ctrl','Ctrl_OffGrp'),Ctrl)
                    except:
                        pass
                i=i+1
            parent(pthLst[-1].replace('Ctrl','Ctrl_OffGrp'),'Main_Ctrl')
            connectAttr('Main_Ctrl.Path_Ctrl_Vis',pthLst[-1].replace('Ctrl','Ctrl_OffGrp')+'.v')
            DummyJnt=duplicate(PathLst[0],n='Dummy_Jnt')[0]
            delete(pointConstraint(Pcrv,DummyJnt,mo=0))
            DCrv=duplicate(Pcrv)[0]
            setAttr(DummyJnt+'.tz',0.5)
            delete(pointConstraint(DummyJnt,Pcrv,mo=0))
            setAttr(DummyJnt+'.tz',-0.5)
            delete(pointConstraint(DummyJnt,DCrv,mo=0))
            delete(DummyJnt)
            select(Pcrv,DCrv,PathLst)
            SmoothBindSkin()
            select(Pcrv,DCrv)
            surf=loft(n='Path_Surface')
            DeleteHistory(surf[0])
            select(surf[0],PathLst)
            skinCluster(PathLst,surf[0],tsb=1,mi=1)        
            print(surf)
            if not FK and not Rev == True:
                if not IK:
                    select(Dlst,surf[0])
                    self.FolRivet()  
                else: 
                    print('不存在 / Not Present')
                    select(IKGrp,surf[0])
                    self.FolRivet() 
            if FK:
                select("FK_Drv_*_Drv_OffGrp",surf[0])
                self.FolRivet() 
            if Rev:
                select("RevFK_Drv_*_Drv_OffGrp",surf[0])
                self.FolRivet() 
            
            # 创建移动绑定设置 / Create traveling Rig setup
            addAttr(main_Ctrl,ln='Travel',min=0,max=10,k=1,at='float')
            if FK:
                fol=ls("FK_Drv_*_Drv_OffGrp_fol")
                initval=getAttr(fol[-1]+"Shape.parameterV")
                Diff=1.0-initval
                for follicle in fol:
                    shp=listRelatives(follicle,c=1,f=1)[0]
                    inValue=getAttr(shp+'.parameterV')
                    select(shp)
                    setDrivenKeyframe(cd="Main_Ctrl.Travel",at='parameterV',dv=0,v=inValue)
                    setDrivenKeyframe(cd="Main_Ctrl.Travel",at='parameterV',dv=10,v=inValue+Diff)
            if Rev:
                fol=ls("RevFK_Drv_*_Drv_OffGrp_fol")
                initval=getAttr(fol[-1]+"Shape.parameterV")
                Diff=1.0-initval
                for follicle in fol:
                    shp=listRelatives(follicle,c=1,f=1)[0]
                    inValue=getAttr(shp+'.parameterV')
                    select(shp)
                    setDrivenKeyframe(cd="Main_Ctrl.Travel",at='parameterV',dv=0,v=inValue)
                    setDrivenKeyframe(cd="Main_Ctrl.Travel",at='parameterV',dv=10,v=inValue+Diff)
            if not FK and not Rev == True:
                if not IK:
                    fol=ls("Drv_*_Jnt_fol")
                    initval=getAttr(fol[-1]+"|follicleShape.parameterV")
                    Diff=1.0-initval
                    for follicle in fol:
                        shp=listRelatives(follicle,c=1,f=1)[0]
                        inValue=getAttr(shp+'.parameterV')
                        select(shp)
                        setDrivenKeyframe(cd="Main_Ctrl.Travel",at='parameterV',dv=0,v=inValue)
                        setDrivenKeyframe(cd="Main_Ctrl.Travel",at='parameterV',dv=10,v=inValue+Diff)
                if IK:
                    fol=ls("IK_Drv_*_Ctrl_OffGrp_fol")
                    initval=getAttr(fol[-1]+"Shape.parameterV")
                    Diff=1.0-initval
                    for follicle in fol:
                        shp=listRelatives(follicle,c=1,f=1)[0]
                        inValue=getAttr(shp+'.parameterV')
                        select(shp)
                        setDrivenKeyframe(cd="Main_Ctrl.Travel",at='parameterV',dv=0,v=inValue)
                        setDrivenKeyframe(cd="Main_Ctrl.Travel",at='parameterV',dv=10,v=inValue+Diff)
        # 在蒙皮关节上添加扭曲 / Adding Twist on Skin Jnts
        if Twst:                
            select(cl=1)
            DummyJnt=duplicate(Jlst[0],n='Dummy_Jnt')[0]
            delete(pointConstraint(crv,DummyJnt,mo=0))
            TlocLst=[]
            DnumJnt=len(Dlst)-1
            LCrv=duplicate(crv)[0]
            rebuildCurve(LCrv,ch=1,rpo=1,rt=0,end=1,kr=0,kcp=0,kep=1,kt=0,s=DnumJnt,d=3,tol=0.01)
            RCrv=duplicate(LCrv)[0]
            axis=['tx','ty','tz']
            for ax in axis:
                setAttr(LCrv+'.'+ax,l=0)
                setAttr(RCrv+'.'+ax,l=0)
            setAttr(DummyJnt+'.tz',0.5)
            delete(pointConstraint(DummyJnt,LCrv,mo=0))
            setAttr(DummyJnt+'.tz',-0.5)
            delete(pointConstraint(DummyJnt,RCrv,mo=0))
            delete(DummyJnt)
            select(LCrv,RCrv)
            Tsurf=loft(n='Twist_Surface')
            DeleteHistory(Tsurf[0])
            select(Tsurf[0],Dlst)
            skinCluster(Dlst,Tsurf[0],tsb=1,mi=1)
            for SknJnt in Jlst:
                Tloc=spaceLocator(n=SknJnt.replace('Jnt','_Twst_Loc'))[0]
                Tgrp=group(n=Tloc+'_Grp')
                TlocLst.append(Tgrp)
                delete(parentConstraint(SknJnt,Tgrp,mo=0))
                parentConstraint(Tloc,SknJnt,st=('x','y','z'),sr=('y','z'),mo=1)
            
            select(TlocLst,Tsurf[0])
            self.FolRivet()  
            for grp in TlocLst:
                delete(listRelatives(grp,ad=1,type='constraint'))
                parent(grp,grp+'_fol')   
            parent('Twist_Surface','Extra_Grp')
            delete(LCrv,RCrv)
        
        # 创建外层控制器并整理层级 / Create outer controllers and organize hierarchy
        select(cl=True)  # 清除选择，确保组是空的 / Clear selection to ensure groups are empty
        # 创建中间层控制器 / Create middle layer controller
        middle_Ctrl = circle(ch=0,n='Middle_Ctrl',r=6,nr=(0,1,0))[0]
        select(cl=True)  # 清除选择 / Clear selection
        middle_Ctrl_off_grp = group(em=True, n='Middle_Ctrl_OffGrp')
        delete(parentConstraint(main_Ctrl,middle_Ctrl_off_grp,mo=0))
        setAttr(middle_Ctrl + '.overrideEnabled', 1)
        setAttr(middle_Ctrl + '.overrideColor', 14)  # 黄色 / Yellow
        
        # 创建最外层控制器 / Create outer layer controller
        select(cl=True)  # 清除选择 / Clear selection
        outer_Ctrl = circle(ch=0,n='Outer_Ctrl',r=7,nr=(0,1,0))[0]
        select(cl=True)  # 清除选择 / Clear selection
        outer_Ctrl_off_grp = group(em=True, n='Outer_Ctrl_OffGrp')
        delete(parentConstraint(middle_Ctrl,outer_Ctrl_off_grp,mo=0))
        setAttr(outer_Ctrl + '.overrideEnabled', 1)
        setAttr(outer_Ctrl + '.overrideColor', 18)  # 红色 / Red
        
        # 建立层级关系 / Establish hierarchy: Outer_Ctrl -> Middle_Ctrl -> Main_Ctrl_Grp
        # 从内到外建立层级：先将 Main_Ctrl_Grp 放入 Middle_Ctrl
        main_grp_parent = listRelatives(main_grp, p=True)
        if not main_grp_parent or main_grp_parent[0] != middle_Ctrl:
            parent(main_grp, middle_Ctrl)
        # 然后将 Middle_Ctrl 放入其 OffGrp
        middle_Ctrl_parent = listRelatives(middle_Ctrl, p=True)
        if not middle_Ctrl_parent or middle_Ctrl_parent[0] != middle_Ctrl_off_grp:
            parent(middle_Ctrl, middle_Ctrl_off_grp)
        # 将 Middle_Ctrl_OffGrp 放入 Outer_Ctrl
        middle_off_grp_parent = listRelatives(middle_Ctrl_off_grp, p=True)
        if not middle_off_grp_parent or middle_off_grp_parent[0] != outer_Ctrl:
            parent(middle_Ctrl_off_grp, outer_Ctrl)
        # 将 Outer_Ctrl 放入其 OffGrp
        outer_Ctrl_parent = listRelatives(outer_Ctrl, p=True)
        if not outer_Ctrl_parent or outer_Ctrl_parent[0] != outer_Ctrl_off_grp:
            parent(outer_Ctrl, outer_Ctrl_off_grp)
                 
        # 清理 / Cleanup
        parent(Ik_OffGrp,'Jnt_Grp')    
        delete(initLoc)
        if Path:
            delete(Pcrv,DCrv,'new_locator')
            parent('Path_Surface','Extra_Grp')
        try:
            parent('Rivet_Fol_Group','Extra_Grp')
        except:pass
        select('Dummy_Mesh')
        RefGrp=group(n='Ref_Geo_Grp')
        select(RefGrp,'Outer_Ctrl_OffGrp','Jnt_Grp','Extra_Grp')
        group(n='Rig_Grp')
        setAttr('Extra_Grp.v',0)
        setAttr('Jnt_Grp.v',0)
                           
 
rope_rig_instance = Curve_Rigger()
rope_rig_instance.create_ui()

This video demonstrates how to rig flexible props such as rope, tail, tentacle, chain and vine in Maya using Curve Rigger.
本期视频演示如何在 Maya 中，使用 Curve Rigger 快速绑定线条类道具（绳子、尾巴、触手、藤蔓等）。

With only 2 locators, you can automatically create joints, FK / IK, Reverse FK, stretch, twist and path animation controls.
只需要 2 个定位器，即可一键生成骨骼、FK / IK、反向 FK、拉伸、扭曲以及路径动画控制。

⚠️ This tool rigs flexible props USING curves, not rigging the curve itself.
⚠️ 本工具是“通过曲线来绑定道具”，而不是去绑定曲线本身。

🔹 Tool Features / 功能亮点

One-click rig for flexible props (Rope / Tail / Tentacle / Vine / Chain)
FK / IK / Reverse FK switching
Stretch & twist control
Path-based animation control
Auto skin and one-click skin weight transfer
Bilingual UI (Chinese / English)
线条类道具一键自动绑定
支持 FK / IK / 反向 FK 切换
支持拉伸、扭曲控制
路径动画控制系统
蒙皮权重一键转移
中英文双语界面优化

🔹 Suitable For / 适用类型

Rope / Cable / Hose rig
Tail & Tentacle rig
Vine, whip and flexible props
Animation, game and cartoon production
绳子、管线、软管类道具
尾巴、触手类结构
藤蔓、鞭子等线条道具
动画、游戏、卡通项目

🔹 Workflow Overview / 绑定流程

Place 2 locators to define the start and end of the prop
Run Curve Rigger to generate the rig automatically
Animate using FK, IK or path controls
放置 2 个定位器作为起点和终点
运行 Curve Rigger 自动生成绑定
使用 FK / IK 或路径控制进行动画

🔹 Software
Autodesk Maya 2018+

Maya Curve Rigger｜线条类道具一键绑定（Rope / Tail / Tentacle Rig）最先出现在喵喵动画屋。

Maya 2022+ Eleven Rig绑定模型

喵喵动画屋 — Wed, 01 Oct 2025 08:05:18 +0000

ElevenRig_Final+Textures 下载

免费开源的 Eleven RIG 模型 —— Maya 动画练习利器

今天要和大家分享的是一个非常经典的免费开源模型 —— Eleven RIG。
这个模型在动画学习圈子里非常有名，因为它简洁、优质，常被用作日常的动画练习。

不过，原版 Eleven RIG 在 Maya2014 之后就停止更新了，对后续版本支持不佳。为此，我对其绑定进行了全面重置，采用了更主流、更通用的 ADV 绑定系统，大大提升了兼容性与实用性。

功能特色

在保持原有基础功能的同时，我还做了一些扩展：

性别切换 —— 一键切换男女角色，练习更灵活。
眉毛切换 —— 提供三种粗细样式，适配不同风格。
胡子样式 —— 可选择不同大小的胡子，丰富角色表现力。
发型绑定 —— 新增男女头发绑定，动画细节更饱满。
iPhone ARKit 面捕支持 —— 直接连接面部捕捉数据，让表情动画更真实。

版权声明

出于对原作者的尊重，我在模型绑定中加入了版权归属显示。该模型依然保持开源与免费特性，可以放心用于学习与商业环境。

写在最后

绑定和优化这个模型花费了不少时间，希望它能为大家的学习和项目带来帮助。如果觉得有用，欢迎点赞与支持，谢谢

Maya 2022+ Eleven Rig绑定模型最先出现在喵喵动画屋。

Maya绑定教学：液压臂的伸缩和移动

喵喵动画屋 — Sat, 09 Mar 2024 07:13:48 +0000

Hydraulic 点击下载模型

如何在 Maya 中制作液压机械臂
视频教学：https://youtu.be/UJ5ipof75Dg

本教程将向您展示如何在 Maya 中制作类似于现实世界的液压机械臂。

步骤

创建骨骼：
- 进入前视图，创建关节。
- 连接关节形成机械臂结构。
绑定蒙皮：
- 将关节绑定到液压杆和其它部件上。
- 测试绑定效果，确保没有漏绑或穿模问题。
目标点约束：
- 选中两个关键关节，执行目标点约束。
- 反过来再执行一次约束。
- 调整约束参数，确保液压杆运动流畅。
创建控制器：
- 创建曲线圆环作为控制器。
- 复制控制器并调整位置。
- 将控制器组添加到主控制器下。
父对象约束：
- 使用父对象约束将控制器与根骨骼连接。
限制旋转范围：
- 旋转控制器到极限位置。
- 限制旋转轴的最小值和最大值。

总结

本教程介绍了 Maya 中制作液压机械臂的基本方法，包括骨骼创建、绑定蒙皮、目标点约束、控制器创建和父对象约束等。掌握这些方法，您可以制作更加复杂的液压机械臂模型。

练习

下载视频附件的模型文件，进行练习和修改。
尝试制作不同形状和功能的液压机械臂。

资源

Maya 文档：https://www.autodesk.com/support/technical/article/caas/tsarticles/ts/lC3jaffqnWFyQoLPEPm7n.html
Maya 教程：https://www.youtube.com/watch?v=tZieJcA5vf0
Maya 论坛：https://forums.autodesk.com/t5/maya/ct-p/area-c2

希望这篇总结对您有所帮助！

Maya绑定教学：液压臂的伸缩和移动最先出现在喵喵动画屋。

Maya人体骨骼绑定 | Polina模型 | Advanced Skeleton 6

喵喵动画屋 — Sat, 23 Dec 2023 16:12:13 +0000

Polina Model（原作者）：https://www.cgtrader.com/free-3d-models/character/woman/polina-3d-stylized-character

Polina 下载（download）
—-布线改良版

Polina-rig 下载（download）
—-Adv绑定版

推荐使用Maya2020以上的版本 + Advanced Skeleton 6+版本

Polina（Maya布线改良版原始模型）：

Polina （Maya已绑定）：

Maya人体骨骼绑定 | Polina模型 | Advanced Skeleton 6最先出现在喵喵动画屋。

Maya绑定教学：nHair头发动力学

喵喵动画屋 — Tue, 21 Nov 2023 19:59:18 +0000

这视频主要介绍了在玛雅中如何使用头发动力学进行绑定，相比传统的绑定方式，动力学可以在保证效果的同时节省时间。以下是视频内容的总结：

隐藏控制器：在开始之前，将不需要的控制器隐藏，以防止干扰后续工作。
创建骨骼：确保头发骨骼完整，足够多的关节是为了保证最终效果。
骨骼绑定：将头发绑定到头部以上的骨骼，确保头部和马尾部分都被正确绑定。
处理马尾部分：使用合并转移的方式，将头部和马尾部分分离开，以便更好地处理。
创建曲线：使用IK样条控制，在头发骨骼上创建曲线，主要在头发拐弯往下的部分。
曲线动力学：对曲线应用动力学属性，取消勾选将曲线附加到选定曲面。
输出曲线驱动骨骼：使用IK样条控制器，让毛发系统下的输出曲线驱动头发骨骼的运动。
优化动力学效果：调整抗弯曲、抗扭曲、阻尼值等参数，以获得更自然的头发动力学效果。
处理碰撞：设置身体为被动碰撞体，调整碰撞厚度，以避免头发穿过身体表面。
动力学开关：在头部或其他控制器上添加动力学开关，使用表达式与模拟方法建立开关关系，方便控制动力学的开启和关闭。
解算设置：可以在解算器中设置起始帧位置，以满足特定解算需求。

总体而言，视频提供了一个详细的玛雅动力学头发绑定教程，涵盖了从基本设置到优化效果的多个步骤。

Maya绑定教学：nHair头发动力学最先出现在喵喵动画屋。

Maya绑定教学：尾巴摆动

喵喵动画屋 — Tue, 21 Nov 2023 19:58:45 +0000

在Maya中实现类似尾巴摆动的效果的步骤概要：

创建骨骼结构：

手动创建骨骼，增加足够的关节数量。
对于线性骨骼，可以先创建首尾骨骼，然后使用高级骨骼绑定插件的关节重新采样功能，确保关节数量均匀。

设置IK样条控制器：

进入蒙皮下方的IK样条控制器选项设置。
保持默认值，设置控制点段数，选择根骨骼和尾部骨骼创建IK样条控制器。
进入控制点模式，通过移动控制点控制骨骼。

创建簇变形器：

为每个控制点创建簇变形器，确保相对控制开启。

创建新的控制器：

为簇变形器进行二次控制，确保相对控制开启。
打组并命名簇变形器。

约束控制器：

摆放控制器位置与簇变形器对应。
使用点约束时，勾选相对点约束，防止簇变形器点被直接约束到控制器中心点。
对根骨骼控制器使用父对象约束，确保其约束到根骨骼上。

整理控制器：

将所有控制器组放到根控制器下方，确保后面的控制器跟随根控制器移动。

完成骨骼控制系统：

验证控制器的功能，确保移动控制器能够正确控制骨骼效果。

蒙皮绑定：

选择模型，选中所有关节，执行蒙皮绑定。

测试绑定是否正确：

进行动画测试，确保尾巴摆动效果符合预期。

整理大纲中的内容：
- 对大纲中的步骤进行整理，使其清晰易懂。

希望这些步骤能够帮助成功实现鱼尾巴摆动的动画效果。

Maya绑定教学：尾巴摆动最先出现在喵喵动画屋。

Maya绑定教学：卷轴展开

喵喵动画屋 — Tue, 21 Nov 2023 19:58:17 +0000

细分面的重要性：首先，确保我们的模型有足够多的细分面，这是后续操作的基础。

第一个弯曲变形器：进入变形菜单，执行非线性弯曲变形器，给模型添加弯曲效果。

创建第二个变形器：以相同的方式再次添加一个弯曲变形器，确保在大纲视图中有两个变形器节点。

调整节点位置：在大纲视图中，调整这两个变形器节点的位置，使其处于卷轴展开的理想位置。

调整弯曲效果：按下T键调出控制器点，在中间的控制器点上用鼠标左键拖动，形成我们期望的弯曲效果。

旋转变形器：按下Q键回到对象模式，旋转第一个变形器，先暂时旋转90度，以满足我们的需求。

处理左侧的弯曲：由于左侧的弯曲需要另一个变形器来完成，按下T键将左侧的控制器点拉回至中心点重合。

调整曲率：展开变形器的输入节点，通过曲率参数来控制弯曲程度。初始设定为1000，如果觉得太大，可以增加曲率，这里设置为1500。

解决重叠问题：根据实际需要适当调整Z轴旋转角度，以达到我们理想的弯曲效果。

添加控制器：进入顶视图，使用EP曲线工具绘制箭头图案。

调整控制器：绘制完成后，删除历史、冻结变换，确保枢轴点居中，重命名，并用Ctrl+G打组。

对称控制器：复制一个一样的控制器，通过设置X轴缩放为-1，对称到另外一侧，然后再次重命名。

约束控制器：使用父对象约束，将右侧的控制器约束到对应的右侧变形器节点。

实现滚动展开：现在只要拖动这个控制器，就能实现滚动展开的效果。

锁定参数：由于我们只需要控制X轴的位移，选择其他参数将其锁定，以防止用户错误操作。

左侧的处理：对左侧的控制器进行类似的操作，锁定不需要的参数，确保控制器的功能正常。

绑定左侧：选择左侧的控制器，调整旋转角度，按下T键调出控制器点，通过鼠标左键拖动中间的控制器点形成弯曲，将右侧的控制器点往回拉至中心点重合。

调整适当的曲率：用左侧的控制器去约束左侧的变形器节点。

测试效果：选择控制器移动，如果是两侧同时展开，选择两个控制器，进入对象模式进行移动。

主副控制器：最后再创建两个控制器作为主副控制器。同样的删除历史、冻结变换，然后选择模型、变形器节点以及变形器控制组，将它们放到副控制器下。这样卷轴展开的模型就绑定好了。

通过这一系列的步骤，我们成功地在Maya中实现了卷轴展开效果的绑定。希望这些详细的操作能够帮助大家更好地理解和掌握Maya中的建模技巧。

Maya绑定教学：卷轴展开最先出现在喵喵动画屋。

Maya Advanced Skeleton 5 人物头发绑定

喵喵动画屋 — Wed, 09 Aug 2023 07:26:06 +0000

本次视频介绍人物头发的绑定。

1.打开骨骼透视，显示关节
2.创建并对齐骨骼
3.创建控制器，吸附到骨骼中心
4.把骨骼和控制器分别P给头部骨骼和控制
5.用控制器父对象约束对应的骨骼
6.选择所有骨骼加选头发，添加影响
7.绘制权重，解锁骨骼权重锁定
8.通过旋转角度来辅助绘制权重
9.测试最终绑定效果
10.通过高级骨骼绑定插件发布最终文件

1.身体绑定教程：https://youtu.be/EZPkVhTf2jw
2.乳房绑定教程：https://youtu.be/OR6ojxL1Sio
3.面部绑定教程：https://youtu.be/I-RuOuUBs9o
4.毛发绑定教材：https://youtu.be/LdYbtMcX9xw

Maya Advanced Skeleton 5 人物头发绑定最先出现在喵喵动画屋。