pyjallib 0.1.8__py3-none-any.whl → 0.1.10__py3-none-any.whl

pyjallib/max/bone.py

@@ -239,7 +239,7 @@ class Bone:
         nubBone.backfin = False
         nubBone.sidefins = False
         nubBone.name = self.name.remove_name_part("Index", inName)
-        nubBone.name = self.name.replace_name_part("Nub", nubBone.name, "Nub")
+        nubBone.name = self.name.replace_name_part("Nub", nubBone.name, self.name.get_name_part_value_by_description("Nub", "Nub"))
         
         # 화면 갱신 재개
         rt.enableSceneRedraw()
@@ -679,18 +679,18 @@ class Bone:
             inOriBone: 원본 뼈대
         """
         self.anim.save_xform(inSkinBone)
-        self.anim.set_xform(inSkinBone)
+        self.anim.set_xform(inSkinBone, space="World")
         
         self.anim.save_xform(inOriBone)
-        self.anim.set_xform(inOriBone)
         
         rt.setPropertyController(inSkinBone.controller, "Scale", rt.scaleXYZ())
         
         linkConst = rt.link_constraint()
+        linkConst.addTarget(inOriBone, 0)
+        
         inSkinBone.controller = linkConst
         
-        self.anim.set_xform([inSkinBone], space="world")
-        linkConst.addTarget(inOriBone, 0)
+        self.anim.set_xform(inSkinBone, space="World")
     
     def link_skin_bones(self, inSkinBoneArray, inOriBoneArray):
         """
@@ -705,14 +705,52 @@ class Bone:
             False: 실패
         """
         if len(inSkinBoneArray) != len(inOriBoneArray):
+            print("Error: Skin bone array and original bone array must have the same length.")
             return False
         
-        for i in range(len(inSkinBoneArray)):
-            self.link_skin_bone(inSkinBoneArray[i], inOriBoneArray[i])
+        skinBoneDict = {}
+        oriBoneDict = {}
+        
+        # 스킨 뼈대 딕셔너리 생성 (이름과 패턴화된 이름을 함께 저장)
+        for item in inSkinBoneArray:
+            # 아이템 저장
+            skinBoneDict[item.name] = item
+            # 언더스코어를 별표로 변환한 패턴 생성
+            namePattern = self.name.remove_name_part("Base", item.name)
+            namePattern = namePattern.replace("_", "*")
+            skinBoneDict[item.name + "_Pattern"] = namePattern
+        
+        # 원본 뼈대 딕셔너리 생성 (이름과 패턴화된 이름을 함께 저장)
+        for item in inOriBoneArray:
+            # 아이템 저장
+            oriBoneDict[item.name] = item
+            # 공백을 별표로 변환한 패턴 생성
+            namePattern = self.name.remove_name_part("Base", item.name)
+            namePattern = namePattern.replace(" ", "*")
+            oriBoneDict[item.name + "_Pattern"] = namePattern
+        
+        # 정렬된 배열 생성
+        sortedSkinBoneArray = []
+        sortedOriBoneArray = []
+        
+        # 같은 패턴을 가진 뼈대들을 찾아 매칭
+        for skinName, skinBone in [(k, v) for k, v in skinBoneDict.items() if not k.endswith("_Pattern")]:
+            skinPattern = skinBoneDict[skinName + "_Pattern"]
+            
+            for oriName, oriBone in [(k, v) for k, v in oriBoneDict.items() if not k.endswith("_Pattern")]:
+                oriPattern = oriBoneDict[oriName + "_Pattern"]
+                
+                if rt.matchPattern(skinName, pattern=oriPattern):
+                    sortedSkinBoneArray.append(skinBone)
+                    sortedOriBoneArray.append(oriBone)
+                    break
+        # 링크 연결 수행
+        for i in range(len(sortedSkinBoneArray)):
+            self.link_skin_bone(sortedSkinBoneArray[i], sortedOriBoneArray[i])
         
         return True
     
-    def create_skin_bone(self, inBoneArray, skipNub=True, mesh=True, link=True, skinBoneBaseName="b"):
+    def create_skin_bone(self, inBoneArray, skipNub=True, mesh=True, link=True, skinBoneBaseName=""):
         """
         스킨 뼈대 생성.
         
@@ -731,11 +769,13 @@ class Bone:
         skinBonePushAmount = -0.02
         returnBones = []
         
+        definedSkinBoneBaseName = self.name.get_name_part_value_by_description("Base", "SkinBone")
+        
         for i in range(len(inBoneArray)):
-            skinBoneName = self.name.replace_base(inBoneArray[i].name, skinBoneBaseName)
+            skinBoneName = self.name.replace_name_part("Base", inBoneArray[i].name, definedSkinBoneBaseName)
             skinBoneName = self.name.replace_filtering_char(skinBoneName, skinBoneFilteringChar)
             
-            skinBone = self.create_nub_bone("b_TempSkin", 2)
+            skinBone = self.create_nub_bone(f"{definedSkinBoneBaseName}_TempSkin", 2)
             skinBone.name = skinBoneName
             skinBone.wireColor = rt.Color(255, 88, 199)
             skinBone.transform = inBoneArray[i].transform
@@ -753,25 +793,32 @@ class Bone:
             
             skinBone.boneEnable = True
             skinBone.renderable = False
-            skinBone.boneScaleType = rt.Name("none")
+            skinBone.boneScaleType = rt.Name("None")
             
             bones.append(skinBone)
         
         for i in range(len(inBoneArray)):
             oriParentObj = inBoneArray[i].parent
             if oriParentObj is not None:
-                skinBoneParentObjName = self.name.replace_base(oriParentObj.name, skinBoneBaseName)
+                skinBoneParentObjName = self.name.replace_name_part("Base", oriParentObj.name, definedSkinBoneBaseName)
                 skinBoneParentObjName = self.name.replace_filtering_char(skinBoneParentObjName, skinBoneFilteringChar)
                 bones[i].parent = rt.getNodeByName(skinBoneParentObjName)
             else:
                 bones[i].parent = None
         
+        for item in bones:
+            item.showLinks = True
+            item.showLinksOnly = True
+        
+        for item in bones:
+            item.name = self.name.replace_name_part("Base", item.name, skinBoneBaseName)
+        
         if link:
             self.link_skin_bones(bones, inBoneArray)
         
         if skipNub:
             for item in bones:
-                if not rt.matchPattern(item.name, pattern=("*" + self.name.get_nub_str())):
+                if not rt.matchPattern(item.name, pattern=("*" + self.name.get_name_part_value_by_description("Nub", "Nub"))):
                     returnBones.append(item)
                 else:
                     rt.delete(item)
@@ -782,7 +829,7 @@ class Bone:
         
         return returnBones
     
-    def create_skin_bone_from_bip(self, inBoneArray, skipNub=True, mesh=False, link=True, skinBoneBaseName="b"):
+    def create_skin_bone_from_bip(self, inBoneArray, skipNub=True, mesh=False, link=True, skinBoneBaseName=""):
         """
         바이페드 객체에서 스킨 뼈대 생성.
         
@@ -791,7 +838,7 @@ class Bone:
             skipNub: Nub 뼈대 건너뛰기 (기본값: True)
             mesh: 메시 스냅샷 사용 (기본값: False)
             link: 원본 뼈대에 연결 (기본값: True)
-            skinBoneBaseName: 스킨 뼈대 기본 이름 (기본값: "b")
+            skinBoneBaseName: 스킨 뼈대 기본 이름 (기본값: "")
             
         Returns:
             생성된 스킨 뼈대 배열
@@ -806,7 +853,7 @@ class Bone:
         
         return returnSkinBones
     
-    def create_skin_bone_from_bip_for_unreal(self, inBoneArray, skipNub=True, mesh=False, link=True, skinBoneBaseName="b"):
+    def create_skin_bone_from_bip_for_unreal(self, inBoneArray, skipNub=True, mesh=False, link=True, skinBoneBaseName=""):
         """
         언리얼 엔진용 바이페드 객체에서 스킨 뼈대 생성.
         
@@ -837,6 +884,291 @@ class Bone:
         
         return genBones
     
+    def gen_missing_bip_bones_for_ue5manny(self, inBoneArray):
+        returnBones = []
+        spine3 = None
+        neck = None
+        
+        handL = None
+        handR = None
+        
+        fingerNames = ["index", "middle", "ring", "pinky"]
+        knuckleName = "metacarpal"
+        lKnuckleDistance = []
+        rKnuckleDistance = []
+        
+        lFingers = []
+        rFingers = []
+        
+        for item in inBoneArray:
+            if rt.matchPattern(item.name, pattern="*spine 03"):
+                spine3 = item
+            if rt.matchPattern(item.name, pattern="*neck 01"):
+                neck = item
+            if rt.matchPattern(item.name, pattern="*hand*l"):
+                handL = item
+            if rt.matchPattern(item.name, pattern="*hand*r"):
+                handR = item
+            
+            for fingerName in fingerNames:
+                if rt.matchPattern(item.name, pattern="*"+fingerName+"*01*l"):
+                    lFingers.append(item)
+                if rt.matchPattern(item.name, pattern="*"+fingerName+"*01*r"):
+                    rFingers.append(item)
+            for finger in lFingers:
+                fingerDistance = rt.distance(finger, handL)
+                lKnuckleDistance.append(fingerDistance)
+            for finger in rFingers:
+                fingerDistance = rt.distance(finger, handR)
+                rKnuckleDistance.append(fingerDistance)
+        
+        filteringChar = self.name._get_filtering_char(inBoneArray[-1].name)
+        isLower = inBoneArray[-1].name[0].islower()
+        spineName = self.name.get_name_part_value_by_description("Base", "Biped") + filteringChar + "Spine"
+        
+        spine4 = self.create_nub_bone(spineName, 2)
+        spine5 = self.create_nub_bone(spineName, 2)
+        
+        spine4.name = self.name.replace_name_part("Index", spine4.name, "4")
+        spine4.name = self.name.remove_name_part("Nub", spine4.name)
+        spine5.name = self.name.replace_name_part("Index", spine5.name, "5")
+        spine5.name = self.name.remove_name_part("Nub", spine5.name)
+        if isLower:
+            spine4.name = spine4.name.lower()
+            spine5.name = spine5.name.lower()
+        
+        spineDistance = rt.distance(spine3, neck)/3.0
+        rt.setProperty(spine4, "transform", spine3.transform)
+        rt.setProperty(spine5, "transform", spine3.transform)
+        self.anim.move_local(spine4, spineDistance, 0, 0)
+        self.anim.move_local(spine5, spineDistance * 2, 0, 0)
+        
+        returnBones.append(spine4)
+        returnBones.append(spine5)
+        
+        for i, finger in enumerate(lFingers):
+            knuckleBoneName = self.name.add_suffix_to_real_name(finger.name, filteringChar+knuckleName)
+            knuckleBoneName = self.name.remove_name_part("Index", knuckleBoneName)
+            
+            knuckleBone = self.create_nub_bone(knuckleBoneName, 2)
+            knuckleBone.name = self.name.remove_name_part("Nub", knuckleBone.name)
+            if isLower:
+                knuckleBone.name = knuckleBone.name.lower()
+                
+            knuckleBone.transform = finger.transform
+            lookAtConst = self.const.assign_lookat(knuckleBone, handL)
+            lookAtConst.upnode_world = False
+            lookAtConst.pickUpNode = handL
+            lookAtConst.lookat_vector_length = 0.0
+            lookAtConst.target_axisFlip = True
+            self.const.collapse(knuckleBone)
+            self.anim.move_local(knuckleBone, -lKnuckleDistance[i]*0.8, 0, 0)
+            
+            returnBones.append(knuckleBone)
+        
+        for i, finger in enumerate(rFingers):
+            knuckleBoneName = self.name.add_suffix_to_real_name(finger.name, filteringChar+knuckleName)
+            knuckleBoneName = self.name.remove_name_part("Index", knuckleBoneName)
+            
+            knuckleBone = self.create_nub_bone(knuckleBoneName, 2)
+            knuckleBone.name = self.name.remove_name_part("Nub", knuckleBone.name)
+            if isLower:
+                knuckleBone.name = knuckleBone.name.lower()
+                
+            knuckleBone.transform = finger.transform
+            lookAtConst = self.const.assign_lookat(knuckleBone, handR)
+            lookAtConst.upnode_world = False
+            lookAtConst.pickUpNode = handR
+            lookAtConst.lookat_vector_length = 0.0
+            lookAtConst.target_axisFlip = True
+            self.const.collapse(knuckleBone)
+            self.anim.move_local(knuckleBone, -rKnuckleDistance[i]*0.8, 0, 0)
+            
+            returnBones.append(knuckleBone)
+        
+        return returnBones
+    
+    def relink_missing_bip_bones_for_ue5manny(self, inBipArray, inMissingBoneArray):
+        returnBones = []
+        
+        spine3 = None
+        
+        handL = None
+        handR = None
+        
+        knuckleName = "metacarpal"
+        
+        for item in inBipArray:
+            if rt.matchPattern(item.name, pattern="*spine 03"):
+                spine3 = item
+            if rt.matchPattern(item.name, pattern="*hand*l"):
+                handL = item
+            if rt.matchPattern(item.name, pattern="*hand*r"):
+                handR = item
+        
+        for item in inMissingBoneArray:
+            if rt.matchPattern(item.name, pattern="*spine*"):
+                item.parent = spine3
+            if rt.matchPattern(item.name, pattern=f"*{knuckleName}*l"):
+                item.parent = handL
+            if rt.matchPattern(item.name, pattern=f"*{knuckleName}*r"):
+                item.parent = handR
+        
+        returnBones.append(inBipArray)
+        returnBones.append(inMissingBoneArray)
+        return returnBones
+    
+    def relink_missing_skin_bones_for_ue5manny(self, inSkinArray):
+        returnBones = []
+        spine3 = None
+        spine4 = None
+        spine5 = None
+        
+        neck = None
+        clavicleL = None
+        clavicleR = None
+        
+        handL = None
+        handR = None
+        
+        fingerNames = ["index", "middle", "ring", "pinky"]
+        knuckleName = "metacarpal"
+        
+        lFingers = []
+        rFingers = []
+        
+        for item in inSkinArray:
+            if rt.matchPattern(item.name, pattern="*spine*03"):
+                spine3 = item
+            if rt.matchPattern(item.name, pattern="*neck*01"):
+                neck = item
+            if rt.matchPattern(item.name, pattern="*clavicle*l"):
+                clavicleL = item
+            if rt.matchPattern(item.name, pattern="*clavicle*r"):
+                clavicleR = item
+            
+            if rt.matchPattern(item.name, pattern="*hand*l"):
+                handL = item
+            if rt.matchPattern(item.name, pattern="*hand*r"):
+                handR = item
+            
+            for fingerName in fingerNames:
+                if rt.matchPattern(item.name, pattern="*"+fingerName+"*01*l"):
+                    lFingers.append(item)
+                if rt.matchPattern(item.name, pattern="*"+fingerName+"*01*r"):
+                    rFingers.append(item)
+        
+        for item in inSkinArray:
+            if rt.matchPattern(item.name, pattern="*spine*04"):
+                spine4 = item
+                item.parent = spine3
+            
+            if rt.matchPattern(item.name, pattern="*spine*05"):
+                spine5 = item
+                item.parent = spine4
+                neck.parent = spine5
+                clavicleL.parent = spine5
+                clavicleR.parent = spine5
+            
+            if rt.matchPattern(item.name, pattern=f"*{knuckleName}*l"):
+                item.parent = handL
+            if rt.matchPattern(item.name, pattern=f"*{knuckleName}*r"):
+                item.parent = handR
+                
+        filteringChar = self.name._get_filtering_char(inSkinArray[-1].name)
+        
+        for item in lFingers:
+            fingerNamePattern = self.name.add_suffix_to_real_name(item.name, filteringChar+knuckleName)
+            fingerNamePattern = self.name.remove_name_part("Index", fingerNamePattern)
+            for knuckle in inSkinArray:
+                if rt.matchPattern(knuckle.name, pattern=fingerNamePattern):
+                    item.parent = knuckle
+                    break
+        
+        for item in rFingers:
+            fingerNamePattern = self.name.add_suffix_to_real_name(item.name, filteringChar+knuckleName)
+            fingerNamePattern = self.name.remove_name_part("Index", fingerNamePattern)
+            for knuckle in inSkinArray:
+                if rt.matchPattern(knuckle.name, pattern=fingerNamePattern):
+                    item.parent = knuckle
+                    break
+        
+        return returnBones
+    
+    def create_skin_bone_from_bip_for_ue5manny(self, inBoneArray, skipNub=True, mesh=False, link=True, isHuman=False, skinBoneBaseName=""):
+        targetBones = [item for item in inBoneArray 
+                      if (rt.classOf(item) == rt.Biped_Object) 
+                      and (not rt.matchPattern(item.name, pattern="*Twist*")) 
+                      and (item != item.controller.rootNode)]
+        
+        missingBipBones = []
+        
+        if isHuman:
+            missingBipBones = self.gen_missing_bip_bones_for_ue5manny(targetBones)
+            self.relink_missing_bip_bones_for_ue5manny(targetBones, missingBipBones)
+        
+        for item in missingBipBones:
+            targetBones.append(item)
+        
+        sortedBipBones = self.sort_bones_as_hierarchy(targetBones)
+        
+        skinBones = self.create_skin_bone(sortedBipBones, skipNub=skipNub, mesh=mesh, link=False, skinBoneBaseName=skinBoneBaseName)
+        if len(skinBones) == 0:
+            return False
+        
+        for item in skinBones:
+            if rt.matchPattern(item.name, pattern="*pelvis*"):
+                self.anim.rotate_local(item, 180, 0, 0, dontAffectChildren=True)
+            if rt.matchPattern(item.name, pattern="*spine*"):
+                self.anim.rotate_local(item, 180, 0, 0, dontAffectChildren=True)
+            if rt.matchPattern(item.name, pattern="*neck*"):
+                self.anim.rotate_local(item, 180, 0, 0, dontAffectChildren=True)
+            if rt.matchPattern(item.name, pattern="*head*"):
+                self.anim.rotate_local(item, 180, 0, 0, dontAffectChildren=True)
+            if rt.matchPattern(item.name, pattern="*thigh*l"):
+                self.anim.rotate_local(item, 0, 0, 180, dontAffectChildren=True)
+            if rt.matchPattern(item.name, pattern="*calf*l"):
+                self.anim.rotate_local(item, 0, 0, 180, dontAffectChildren=True)
+            if rt.matchPattern(item.name, pattern="*foot*l"):
+                self.anim.rotate_local(item, 0, 0, 180, dontAffectChildren=True)
+            if rt.matchPattern(item.name, pattern="*ball*r"):
+                self.anim.rotate_local(item, 0, 0, 180, dontAffectChildren=True)
+                
+            if rt.matchPattern(item.name, pattern="*clavicle*r"):
+                self.anim.rotate_local(item, 0, 0, -180, dontAffectChildren=True)
+            if rt.matchPattern(item.name, pattern="*upperarm*r"):
+                self.anim.rotate_local(item, 0, 0, -180, dontAffectChildren=True)
+            if rt.matchPattern(item.name, pattern="*lowerarm*r"):
+                self.anim.rotate_local(item, 0, 0, -180, dontAffectChildren=True)
+            if rt.matchPattern(item.name, pattern="*hand*r"):
+                self.anim.rotate_local(item, 0, 0, -180, dontAffectChildren=True)
+            
+            if rt.matchPattern(item.name, pattern="*thumb*r"):
+                self.anim.rotate_local(item, 0, 0, 180, dontAffectChildren=True)
+            if rt.matchPattern(item.name, pattern="*index*r"):
+                self.anim.rotate_local(item, 0, 0, 180, dontAffectChildren=True)
+            if rt.matchPattern(item.name, pattern="*middle*r"):
+                self.anim.rotate_local(item, 0, 0, 180, dontAffectChildren=True)
+            if rt.matchPattern(item.name, pattern="*ring*r"):
+                self.anim.rotate_local(item, 0, 0, 180, dontAffectChildren=True)
+            if rt.matchPattern(item.name, pattern="*pinky*r"):
+                self.anim.rotate_local(item, 0, 0, 180, dontAffectChildren=True)
+            
+            if rt.matchPattern(item.name, pattern="*metacarpal*"):
+                tempArray = self.name._split_to_array(item.name)
+                item.name = self.name._combine(tempArray, inFilChar="_")
+                item.name = self.name.remove_name_part("Base", item.name)
+            
+            self.anim.save_xform(item)
+            
+        self.relink_missing_skin_bones_for_ue5manny(skinBones)
+        
+        self.link_skin_bones(skinBones, sortedBipBones)
+        for item in skinBones:
+            self.anim.save_xform(item)
+        
+        return skinBones
+    
     def set_bone_on(self, inBone):
         """
         뼈대 활성화.

pyjallib/max/constraint.py

@@ -233,6 +233,8 @@ class Constraint:
         # 마지막 타겟에 특정 가중치 적용
         targetNum = targetPosConst.getNumTargets()
         targetPosConst.SetWeight(targetNum, inWeight)
+        
+        return targetPosConst
     
     def assign_pos_xyz(self, inObj):
         """
@@ -443,6 +445,8 @@ class Constraint:
         # 마지막 타겟에 특정 가중치 적용
         targetNum = targetRotConstraint.getNumTargets()
         targetRotConstraint.SetWeight(targetNum, inWeight)
+        
+        return targetRotConstraint
     
     def assign_euler_xyz(self, inObj):
         """
@@ -609,6 +613,8 @@ class Constraint:
             rot_list = self.get_rot_list_controller(inObj)
             rt.setPropertyController(rot_list, "Available", targetRotConstraint)
             rot_list.setActive(rot_list.count)
+            
+            return targetRotConstraint
     
     def assign_rot_const_scripted(self, inObj, inTarget):
         """
@@ -635,32 +641,19 @@ class Constraint:
         rot_list.setActive(rot_list.count)
         
         # 헬퍼 객체 이름 생성
-        if self.name:
-            rotPointName = self.name.replace_Type(inObj.name, self.name.get_dummy_value())
-            rotMeasurePointName = self.name.increase_index(rotPointName, 1)
-            rotExpName = self.name.replace_Type(inObj.name, self.name.get_exposeTm_value())
-            rotExpName = self.name.replace_Index(rotExpName, "0")
-            
-            print(f"dumStr: {self.name.get_dummy_value()}")
-            print(f"exposeTmStr: {self.name.get_exposeTm_value()}")
-            print(f"rotPointName: {rotPointName}, rotMeasurePointName: {rotMeasurePointName}, rotExpName: {rotExpName}")
-        else:
-            # name 서비스가 없는 경우 기본 이름 사용
-            base_name = rt.getProperty(inObj, "name")
-            rotPointName = f"dum_{base_name}"
-            rotMeasurePointName = f"dum_{base_name}_01"
-            rotExpName = f"exp_{base_name}_0"
+        rotPointName = self.name.replace_Type(inObj.name, self.name.get_dummy_value())
+        rotMeasurePointName = self.name.increase_index(rotPointName, 1)
+        rotExpName = self.name.replace_Type(inObj.name, self.name.get_exposeTm_value())
+        rotExpName = self.name.replace_Index(rotExpName, "0")
+        
+        print(f"dumStr: {self.name.get_dummy_value()}")
+        print(f"exposeTmStr: {self.name.get_exposeTm_value()}")
+        print(f"rotPointName: {rotPointName}, rotMeasurePointName: {rotMeasurePointName}, rotExpName: {rotExpName}")
         
         # 헬퍼 객체 생성
-        if self.helper:
-            rotPoint = self.helper.create_point(rotPointName, size=2, boxToggle=True, crossToggle=False)
-            rotMeasuerPoint = self.helper.create_point(rotMeasurePointName, size=3, boxToggle=True, crossToggle=False)
-            rotExpPoint = rt.ExposeTm(name=rotExpName, size=3, box=False, cross=True, wirecolor=rt.Color(14, 255, 2))
-        else:
-            # 직접 헬퍼 객체 생성
-            rotPoint = rt.Point(name=rotPointName, size=2, box=True, cross=False)
-            rotMeasuerPoint = rt.Point(name=rotMeasurePointName, size=3, box=True, cross=False)
-            rotExpPoint = rt.ExposeTm(name=rotExpName, size=3, box=False, cross=True, wirecolor=rt.Color(14, 255, 2))
+        rotPoint = self.helper.create_point(rotPointName, size=2, boxToggle=True, crossToggle=False)
+        rotMeasuerPoint = self.helper.create_point(rotMeasurePointName, size=3, boxToggle=True, crossToggle=False)
+        rotExpPoint = rt.ExposeTm(name=rotExpName, size=3, box=False, cross=True, wirecolor=rt.Color(14, 255, 2))
         
         # 초기 변환 설정
         rt.setProperty(rotPoint, "transform", rt.getProperty(inObj, "transform"))
@@ -710,22 +703,20 @@ class Constraint:
         targetObjArray = inTarget
         
         # 객체 이름 생성
-        if self.name:
-            objName = self.name.get_string(oriObj.name)
-            indexVal = self.name.get_index_as_digit(oriObj.name)
-            indexNum = 0 if indexVal is False else indexVal
-            dummyName = self.name.add_prefix_to_real_name(objName, self.name.get_dummy_value())
-            
-            lookAtPointName = self.name.replace_Index(dummyName, str(indexNum))
-            lookAtMeasurePointName = self.name.replace_Index(dummyName, str(indexNum+1))
-            lookAtExpPointName = dummyName + self.name.get_exposeTm_value()
-            lookAtExpPointName = self.name.replace_Index(lookAtExpPointName, "0")
+        objName = self.name.get_string(oriObj.name)
+        indexVal = self.name.get_index_as_digit(oriObj.name)
+        indexNum = 0 if indexVal is False else indexVal
+        dummyName = self.name.add_prefix_to_real_name(objName, self.name.get_dummy_value())
+        
+        lookAtPointName = self.name.replace_Index(dummyName, str(indexNum))
+        lookAtMeasurePointName = self.name.replace_Index(dummyName, str(indexNum+1))
+        lookAtExpPointName = dummyName + self.name.get_exposeTm_value()
+        lookAtExpPointName = self.name.replace_Index(lookAtExpPointName, "0")
         
         # 헬퍼 객체 생성
-        if self.helper:
-            lookAtPoint = self.helper.create_point(lookAtPointName, size=2, boxToggle=True, crossToggle=False)
-            lookAtMeasurePoint = self.helper.create_point(lookAtMeasurePointName, size=3, boxToggle=True, crossToggle=False)
-            lookAtExpPoint = rt.ExposeTm(name=lookAtExpPointName, size=3, box=False, cross=True, wirecolor=rt.Color(14, 255, 2))
+        lookAtPoint = self.helper.create_point(lookAtPointName, size=2, boxToggle=True, crossToggle=False)
+        lookAtMeasurePoint = self.helper.create_point(lookAtMeasurePointName, size=3, boxToggle=True, crossToggle=False)
+        lookAtExpPoint = rt.ExposeTm(name=lookAtExpPointName, size=3, box=False, cross=True, wirecolor=rt.Color(14, 255, 2))
         
         # 초기 변환 설정
         rt.setProperty(lookAtPoint, "transform", rt.getProperty(oriObj, "transform"))