def createControl(controlType=None, color=0): ''' controlType (string) - eyeball, uppereyelid, lowereyelid return name of control (string) ''' createdCurves = [] if controlType == 'eyeball': # eyeball control createdCurves.append(mc.curve( d = 3,p = [[-2.0, 0.0, 0.0], [-1.7410218346353992, 0.2589781653646009, 0.0], [-1.0960546349793177, 0.6343203989838185, 0.0], [-2.446163389034639e-16, 0.8074550147753012, 0.0], [1.0960546349793174, 0.6343203989838179, 0.0], [1.7410218346353985, 0.2589781653646016, 0.0], [2.0, 0.0, 0.0]],k = (0.0, 0.0, 0.0, 1.0, 2.0, 3.0, 4.0, 4.0, 4.0))) createdCurves.append(mc.curve( d = 3,p = [[4.286263797015736e-17, 0.7, 0.0], [-0.17811519070418735, 0.7, 0.0], [-0.5489785167141249, 0.5494107756462852, 0.0], [-0.7747646195700771, 0.003382897653852665, 0.0], [-0.5519230240326511, -0.54461646726576, 0.0], [-0.0067656301510380795, -0.7752644262815899, 0.0], [0.5423340955436322, -0.5541659044773989, 0.0], [0.7747056588706507, -0.010139124611810102, 0.0], [0.5584834447845943, 0.5397461015249914, 0.0], [0.1903047474040215, 0.69678484790865, 0.0], [0.0122166845060987, 0.6998933866094739, 0.0]],k = (0.0, 0.0, 0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 8.0, 8.0))) createdCurves.append(mc.curve( d = 3,p = [[-2.0, 0.0, 0.0], [-1.7410218346353992, -0.2589781653646009, 0.0], [-1.0960546349793177, -0.6343203989838185, 0.0], [-2.446163389034639e-16, -0.8074550147753012, 0.0], [1.0960546349793174, -0.6343203989838179, 0.0], [1.7410218346353985, -0.2589781653646016, 0.0], [2.0, 0.0, 0.0]],k = (0.0, 0.0, 0.0, 1.0, 2.0, 3.0, 4.0, 4.0, 4.0))) elif controlType == 'uppereyelid': # uppereyelid control createdCurves.append(mc.curve( d = 3,p = [[-2.0, 0.0, 0.0], [-1.7410218346353992, 0.2589781653646009, 0.0], [-1.0960546349793177, 0.6343203989838185, 0.0], [-2.446163389034639e-16, 0.8074550147753012, 0.0], [1.0960546349793174, 0.6343203989838179, 0.0], [1.7410218346353985, 0.2589781653646016, 0.0], [2.0, 0.0, 0.0]],k = (0.0, 0.0, 0.0, 1.0, 2.0, 3.0, 4.0, 4.0, 4.0))) createdCurves.append(mc.curve( d = 3,p = [[-2.0, 0.0, 0.0], [-1.6741765841276626, 0.0826315157302451, 0.0], [-1.0063776917734268, 0.16297797352985877, 0.0], [1.2342828582118104e-15, 0.20455714681939524, 0.0], [1.0063776917734248, 0.16297797352985888, 0.0], [1.6741765841276648, 0.08263151573024477, 0.0], [2.0, 0.0, 0.0]],k = (0.0, 0.0, 0.0, 1.0, 2.0, 3.0, 4.0, 4.0, 4.0))) elif controlType == 'lowereyelid': # lowereyelid control createdCurves.append(mc.curve( d = 3,p = [[-2.0, 0.0, 0.0], [-1.7410218346353992, -0.2589781653646009, 0.0], [-1.0960546349793177, -0.6343203989838185, 0.0], [-2.446163389034639e-16, -0.8074550147753012, 0.0], [1.0960546349793174, -0.6343203989838179, 0.0], [1.7410218346353985, -0.2589781653646016, 0.0], [2.0, 0.0, 0.0]],k = (0.0, 0.0, 0.0, 1.0, 2.0, 3.0, 4.0, 4.0, 4.0))) createdCurves.append(mc.curve( d = 3,p = [[-2.0, 0.0, 0.0], [-1.6741765841276626, -0.0826315157302451, 0.0], [-1.0063776917734268, -0.16297797352985877, 0.0], [1.2342828582118104e-15, -0.20455714681939524, 0.0], [1.0063776917734248, -0.16297797352985888, 0.0], [1.6741765841276648, -0.08263151573024477, 0.0], [2.0, 0.0, 0.0]],k = (0.0, 0.0, 0.0, 1.0, 2.0, 3.0, 4.0, 4.0, 4.0))) else: pass crv = curves.combineCurves(createdCurves) curves.setColorByIndex(crv, color) return crv
def createSizeTemplateControl(self): """ >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> DESCRIPTION: Generates a sizeTemplateObject. It's been deleted, it recreates it. Guess the size based off of there being a mesh there. If there is no mesh, it sets sets an intial size of a [155,170,29] unit character. ARGUMENTS: self.PuppetNull.nameShort(string) RETURNS: returnList(list) = [startCrv(string),EndCrv(list)] >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> """ #>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> # Get info #>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> startColors = modules.returnSettingsData('colorStart') endColors = modules.returnSettingsData('colorEnd') font = mc.getAttr((self.msgSettingsInfo.get() + '.font')) """ checks for there being anything in our geo group """ if not self.geo: return guiFactory.warning( 'Need some geo defined to make this tool worthwhile') boundingBoxSize = modules.returnSettingsDataAsFloat( 'meshlessSizeTemplate') else: boundingBoxSize = distance.returnBoundingBoxSize( self.msgGeoGroup.get()) boundingBox = mc.exactWorldBoundingBox(self.msgGeoGroup.get()) """determine orienation """ maxSize = max(boundingBoxSize) matchIndex = boundingBoxSize.index(maxSize) """Find the pivot of the bounding box """ pivotPosition = distance.returnCenterPivotPosition( self.msgGeoGroup.get()) #>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> # Get our positions #>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> if self.optionPuppetMode.get() == 0: #If bio... if matchIndex == 1 or matchIndex == 0: #Vertical posBuffers = [[0, .5, 0], [0, .75, 0]] width = (boundingBoxSize[0] / 2) height = (boundingBoxSize[1]) depth = boundingBoxSize[2] for cnt, pos in enumerate(posBuffers): posBuffer = posBuffers[cnt] posBuffer[0] = 0 posBuffer[1] = (posBuffer[1] * height) posBuffer[2] = 0 elif matchIndex == 2: #Horizontal posBuffers = [[0, 0, -.33], [0, 0, .66]] width = boundingBoxSize[1] height = boundingBoxSize[2] / 2 depth = (boundingBoxSize[0]) for cnt, pos in enumerate(posBuffers): posBuffer = posBuffers[cnt] posBuffer[0] = 0 posBuffer[1] = boundingBoxSize[1] * .75 posBuffer[2] = (posBuffer[2] * height) else: #Otherwise if matchIndex == 1 or matchIndex == 0: #Vertical width = (boundingBoxSize[0] / 2) height = (boundingBoxSize[1]) depth = boundingBoxSize[2] posBuffers = [[0, boundingBox[1], 0], [0, boundingBox[4], 0]] elif matchIndex == 2: #Horizontal width = boundingBoxSize[0] height = boundingBoxSize[2] / 2 depth = (boundingBoxSize[1]) startHeight = max([boundingBox[4], boundingBox[1]]) - depth / 2 print startHeight posBuffers = [[0, startHeight, boundingBox[2]], [0, startHeight, boundingBox[5]]] # Simple reverse of start pos buffers if the object is pointing negative if self.optionAimAxis < 2: posBuffers.reverse() #>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> # Making the controls #>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> """ make our control object """ startCurves = [] startCurve = curves.createControlCurve('circle', depth * .8) mc.xform(startCurve, t=posBuffers[0], ws=True) attributes.doSetAttr(startCurve, 'rotateOrder', 5) curves.setCurveColorByName(startCurve, startColors[1]) startCurves.append(startCurve) startText = curves.createTextCurve('start', size=depth * .75, font=font) mc.xform(startText, t=posBuffers[0], ws=True) curves.setCurveColorByName(startText, startColors[0]) startCurves.append(startText) endCurves = [] endCurve = curves.createControlCurve('circle', depth * .8) mc.xform(endCurve, t=posBuffers[1], ws=True) curves.setCurveColorByName(endCurve, endColors[1]) attributes.doSetAttr(endCurve, 'rotateOrder', 5) endCurves.append(endCurve) endText = curves.createTextCurve('end', size=depth * .6, font=font) mc.xform(endText, t=posBuffers[1], ws=True) curves.setCurveColorByName(endText, endColors[0]) endCurves.append(endText) """ aiming """ position.aimSnap(startCurve, endCurve, [0, 0, 1], [0, 1, 0]) position.aimSnap(startText, endCurve, [0, 0, 1], [0, 1, 0]) position.aimSnap(endCurve, startCurve, [0, 0, -1], [0, 1, 0]) position.aimSnap(endText, startCurve, [0, 0, -1], [0, 1, 0]) sizeCurveControlStart = curves.combineCurves(startCurves) sizeCurveControlEnd = curves.combineCurves(endCurves) """ store our info to name our objects""" attributes.storeInfo(sizeCurveControlStart, 'cgmName', (self.PuppetNull.nameShort + '.cgmName')) attributes.storeInfo(sizeCurveControlStart, 'cgmDirection', 'start') attributes.storeInfo(sizeCurveControlStart, 'cgmType', 'templateSizeObject') sizeCurveControlStart = NameFactory.doNameObject(sizeCurveControlStart) mc.makeIdentity(sizeCurveControlStart, apply=True, t=True, s=True, r=True) attributes.storeInfo(sizeCurveControlEnd, 'cgmName', (self.PuppetNull.nameShort + '.cgmName')) attributes.storeInfo(sizeCurveControlEnd, 'cgmDirection', 'end') attributes.storeInfo(sizeCurveControlEnd, 'cgmType', 'templateSizeObject') sizeCurveControlEnd = NameFactory.doNameObject(sizeCurveControlEnd) endGroup = rigging.groupMeObject(sizeCurveControlEnd) mc.makeIdentity(sizeCurveControlEnd, apply=True, t=True, s=True, r=True) mc.parentConstraint(sizeCurveControlStart, endGroup, maintainOffset=True) """ make control group """ controlGroup = rigging.groupMeObject(sizeCurveControlStart) attributes.storeInfo(controlGroup, 'cgmName', (self.PuppetNull.nameShort + '.cgmName')) attributes.storeInfo(controlGroup, 'cgmType', 'templateSizeObjectGroup') controlGroup = NameFactory.doNameObject(controlGroup) endGroup = rigging.doParentReturnName(endGroup, controlGroup) #>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> # Getting data ready #>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> attributes.storeInfo(controlGroup, 'controlStart', sizeCurveControlStart) attributes.storeInfo(controlGroup, 'controlEnd', sizeCurveControlEnd) attributes.storeInfo(self.PuppetNull.nameShort, 'templateSizeObject', controlGroup) self.templateSizeObjects['root'] = controlGroup self.templateSizeObjects['start'] = sizeCurveControlStart self.templateSizeObjects['end'] = sizeCurveControlEnd returnList = [] returnList.append(sizeCurveControlStart) returnList.append(sizeCurveControlEnd) return returnList
def createWrapControlShape( targetObjects, targetGeo=None, latheAxis='z', aimAxis='y+', objectUp='y+', points=8, curveDegree=1, insetMult=None, #Inset multiplier minRotate=None, maxRotate=None, posOffset=[], rootOffset=[], #offset root before cast rootRotate=None, joinMode=False, extendMode=None, closedCurve=True, l_specifiedRotates=None, maxDistance=1000, closestInRange=True, vectorOffset=None, midMeshCast=False, subSize=None, #For ball on loli for example rotateBank=None, joinHits=None, #keys to processed hits to see what to join axisToCheck=['x', 'y'], **kws): #'segment,radial,disc' """ This function lathes an axis of an object, shoot rays out the aim axis at the provided mesh and returning hits. it then uses this information to build a curve shape. :parameters: mesh(string) | Surface to cast at mi_obj(string/mObj) | our casting object latheAxis(str) | axis of the objec to lathe TODO: add validation aimAxis(str) | axis to shoot out of points(int) | how many points you want in the curve curveDegree(int) | specified degree minRotate(float) | let's you specify a valid range to shoot maxRotate(float) | let's you specify a valid range to shoot posOffset(vector) | transformational offset for the hit from a normalized locator at the hit. Oriented to the surface markHits(bool) | whether to keep the hit markers returnDict(bool) | whether you want all the infomation from the process. rotateBank (float) | let's you add a bank to the rotation object l_specifiedRotates(list of values) | specify where to shoot relative to an object. Ignores some other settings maxDistance(float) | max distance to cast rays closestInRange(bool) | True by default. If True, takes first hit. Else take the furthest away hit in range. :returns: Dict ------------------------------------------------------------------ 'source'(double3) | point from which we cast 'hit'(double3) | world space points | active during single return 'hits'(list) | world space points | active during multi return 'uv'(double2) | uv on surface of hit | only works for mesh surfaces :raises: Exception | if reached """ _str_func = "createWrapControlShape" log.debug(">> %s >> " % (_str_func) + "=" * 75) _joinModes = [] _extendMode = [] if type(targetObjects) not in [list, tuple]: targetObjects = [targetObjects] targetGeo = VALID.objStringList(targetGeo, calledFrom=_str_func) assert type(points) is int, "Points must be int: %s" % points assert type(curveDegree) is int, "Points must be int: %s" % points assert curveDegree > 0, "Curve degree must be greater than 1: %s" % curveDegree if posOffset is not None and len(posOffset) and len(posOffset) != 3: raise StandardError, "posOffset must be len(3): %s | len: %s" % ( posOffset, len(posOffset)) if rootOffset is not None and len(rootOffset) and len(rootOffset) != 3: raise StandardError, "rootOffset must be len(3): %s | len: %s" % ( rootOffset, len(rootOffset)) if rootRotate is not None and len(rootRotate) and len(rootRotate) != 3: raise StandardError, "rootRotate must be len(3): %s | len: %s" % ( rootRotate, len(rootRotate)) if extendMode in ['loliwrap', 'cylinder', 'disc'] and insetMult is None: insetMult = 1 for axis in ['x', 'y', 'z']: if axis in latheAxis.lower(): latheAxis = axis log.debug("targetObjects: %s" % targetObjects) if len(aimAxis) == 2: single_aimAxis = aimAxis[0] else: single_aimAxis = aimAxis mAxis_aim = VALID.simpleAxis(aimAxis) log.debug("Single aim: %s" % single_aimAxis) log.debug("createWrapControlShape>> midMeshCast: %s" % midMeshCast) log.debug("|{0}| >> extendMode: {1}".format(_str_func, extendMode)) #>> Info l_groupsBuffer = [] il_curvesToCombine = [] l_sliceReturns = [] #Need to do more to get a better size #>> Build curves #================================================================= #> Root curve # log.debug("RootRotate: %s" % rootRotate) mi_rootLoc = cgmMeta.cgmNode(targetObjects[0]).doLoc() if rootOffset: log.debug("rootOffset: %s" % rootOffset) mc.move(rootOffset[0], rootOffset[1], rootOffset[2], [mi_rootLoc.mNode], r=True, rpr=True, os=True, wd=True) if rootRotate is not None and len(rootRotate): log.debug("rootRotate: %s" % rootRotate) mc.rotate(rootRotate[0], rootRotate[1], rootRotate[2], [mi_rootLoc.mNode], os=True, r=True) #>> Root mi_rootLoc.doGroup() #Group to zero if extendMode == 'segment': log.debug("segment mode. Target len: %s" % len(targetObjects[1:])) if len(targetObjects) < 2: log.warning( "Segment build mode only works with two objects or more") else: if insetMult is not None: rootDistanceToMove = distance.returnDistanceBetweenObjects( targetObjects[0], targetObjects[1]) log.debug("rootDistanceToMove: %s" % rootDistanceToMove) mi_rootLoc.__setattr__('t%s' % latheAxis, rootDistanceToMove * insetMult) #mi_rootLoc.tz = (rootDistanceToMove*insetMult)#Offset it #Notes -- may need to play with up object for aim snapping #mi_upLoc = cgmMeta.cgmNode(targetObjects[0]).doLoc() #mi_upLoc.doGroup()#To zero objectUpVector = dictionary.returnStringToVectors(objectUp) log.debug("objectUpVector: %s" % objectUpVector) #mi_uploc for i, obj in enumerate(targetObjects[1:]): log.debug("i: %s" % i) #> End Curve mi_endLoc = cgmMeta.cgmNode(obj).doLoc() aimVector = dictionary.returnStringToVectors(latheAxis + '-') log.debug("segment aimback: %s" % aimVector) #Snap.go(mi_endLoc.mNode,mi_rootLoc.mNode,move=False,aim=True,aimVector=aimVector,upVector=objectUpVector) #Snap.go(mi_endLoc.mNode,mi_rootLoc.mNode,move=False,orient=True) SNAP.go(mi_endLoc.mNode, mi_rootLoc.mNode, position=False, rotation=True) mi_endLoc.doGroup() if i == len(targetObjects[1:]) - 1: if insetMult is not None: log.debug("segment insetMult: %s" % insetMult) distanceToMove = distance.returnDistanceBetweenObjects( targetObjects[-1], targetObjects[0]) log.debug("distanceToMove: %s" % distanceToMove) #mi_endLoc.tz = -(distanceToMove*insetMult)#Offset it mi_endLoc.__setattr__('t%s' % latheAxis, -(distanceToMove * insetMult)) log.debug("segment lathe: %s" % latheAxis) log.debug("segment aim: %s" % aimAxis) log.debug("segment rotateBank: %s" % rotateBank) d_endCastInfo = createMeshSliceCurve( targetGeo, mi_endLoc, midMeshCast=midMeshCast, curveDegree=curveDegree, latheAxis=latheAxis, aimAxis=aimAxis, posOffset=posOffset, points=points, returnDict=True, closedCurve=closedCurve, maxDistance=maxDistance, closestInRange=closestInRange, rotateBank=rotateBank, l_specifiedRotates=l_specifiedRotates, axisToCheck=axisToCheck) l_sliceReturns.append(d_endCastInfo) mi_end = cgmMeta.cgmObject(d_endCastInfo['curve']) il_curvesToCombine.append(mi_end) mc.delete(mi_endLoc.parent) #delete the loc elif extendMode == 'radial': log.debug("|{0}| >> radial...".format(_str_func)) d_handleInner = createMeshSliceCurve( targetGeo, mi_rootLoc, midMeshCast=midMeshCast, curveDegree=curveDegree, latheAxis=latheAxis, aimAxis=aimAxis, posOffset=0, points=points, returnDict=True, closedCurve=closedCurve, maxDistance=maxDistance, closestInRange=closestInRange, rotateBank=rotateBank, l_specifiedRotates=l_specifiedRotates, axisToCheck=axisToCheck) mi_buffer = cgmMeta.cgmObject(d_handleInner['curve']) #instance curve l_sliceReturns.append(d_handleInner) il_curvesToCombine.append(mi_buffer) elif extendMode == 'disc': log.debug("|{0}| >> disc...".format(_str_func)) d_size = returnBaseControlSize(mi_rootLoc, targetGeo, axis=[aimAxis]) #Get size #discOffset = d_size[ d_size.keys()[0]]*insetMult size = False l_absSize = [abs(i) for i in posOffset] if l_absSize: size = max(l_absSize) if not size: d_size = returnBaseControlSize(mi_rootLoc, targetGeo, axis=[aimAxis]) #Get size log.debug("d_size: %s" % d_size) size = d_size[d_size.keys()[0]] * insetMult discOffset = size log.debug("d_size: %s" % d_size) log.debug("discOffset is: %s" % discOffset) mi_rootLoc.__setattr__('t%s' % latheAxis, discOffset) if posOffset: tmp_posOffset = [ posOffset[0] * .5, posOffset[1] * .5, posOffset[2] * .5 ] d_handleInnerUp = createMeshSliceCurve( targetGeo, mi_rootLoc, curveDegree=curveDegree, midMeshCast=midMeshCast, latheAxis=latheAxis, aimAxis=aimAxis, posOffset=tmp_posOffset, points=points, returnDict=True, closedCurve=closedCurve, maxDistance=maxDistance, closestInRange=closestInRange, rotateBank=rotateBank, l_specifiedRotates=l_specifiedRotates, axisToCheck=axisToCheck) mi_buffer = cgmMeta.cgmObject( d_handleInnerUp['curve']) #instance curve l_sliceReturns.append(d_handleInnerUp) il_curvesToCombine.append(mi_buffer) mi_rootLoc.__setattr__('t%s' % latheAxis, -discOffset) d_handleInnerDown = createMeshSliceCurve( targetGeo, mi_rootLoc, curveDegree=curveDegree, midMeshCast=midMeshCast, latheAxis=latheAxis, aimAxis=aimAxis, posOffset=tmp_posOffset, points=points, returnDict=True, closedCurve=closedCurve, maxDistance=maxDistance, closestInRange=closestInRange, rotateBank=rotateBank, l_specifiedRotates=l_specifiedRotates, axisToCheck=axisToCheck) mi_buffer = cgmMeta.cgmObject( d_handleInnerDown['curve']) #instance curve l_sliceReturns.append(d_handleInnerDown) il_curvesToCombine.append(mi_buffer) mi_rootLoc.tz = 0 elif extendMode == 'cylinder': log.debug("|{0}| >> cylinder...".format(_str_func)) d_size = returnBaseControlSize(mi_rootLoc, targetGeo, axis=[aimAxis]) #Get size discOffset = d_size[d_size.keys()[0]] * insetMult log.debug("d_size: %s" % d_size) log.debug("discOffset is: %s" % discOffset) mi_rootLoc.__setattr__('t%s' % latheAxis, discOffset) d_handleInnerUp = createMeshSliceCurve( targetGeo, mi_rootLoc, curveDegree=curveDegree, midMeshCast=midMeshCast, latheAxis=latheAxis, aimAxis=aimAxis, posOffset=posOffset, points=points, returnDict=True, closedCurve=closedCurve, maxDistance=maxDistance, closestInRange=closestInRange, rotateBank=rotateBank, l_specifiedRotates=l_specifiedRotates, axisToCheck=axisToCheck) mi_buffer = cgmMeta.cgmObject( d_handleInnerUp['curve']) #instance curve l_sliceReturns.append(d_handleInnerUp) il_curvesToCombine.append(mi_buffer) mi_rootLoc.__setattr__('t%s' % latheAxis, 0) elif extendMode == 'loliwrap': log.debug("|{0}| >> lolipop...".format(_str_func)) #l_absSize = [abs(i) for i in posOffset] size = False #if l_absSize: #log.debug("l_absSize: %s"%l_absSize) #size = max(l_absSize)*1.25 if subSize is not None: size = subSize if not size: d_size = returnBaseControlSize(mi_rootLoc, targetGeo, axis=[aimAxis]) #Get size log.info("d_size: %s" % d_size) l_size = d_size[single_aimAxis] size = l_size / 3 log.info("loli size: %s" % size) i_ball = cgmMeta.cgmObject( curves.createControlCurve('sphere', size=size)) elif extendMode == 'endCap': log.debug("|{0}| >> endCap...".format(_str_func)) returnBuffer1 = createMeshSliceCurve( targetGeo, mi_rootLoc.mNode, aimAxis='{0}+'.format(latheAxis), latheAxis=objectUp[0], curveDegree=curveDegree, maxDistance=maxDistance, closestInRange=closestInRange, closedCurve=False, l_specifiedRotates=[-90, -60, -30, 0, 30, 60, 90], posOffset=posOffset) mi_rootLoc.rotate = [0, 0, 0] mi_rootLoc.__setattr__('r%s' % latheAxis, 90) returnBuffer2 = createMeshSliceCurve( targetGeo, mi_rootLoc.mNode, aimAxis='{0}+'.format(latheAxis), latheAxis=objectUp[0], curveDegree=curveDegree, maxDistance=maxDistance, closedCurve=False, closestInRange=closestInRange, l_specifiedRotates=[-90, -60, -30, 0, 30, 60, 90], posOffset=posOffset) l_sliceReturns.extend([returnBuffer1, returnBuffer2]) il_curvesToCombine.append(cgmMeta.cgmObject(returnBuffer1)) il_curvesToCombine.append(cgmMeta.cgmObject(returnBuffer2)) mi_rootLoc.rotate = [0, 0, 0] #Now cast our root since we needed to move it with segment mode before casting if extendMode == 'cylinder': log.debug("|{0}| >> cylinder move...".format(_str_func)) mi_rootLoc.__setattr__('t%s' % latheAxis, -discOffset) log.debug("|{0}| >> Rootcast...".format(_str_func)) d_rootCastInfo = createMeshSliceCurve( targetGeo, mi_rootLoc, curveDegree=curveDegree, minRotate=minRotate, maxRotate=maxRotate, latheAxis=latheAxis, midMeshCast=midMeshCast, aimAxis=aimAxis, posOffset=posOffset, points=points, vectorOffset=vectorOffset, returnDict=True, closedCurve=closedCurve, maxDistance=maxDistance, closestInRange=closestInRange, rotateBank=rotateBank, l_specifiedRotates=l_specifiedRotates, axisToCheck=axisToCheck) #d_rootCastInfo = createMeshSliceCurve(targetGeo,mi_rootLoc,**kws) log.debug("|{0}| >> Rootcast done".format(_str_func) + cgmGEN._str_subLine) if extendMode == 'disc': l_sliceReturns.insert(1, d_rootCastInfo) else: l_sliceReturns.insert(0, d_rootCastInfo) #Special loli stuff if extendMode == 'loliwrap': SNAP.go(i_ball.mNode, mi_rootLoc.mNode, True, True) #Snap to main object #log.debug("hitReturns: %s"%d_rootCastInfo['hitReturns']) #cgmGEN.walk_dat(d_rootCastInfo['hitReturns'],'hitReturns') mi_crv = cgmMeta.cgmObject(d_rootCastInfo['curve']) """ d_return = RayCast.findMeshIntersectionFromObjectAxis(targetGeo,mi_rootLoc.mNode,mAxis_aim.p_string) or {} if not d_return.get('hit'): log.info(d_return) raise ValueError,"No hit on loli check" pos = d_return.get('hit') dist = distance.returnDistanceBetweenPoints(i_ball.getPosition(),pos) * 2""" if vectorOffset is not None: dist = vectorOffset + subSize * 4 else: dist = max(posOffset) + subSize * 4 if '-' in aimAxis: distM = -dist else: distM = dist log.debug("distM: %s" % distM) #Move the ball pBuffer = i_ball.doGroup() i_ball.__setattr__('t%s' % single_aimAxis, distM) i_ball.parent = False mc.delete(pBuffer) uPos = distance.returnClosestUPosition(i_ball.mNode, mi_crv.mNode) SNAP.aim(i_ball.mNode, mi_rootLoc.mNode, aimAxis='z-') #if posOffset: #mc.move(posOffset[0]*3,posOffset[1]*3,posOffset[2]*3, [i_ball.mNode], r = True, rpr = True, os = True, wd = True) #Make the curve between the two mi_traceCrv = cgmMeta.cgmObject( mc.curve(degree=1, ep=[uPos, i_ball.getPosition()])) #Combine il_curvesToCombine.extend([i_ball, mi_traceCrv]) mi_root = cgmMeta.cgmObject(d_rootCastInfo['curve']) #instance curve il_curvesToCombine.append(mi_root) mc.delete(mi_rootLoc.parent) #delete the loc l_curvesToCombine = [mi_obj.mNode for mi_obj in il_curvesToCombine ] #Build our combine list before adding connectors log.debug("|{0}| >> processed: {1}".format( _str_func, d_rootCastInfo['processedHits'])) if joinMode and extendMode not in ['loliwrap', 'endCap' ] and len(l_sliceReturns) > 1: if joinHits: keys = d_rootCastInfo['processedHits'].keys() keys.sort() #goodDegrees = [] #for i,key in enumerate(keys): #if i in joinHits: #goodDegrees.append(key) goodDegrees = [key for i, key in enumerate(keys) if i in joinHits] log.debug("joinHits: %s" % joinHits) log.debug("goodDegrees: %s" % goodDegrees) else: goodDegrees = [ key for key in d_rootCastInfo['processedHits'].keys() ] #> Side Curves for degree in goodDegrees: l_pos = [] for d in l_sliceReturns: l_pos.append(d['processedHits'].get(degree) or False) while False in l_pos: l_pos.remove(False) log.debug("l_pos: %s" % l_pos) if len(l_pos) >= 2: try: l_curvesToCombine.append( mc.curve(d=curveDegree, ep=l_pos, os=True)) #Make the curve except: log.debug( "createWrapControlShape>>> skipping curve fail: %s" % (degree)) #>>Combine the curves newCurve = curves.combineCurves(l_curvesToCombine) mi_crv = cgmMeta.cgmObject(rigging.groupMeObject(targetObjects[0], False)) curves.parentShapeInPlace(mi_crv.mNode, newCurve) #Parent shape mc.delete(newCurve) #>>Copy tags and name mi_crv.doCopyNameTagsFromObject(targetObjects[0], ignore=['cgmType', 'cgmTypeModifier']) mi_crv.addAttr('cgmType', attrType='string', value='controlCurve', lock=True) mi_crv.doName() #Store for return return {'curve': mi_crv.mNode, 'instance': mi_crv}
#> Side Curves for degree in goodDegrees: l_pos = [] for d in l_sliceReturns: l_pos.append( d['processedHits'].get(degree) or False ) while False in l_pos: l_pos.remove(False) log.debug("l_pos: %s"%l_pos) if len(l_pos)>=2: try: l_curvesToCombine.append( mc.curve(d=curveDegree,ep=l_pos,os =True) )#Make the curve except: log.debug("createWrapControlShape>>> skipping curve fail: %s"%(degree)) #>>Combine the curves newCurve = curves.combineCurves(l_curvesToCombine) mi_crv = cgmMeta.cgmObject( rigging.groupMeObject(targetObjects[0],False) ) curves.parentShapeInPlace(mi_crv.mNode,newCurve)#Parent shape mc.delete(newCurve) #>>Copy tags and name mi_crv.doCopyNameTagsFromObject(targetObjects[0],ignore = ['cgmType','cgmTypeModifier']) mi_crv.addAttr('cgmType',attrType='string',value = 'controlCurve',lock=True) mi_crv.doName() #Store for return return {'curve':mi_crv.mNode,'instance':mi_crv} def createMeshSliceCurve(mesh, mi_obj,latheAxis = 'z',aimAxis = 'y+', points = 12, curveDegree = 3, minRotate = None, maxRotate = None, rotateRange = None, posOffset = 0, markHits = False,rotateBank = None, closedCurve = True, maxDistance = 1000,