def extendPoly(*args):
"""does the polyextension by grabbing the curve, offsetting it and then lofting. Then converts the nurbs surface to polys"""
#make sure a curve is selected
selection = cmds.ls(sl=True)
if selection:
sel = selection[0]
shape = cmds.listRelatives(sel, s=True)[0]
type = cmds.objectType(shape)
name = cmds.textFieldGrp("name", q=True, tx=True)
hisGrp = cmds.checkBox("history", q=True, v=True)
hisPoly = cmds.checkBox("polyHistory", q=True, v=True)
if type == "nurbsCurve":
#offset the curb
distance = cmds.floatFieldGrp("curbFFG", q=True, v1=True)
# bump = cmds.checkBox("bumpCB", q=True, v=True)
pos = cmds.checkBox("curbCB", q=True, v=True)
if pos == 0:
dist = distance * -1
else:
dist = distance
U = cmds.intFieldGrp("UDivIFG", q=True, v1=True)
V = cmds.intFieldGrp("VDivIFG", q=True, v1=True)
origCrv = cmds.rename(sel, "%s_inner_CRV" % name)
outCurve = cmds.offsetCurve(origCrv,
d=dist,
n="%s_outer_CRV" % name)
midCurve = cmds.offsetCurve(origCrv,
d=dist / 2,
n="%s_mid_CRV" % name)
# if bump:
# cmds.xform(midCurve, ws=True, r=True, t=(0,5,0))
cmds.select(cl=True)
lofted = cmds.loft(origCrv, midCurve, outCurve)[0]
loft = cmds.rename(lofted, "%s_lofted" % name)
polygon = cmds.nurbsToPoly(loft, pt=1, ch=hisPoly, f=2, un=U,
vn=V)[0]
poly = cmds.rename(polygon, "%s_poly" % name)
curbGrp = cmds.group(empty=True)
grp = cmds.rename(curbGrp, "%s_History_GRP" % name)
# cmds.rename(poly, "polyCurb")
cmds.parent(loft, outCurve, midCurve, origCrv, grp)
cmds.setAttr("%s.v" % grp, 0)
if not hisGrp:
cmds.delete(grp)
else:
cmds.warning("That's not a curve! You need to select a curve!")
else:
cmds.warning("You haven't selected anything!")
def extendPoly(*args):
"""does the polyextension by grabbing the curve, offsetting it and then lofting. Then converts the nurbs surface to polys"""
#make sure a curve is selected
selection = cmds.ls(sl=True)
if selection:
sel = selection[0]
shape = cmds.listRelatives(sel, s=True)[0]
type = cmds.objectType(shape)
name = cmds.textFieldGrp("name", q=True, tx=True)
hisGrp = cmds.checkBox("history", q=True, v=True)
hisPoly = cmds.checkBox("polyHistory", q=True, v=True)
if type== "nurbsCurve":
#offset the curb
distance = cmds.floatFieldGrp("curbFFG", q=True, v1=True)
# bump = cmds.checkBox("bumpCB", q=True, v=True)
pos = cmds.checkBox("curbCB", q=True, v=True)
if pos == 0:
dist = distance * -1
else:
dist = distance
U = cmds.intFieldGrp("UDivIFG", q=True, v1=True)
V = cmds.intFieldGrp("VDivIFG", q=True, v1=True)
origCrv = cmds.rename(sel, "%s_inner_CRV"%name)
outCurve = cmds.offsetCurve(origCrv, d=dist, n="%s_outer_CRV"%name)
midCurve = cmds.offsetCurve(origCrv, d=dist/2, n="%s_mid_CRV"%name)
# if bump:
# cmds.xform(midCurve, ws=True, r=True, t=(0,5,0))
cmds.select(cl=True)
lofted = cmds.loft(origCrv, midCurve, outCurve)[0]
loft = cmds.rename(lofted, "%s_lofted"%name)
polygon = cmds.nurbsToPoly(loft, pt=1, ch=hisPoly, f=2, un=U, vn=V)[0]
poly = cmds.rename(polygon, "%s_poly"%name)
curbGrp = cmds.group(empty=True)
grp = cmds.rename(curbGrp, "%s_History_GRP"%name)
# cmds.rename(poly, "polyCurb")
cmds.parent(loft, outCurve, midCurve, origCrv, grp)
cmds.setAttr("%s.v"%grp, 0)
if not hisGrp:
cmds.delete(grp)
else:
cmds.warning("That's not a curve! You need to select a curve!")
else:
cmds.warning("You haven't selected anything!")
def _createNurbs(self):
"""Create the nurbs curves that will act as our bendy/twist curves."""
for crv in [["hip", "knee"], ["knee", "foot"]]:
limb_points = self._getCurvePositions(crv[0], crv[1])
limb_crv = mc.curve(n=self.guides[crv[0]][0].replace("guide", "crv"), p=limb_points, d=3)
limb_crv_offset = mc.offsetCurve(limb_crv, d=.3, ugn=0)
limb_crv_inv = mc.offsetCurve(limb_crv, d=-.3, ugn=0)
limb_loft = mc.loft(limb_crv_inv, limb_crv_offset, n=self.guides[crv[0]][0].replace("guide", "nrb"), ch=0)
mc.delete(limb_crv, limb_crv_offset, limb_crv_inv)
self.nurbs[crv[0]] = limb_loft[0]
mc.parent(limb_loft, self.mod_dict["noTransform"])
def addJntsOnSurfIntersection(surf1, surf2, jntsNum):
'''
Places jnts along intersection curve between surf1 and surf2
naming convention based on surf1
'''
# intersect surfaces
crvGrp, intNode = mc.intersect(surf1, surf2, fs=True, ch=True, o=True, cos=False)[:2]
intNode = mc.rename(intNode, surf1+'_ints')
crvGrp = mc.rename(crvGrp, surf1+'_ints_crv_grp')
crv = mc.listRelatives(crvGrp, c=True)[0]
crv = mc.rename(crv, surf1+'_ints_crv')
# rebuild curve to jntNum spans
rbdCrv, rbdNode = mc.rebuildCurve(crv, ch=True, o=True, rpo=False, spans=jntsNum, rt=0, kr=2, n=crv+'_rbd_crv')
rbdNode = mc.rename(rbdNode, crv+'_rbd')
# offset curve to control size of eye hole
offsetCrv, offsetNode = mc.offsetCurve(rbdCrv, ch=True, distance=0, o=True, ugn=0, n=crv+'_offset_crv')
offsetNode = mc.rename(offsetNode, crv+'_offset')
locs = []
locName = '_'.join(surf1.split('_')[:2])
# attach locators to intersection curve
for locId in range(jntsNum):
loc = mc.spaceLocator(n=locName+'_loc_%d' % locId)[0]
rt.attachToMotionPath(offsetCrv, locId, loc, fm=False)
mc.setAttr(loc+'.localScale', 0.05, 0.05, 0.05)
locs.append(loc)
# normal constraint to surf1
for loc in locs:
mc.normalConstraint(surf2, loc, aim=(1,0,0))
jnts = []
# add joints under locators
for loc in locs:
mc.select(cl=True)
jnt = mc.joint(n=loc.replace('_loc_','_jnt_'))
rt.parentSnap(jnt, loc)
mc.setAttr(jnt+'.jointOrient', 0,0,0)
jnts.append(jnt)
# groups
grp = mc.group(crvGrp, offsetCrv, rbdCrv, locs, n=surf1+'_intersect_loc_grp')
# create offset attribute
mc.addAttr(grp, ln='collideOffset', at='double', dv=0, k=True)
offsetPlug = cn.create_multDoubleLinear(grp+'.collideOffset', -1)
mc.connectAttr(offsetPlug, offsetNode+'.distance', f=True)
# connect debug
rt.connectVisibilityToggle(offsetCrv, grp, 'offsetCrv', False)
rt.connectVisibilityToggle(rbdCrv, grp, 'rebuildCrv', False)
rt.connectVisibilityToggle(crvGrp, grp, 'intersectCrv', False)
rt.connectVisibilityToggle(locs, grp, 'crvLocs', False)
rt.connectVisibilityToggle(jnts, grp, 'crvJnts', False)
def addJntsOnSurfIntersection(surf1, surf2, jntsNum):
'''
Places jnts along intersection curve between surf1 and surf2
naming convention based on surf1
'''
# intersect surfaces
crvGrp, intNode = mc.intersect(surf1,
surf2,
fs=True,
ch=True,
o=True,
cos=False)[:2]
intNode = mc.rename(intNode, surf1 + '_ints')
crvGrp = mc.rename(crvGrp, surf1 + '_ints_crv_grp')
crv = mc.listRelatives(crvGrp, c=True)[0]
crv = mc.rename(crv, surf1 + '_ints_crv')
# rebuild curve to jntNum spans
rbdCrv, rbdNode = mc.rebuildCurve(crv,
ch=True,
o=True,
rpo=False,
spans=jntsNum,
rt=0,
kr=2,
n=crv + '_rbd_crv')
rbdNode = mc.rename(rbdNode, crv + '_rbd')
# offset curve to control size of eye hole
offsetCrv, offsetNode = mc.offsetCurve(rbdCrv,
ch=True,
distance=0,
o=True,
ugn=0,
n=crv + '_offset_crv')
offsetNode = mc.rename(offsetNode, crv + '_offset')
locs = []
locName = '_'.join(surf1.split('_')[:2])
# attach locators to intersection curve
for locId in range(jntsNum):
loc = mc.spaceLocator(n=locName + '_loc_%d' % locId)[0]
rt.attachToMotionPath(offsetCrv, locId, loc, fm=False)
mc.setAttr(loc + '.localScale', 0.05, 0.05, 0.05)
locs.append(loc)
# normal constraint to surf1
for loc in locs:
mc.normalConstraint(surf2, loc, aim=(1, 0, 0))
jnts = []
# add joints under locators
for loc in locs:
mc.select(cl=True)
jnt = mc.joint(n=loc.replace('_loc_', '_jnt_'))
rt.parentSnap(jnt, loc)
mc.setAttr(jnt + '.jointOrient', 0, 0, 0)
jnts.append(jnt)
# groups
grp = mc.group(crvGrp,
offsetCrv,
rbdCrv,
locs,
n=surf1 + '_intersect_loc_grp')
# create offset attribute
mc.addAttr(grp, ln='collideOffset', at='double', dv=0, k=True)
offsetPlug = cn.create_multDoubleLinear(grp + '.collideOffset', -1)
mc.connectAttr(offsetPlug, offsetNode + '.distance', f=True)
# connect debug
rt.connectVisibilityToggle(offsetCrv, grp, 'offsetCrv', False)
rt.connectVisibilityToggle(rbdCrv, grp, 'rebuildCrv', False)
rt.connectVisibilityToggle(crvGrp, grp, 'intersectCrv', False)
rt.connectVisibilityToggle(locs, grp, 'crvLocs', False)
rt.connectVisibilityToggle(jnts, grp, 'crvJnts', False)
def resize_masterShape(self, sizeBy=None, resize=False):
try:
_short = self.p_nameShort
_str_func = '[{0}] resize_masterShape'.format(_short)
log.debug("|{0}| >> ".format(_str_func) + '-' * 80)
_sel = mc.ls(sl=True)
_bb = False
_bb = self.baseSize
if resize:
if _sel:
_bb = TRANS.bbSize_get(_sel, False)
#elif self.getBlockChildren():
# sizeBy = mc.ls(self.getBlockChildren(asMeta=False))
# _bb = TRANS.bbSize_get(sizeBy,False)
self.baseSize = _bb
log.debug("|{0}| >> _bb: {1}".format(_str_func, _bb))
mHandleFactory = self.asHandleFactory(_short)
mc.delete(self.getShapes())
_average = MATH.average([_bb[0], _bb[2]])
_size = _average * 1.5
_offsetSize = _average * .01
_blockScale = self.blockScale
mFormNull = self.atUtils('stateNull_verify', 'form')
mNoTransformNull = self.atUtils('noTransformNull_verify', 'form')
if resize or self.controlOffset == .9999:
self.controlOffset = _offsetSize
#Main curve ===========================================================================
_crv = CURVES.create_fromName(name='circle', direction='y+', size=1)
mCrv = cgmMeta.asMeta(_crv)
SNAP.go(mCrv.mNode, self.mNode, rotation=False)
TRANS.scale_to_boundingBox(mCrv.mNode, [_bb[0], None, _bb[2]])
#mDup = mCrv.doDuplicate(po=False)
#mDup.p_position = MATH.list_add(mDup.p_position, [0,_offsetSize,0])
RIG.shapeParent_in_place(self.mNode, _crv, False)
#RIG.shapeParent_in_place(self.mNode,mDup.mNode,False)
mHandleFactory.color(self.mNode, 'center', 'main', transparent=False)
#Bounding box ==================================================================
if self.getMessage('bbHelper'):
self.bbHelper.delete()
_bb_shape = CURVES.create_controlCurve(self.mNode,
'cubeOpen',
size=1,
sizeMode='fixed')
_bb_newSize = MATH.list_mult(self.baseSize,
[_blockScale, _blockScale, _blockScale])
TRANS.scale_to_boundingBox(_bb_shape, _bb_newSize)
mBBShape = cgmMeta.validateObjArg(_bb_shape,
'cgmObject',
setClass=True)
mBBShape.p_parent = mFormNull
mBBShape.inheritsTransform = False
mc.parentConstraint(self.mNode, mBBShape.mNode, maintainOffset=False)
SNAPCALLS.snap(mBBShape.mNode,
self.mNode,
objPivot='axisBox',
objMode='y-')
CORERIG.copy_pivot(mBBShape.mNode, self.mNode)
self.doConnectOut('baseSize', "{0}.scale".format(mBBShape.mNode))
#mHandleFactory.color(mBBShape.mNode,controlType='sub')
mBBShape.setAttrFlags()
mBBShape.doStore('cgmName', self)
mBBShape.doStore('cgmType', 'bbVisualize')
mBBShape.doName()
mBBShape.template = True
self.connectChildNode(mBBShape.mNode, 'bbHelper')
#Offset visualize ==================================================================
if self.getMessage('offsetHelper'):
self.offsetHelper.delete()
#Need to guess our offset size based on bounding box volume
mShape = self.getShapes(asMeta=True)[0]
l_return = mc.offsetCurve(mShape.mNode, distance=1, ch=True)
#pprint.pprint(l_return)
mHandleFactory.color(l_return[0], 'center', 'sub', transparent=False)
mOffsetShape = cgmMeta.validateObjArg(l_return[0],
'cgmObject',
setClass=True)
mOffsetShape.p_parent = mNoTransformNull
#mOffsetShape.doSnapTo(self)
#mc.pointConstraint(self.mNode,mOffsetShape.mNode,maintainOffset=True)
#mc.orientConstraint(self.mNode,mOffsetShape.mNode,maintainOffset=True)
mOffsetShape.inheritsTransform = False
mOffsetShape.dagLock()
_arg = '{0}.distance = -{1}.controlOffset'.format(
l_return[1], self.mNode)
NODEFACTORY.argsToNodes(_arg).doBuild()
#self.doConnectOut('controlOffset',"{0}.distance".format(l_return[1]))
mOffsetShape.doStore('cgmName', self)
mOffsetShape.doStore('cgmType', 'offsetVisualize')
mOffsetShape.doName()
self.connectChildNode(mOffsetShape.mNode, 'offsetHelper')
return
#Offset visualize ==================================================================
if self.getMessage('offsetHelper'):
self.offsetHelper.delete()
mShape = self.getShapes(asMeta=True)[0]
l_return = mc.offsetCurve(mShape.mNode, distance=1, ch=True)
#pprint.pprint(l_return)
mHandleFactory.color(l_return[0], 'center', 'sub', transparent=False)
mOffsetShape = cgmMeta.validateObjArg(l_return[0],
'cgmObject',
setClass=True)
mOffsetShape.p_parent = mFormNull
mOffsetShape.inheritsTransform = False
mc.parentConstraint(self.mNode,
mOffsetShape.mNode,
maintainOffset=False)
#mOffsetShape.setAttrFlags()
_arg = '{0}.distance = -{1}.controlOffset * {1}.blockScale'.format(
l_return[1], self.mNode)
NODEFACTORY.argsToNodes(_arg).doBuild()
#self.doConnectOut('controlOffset',"{0}.distance".format(l_return[1]))
mOffsetShape.doStore('cgmName', self)
mOffsetShape.doStore('cgmType', 'offsetVisualize')
mOffsetShape.doName()
self.connectChildNode(mOffsetShape.mNode, 'offsetHelper')
return
_crv = CURVES.create_fromName(name='squareOpen',
direction='y+',
size=1)
TRANS.scale_to_boundingBox(_crv, [_bb[0], None, _bb[2]])
mHandleFactory.color(_crv, 'center', 'sub', transparent=False)
mCrv = cgmMeta.validateObjArg(_crv, 'cgmObject')
l_offsetCrvs = []
for shape in mCrv.getShapes():
offsetShape = mc.offsetCurve(shape, distance=-_offsetSize,
ch=True)[0]
mHandleFactory.color(offsetShape,
'center',
'main',
transparent=False)
l_offsetCrvs.append(offsetShape)
RIG.combineShapes(l_offsetCrvs + [_crv], True)
SNAP.go(_crv, self.mNode)
RIG.shapeParent_in_place(self.mNode, _crv, True)
self.baseSize = _bb
#Bounding box ==================================================================
if self.getMessage('offsetVisualize'):
self.bbVisualize.delete()
_bb_shape = CURVES.create_controlCurve(self.mNode,
'cubeOpen',
size=1.0,
sizeMode='fixed')
mBBShape = cgmMeta.validateObjArg(_bb_shape,
'cgmObject',
setClass=True)
mBBShape.p_parent = mFormNull
SNAPCALLS.snap(mBBShape.mNode,
self.mNode,
objPivot='axisBox',
objMode='y-')
CORERIG.copy_pivot(mBBShape.mNode, self.mNode)
self.doConnectOut('baseSize', "{0}.scale".format(mBBShape.mNode))
mHandleFactory.color(mBBShape.mNode, controlType='sub')
mBBShape.setAttrFlags()
mBBShape.doStore('cgmName', self)
mBBShape.doStore('cgmType', 'bbVisualize')
mBBShape.doName()
self.connectChildNode(mBBShape.mNode, 'bbHelper')
return True
except Exception, err:
cgmGEN.cgmExceptCB(Exception, err, localDat=vars())
def _buildSideSplashEmitter(name = '', boatName = '', splashParticleName = [], boatIntersectCurveShape = '', sideAnimatable = '', presetName = None):
"""
New builder for sideSplash nParticle Emitter
Checks if the NPARTICLE_EMITTLERS_hrc exists or not too
@param name: The name of the new emitter
@param splashParticleName: List of the names of nParticleShape nodes to connect to the emitter
@param boatIntersectCurveShape: The name of the intersection curve to emit from.
@type name: String
@type splashParticleName: List
@type boatIntersectCurveShape: String
"""
if not cmds.objExists('nPARTICLE_EMITTERS_hrc'):
cmds.group(n = 'nPARTICLE_EMITTERS_hrc', em = True)
debug(None, method = '_buildSideSplashEmitter', message = 'name: %s' % name, verbose = False)
# Get base flat surface
lineCurve = cmds.curve( name = '%s_extrudeCurve' % name, degree = 1, point = [(-0.01, 0, 0), (0.01, 0, 0)] )
flatSurface = cmds.extrude(lineCurve, boatIntersectCurveShape, name = '%s_flatSurface' % name, constructionHistory = True, range = False, polygon = 0, useComponentPivot = 1, fixedPath = True, useProfileNormal = True, extrudeType = 2, reverseSurfaceIfPathReversed = True)[0]
cmds.rebuildSurface(flatSurface, constructionHistory = True, replaceOriginal = True, rebuildType = 0, endKnots = 1, keepCorners = False, spansU = 1, degreeU = 1, spansV = 100, degreeV = 3)
# Offset upwards curve from surface
offsetUp = cmds.offsetCurve('%s.u[0.5]' % flatSurface, name = '%s_offsetUp' % name, distance = 0, constructionHistory = True, range = 0, subdivisionDensity = 1)[0]
cmds.rebuildCurve(offsetUp, constructionHistory = False, replaceOriginal = True, end = 1, keepRange = 0, keepControlPoints = True, degree = 1)
cmds.setAttr('%s.translateY' % offsetUp, 0.01)
# Offset from upwards curve with distance and translate down to get the 45 degree angle
offset_distance = -0.01
offsetOut = cmds.offsetCurve(offsetUp, name = '%s_offsetOut' % name, distance = offset_distance, constructionHistory = True, range = 0, subdivisionDensity = 1)[0]
cmds.setAttr('%s.translateY' % offsetOut, offset_distance)
# Finally, loft a non-flipping surface solution (45 degree angle of the boat)
noFlipSurface = cmds.loft(offsetUp, offsetOut, degree = 1, constructionHistory = True, range = 0, polygon = 0, sectionSpans = 1)[0]
noFlipSurface = cmds.rename(noFlipSurface, '%s_noFlipSurface' % name)
## Build the emitter
emitter = cmds.emitter(noFlipSurface, name = '%s_emitter' % name, type = 'surface')
# Create closestPointOnSurface for acceleration expression where front more acceleration
cPoS = cmds.createNode('closestPointOnSurface', name = '%s_cPoS' % name)
cmds.connectAttr('%s.worldSpace' % noFlipSurface, '%s.inputSurface' % cPoS)
## Build the emitter group if it doesn't already exist
emitterGroup = '%s_hrc' % name
if not cmds.objExists(emitterGroup):
cmds.group(lineCurve, flatSurface, offsetUp, offsetOut, noFlipSurface, emitter[0], n = emitterGroup)
debug(None, method = '_buildSideSplashEmitter', message = 'emitterName: %s' % emitter[1], verbose = False)
## Check if a custom preset has been assigned via the func flags for the emitter, if not use the default preset...
if presetName:
pathToPreset = '%s/%s' %(CONST.EMITTERBASEPRESETPATH, presetName)
debug(None, method = '_buildSideSplashEmitter', message = 'pathToPreset: %s' % pathToPreset, verbose = False)
mel.eval( 'applyPresetToNode "%s" "" "" "%s" 1;' %(emitter[1], pathToPreset) )
## Now parent it
try: cmds.parent(emitterGroup, 'nPARTICLE_EMITTERS_hrc')
except: pass
## Connect the emitter to the particles
debug(None, method = '_buildSideSplashEmitter', message = 'Connected %s: %s' % (splashParticleName, emitter[1]), verbose = False)
for each in splashParticleName:
_connect_NParticleShape_to_NParticleEmitter(particleShapeNode = each, emitter = emitter[1])
## Now do the expression for the side emitter
if 'IntersectCurveRight' in emitter[1]:
direction = 'R'
else:
direction = 'L'
expStringList = [
'float $minSpeed = %s.minSpeed;\n' % sideAnimatable,
'float $maxSpeed = %s.maxSpeed;\n' % sideAnimatable,
'float $speed = %s:world_ctrl.speed;\n' % boatName,
'float $curve = smoothstep($minSpeed, $maxSpeed, $speed);\n',
'float $rateMuliplier = %s.rateMultiplier%s;\n' %(sideAnimatable, direction),
'float $splashMaxSpeed = %s.splashMaxSpeed%s;\n' %(sideAnimatable, direction),
'\n',
'if (%s.useSpeed == 1)\n' % sideAnimatable,
'{\n\t',
'%s.rate = $rateMuliplier * $curve;\n' % emitter[1],
'\n\t\t',
'float $emitterSpeed = $splashMaxSpeed * $curve;\n\t\t',
'if ($emitterSpeed == 0)\n\t\t',
'{\n\t\t\t',
'$emitterSpeed = 0.1;\n\t\t',
'}\n\t\t',
'%s.speed = $emitterSpeed;\n' % emitter[1],
'}\n',
'else\n',
'{\n\t',
'%s.rate = $rateMuliplier;\n\t' % emitter[1],
'%s.speed = $splashMaxSpeed;\n' % emitter[1],
'}\n',
]
## Check if the expression already exists in the scene, if so delete it
utils.checkExpressionExists('%s_sideSplashEmitter' % boatName)
## Build new expression
cmds.expression(emitter[1], n = '%s_sideSplashEmitter' % emitter[1], string = utils.processExpressionString(expStringList))
## Connect some attributes
if not cmds.isConnected('%s.normalSpeed%s' %(sideAnimatable, direction), '%s.normalSpeed' % emitter[1]):
cmds.connectAttr('%s.normalSpeed%s' %(sideAnimatable, direction), '%s.normalSpeed' % emitter[1])
if not cmds.isConnected('%s.randomSpeed%s' %(sideAnimatable, direction), '%s.speedRandom' % emitter[1]):
cmds.connectAttr('%s.randomSpeed%s' %(sideAnimatable, direction), '%s.speedRandom' % emitter[1])
return cPoS
cgmGEN.cgmExceptCB(Exception, err, localDat=vars())
_crv = CURVES.create_controlCurve(self.mNode,
shape='squareOpen',
direction='y+',
sizeMode='fixed',
size=1)
TRANS.scale_to_boundingBox(_crv,
[self.baseSize[0], None, self.baseSize[2]])
mHandleFactory.color(_crv, 'center', 'sub', transparent=False)
mCrv = cgmMeta.validateObjArg(_crv, 'cgmObject')
l_offsetCrvs = []
for shape in mCrv.getShapes():
offsetShape = mc.offsetCurve(shape, distance=-_offsetSize, ch=False)[0]
mHandleFactory.color(offsetShape, 'center', 'main', transparent=False)
l_offsetCrvs.append(offsetShape)
for s in [_crv] + l_offsetCrvs:
RIG.shapeParent_in_place(self.mNode, s, False)
return True
def formDelete(self):
pass
#self.setAttrFlags(attrs=['translate','rotate','sx','sz'], lock = False)
def is_form(self):
def offsetCurve(*args, **kwargs):
res = cmds.offsetCurve(*args, **kwargs)
if not kwargs.get('query', kwargs.get('q', False)):
res = _factories.maybeConvert(res, _general.PyNode)
return res
roty = math.degrees(math.atan2(tangent[0], tangent[2]))
rotx = math.degrees(
math.atan2(
-tangent[1],
math.sqrt(tangent[0] * tangent[0] + tangent[2] * tangent[2])))
curCube = MakeSleeper()
mc.move(position[0], position[1], position[2])
mc.rotate(0, roty + 90, 0)
sleeperCurve = random.randrange(-rotAmp, rotAmp)
mc.rotate(0, sleeperCurve, 0, r=True)
mc.rotate(rotx, 0, 0, r=True)
sleepers.append(curCube)
dist += distSleepers
sleeperGroup = mc.group(sleepers, n='Sleepers')
leftCurve = mc.offsetCurve(curveName, d=3)
mc.move(0, 0.6, 0)
leftCurveTop = mc.duplicate(rr=True)
mc.move(0, 1.1, 0)
leftRail = CutRailPieces(curve=leftCurve[0], width=0.4)
leftRailTop = CutRailPieces(curve=leftCurveTop[0], height=0.2, width=0.7)
rightCurve = mc.offsetCurve(curveName, d=-3)
mc.move(0, 0.6, 0)
rightCurveTop = mc.duplicate(rr=True)
mc.move(0, 1.1, 0)
rightRail = CutRailPieces(curve=rightCurve[0], width=0.4)
rightRailTop = CutRailPieces(curve=rightCurveTop[0], height=0.2, width=0.7)
track = mc.group(leftRail,
rightRail,
def createNurb(uNumber=5, vNumber=5, side=None, name=None, mX=0, mY=0, mZ=0):
name = '{}_{}_nurb'.format(name, side)
try:
crv = cmds.polyToCurve(n='deletableCurve',
form=2,
degree=3,
conformToSmoothMeshPreview=1)[0]
degs = cmds.getAttr('{}.degree'.format(crv))
spans = cmds.getAttr('{}.spans'.format(crv))
cvs = degs + spans
#
#crv1 = cmds.duplicate(crv, n='deletableCurve1')[0]
#cmds.select('{}.cv[0:{}]'.format(crv1, cvs))
#cmds.move(mX, mY, mZ, r=True, os=True, wd=True)
#crv2 = cmds.duplicate(crv, n='deletableCurve2')[0]
#cmds.select('{}.cv[0:{}]'.format(crv2, cvs))
#mX= mX*(-1)
#mY= mY*(-1)
#mZ= mZ*(-1)
#cmds.move(mX, mY, mZ, r=True, os=True, wd=True)
mnX = mX * (-1)
offst_curve1 = cmds.offsetCurve(crv, d=mX)[0]
offst_curve2 = cmds.offsetCurve(crv, d=mnX)[0]
surf = cmds.loft(offst_curve1,
offst_curve2,
ch=1,
u=1,
c=0,
ar=1,
d=3,
ss=1,
rn=0,
po=0,
rsn=True,
n=name)[0]
cmds.rebuildSurface(surf,
ch=1,
rpo=1,
rt=0,
end=1,
kr=0,
kcp=0,
kc=0,
su=uNumber,
du=3,
sv=vNumber,
dv=3,
tol=0.01,
fr=0,
dir=2)
cmds.delete(surf, ch=True)
for c in [crv, offst_curve1, offst_curve2]:
cmds.delete(c)
except:
cmds.nurbsPlane(n=name,
ax=(0, 1, 0),
w=True,
lr=True,
d=3,
u=uNumber,
v=vNumber,
ch=1)
def _buildSideSplashEmitter(name='',
boatName='',
splashParticleName=[],
boatIntersectCurveShape='',
sideAnimatable='',
presetName=None):
"""
New builder for sideSplash nParticle Emitter
Checks if the NPARTICLE_EMITTLERS_hrc exists or not too
@param name: The name of the new emitter
@param splashParticleName: List of the names of nParticleShape nodes to connect to the emitter
@param boatIntersectCurveShape: The name of the intersection curve to emit from.
@type name: String
@type splashParticleName: List
@type boatIntersectCurveShape: String
"""
if not cmds.objExists('nPARTICLE_EMITTERS_hrc'):
cmds.group(n='nPARTICLE_EMITTERS_hrc', em=True)
debug(None,
method='_buildSideSplashEmitter',
message='name: %s' % name,
verbose=False)
# Get base flat surface
lineCurve = cmds.curve(name='%s_extrudeCurve' % name,
degree=1,
point=[(-0.01, 0, 0), (0.01, 0, 0)])
flatSurface = cmds.extrude(lineCurve,
boatIntersectCurveShape,
name='%s_flatSurface' % name,
constructionHistory=True,
range=False,
polygon=0,
useComponentPivot=1,
fixedPath=True,
useProfileNormal=True,
extrudeType=2,
reverseSurfaceIfPathReversed=True)[0]
cmds.rebuildSurface(flatSurface,
constructionHistory=True,
replaceOriginal=True,
rebuildType=0,
endKnots=1,
keepCorners=False,
spansU=1,
degreeU=1,
spansV=100,
degreeV=3)
# Offset upwards curve from surface
offsetUp = cmds.offsetCurve('%s.u[0.5]' % flatSurface,
name='%s_offsetUp' % name,
distance=0,
constructionHistory=True,
range=0,
subdivisionDensity=1)[0]
cmds.rebuildCurve(offsetUp,
constructionHistory=False,
replaceOriginal=True,
end=1,
keepRange=0,
keepControlPoints=True,
degree=1)
cmds.setAttr('%s.translateY' % offsetUp, 0.01)
# Offset from upwards curve with distance and translate down to get the 45 degree angle
offset_distance = -0.01
offsetOut = cmds.offsetCurve(offsetUp,
name='%s_offsetOut' % name,
distance=offset_distance,
constructionHistory=True,
range=0,
subdivisionDensity=1)[0]
cmds.setAttr('%s.translateY' % offsetOut, offset_distance)
# Finally, loft a non-flipping surface solution (45 degree angle of the boat)
noFlipSurface = cmds.loft(offsetUp,
offsetOut,
degree=1,
constructionHistory=True,
range=0,
polygon=0,
sectionSpans=1)[0]
noFlipSurface = cmds.rename(noFlipSurface, '%s_noFlipSurface' % name)
## Build the emitter
emitter = cmds.emitter(noFlipSurface,
name='%s_emitter' % name,
type='surface')
# Create closestPointOnSurface for acceleration expression where front more acceleration
cPoS = cmds.createNode('closestPointOnSurface', name='%s_cPoS' % name)
cmds.connectAttr('%s.worldSpace' % noFlipSurface, '%s.inputSurface' % cPoS)
## Build the emitter group if it doesn't already exist
emitterGroup = '%s_hrc' % name
if not cmds.objExists(emitterGroup):
cmds.group(lineCurve,
flatSurface,
offsetUp,
offsetOut,
noFlipSurface,
emitter[0],
n=emitterGroup)
debug(None,
method='_buildSideSplashEmitter',
message='emitterName: %s' % emitter[1],
verbose=False)
## Check if a custom preset has been assigned via the func flags for the emitter, if not use the default preset...
if presetName:
pathToPreset = '%s/%s' % (CONST.EMITTERBASEPRESETPATH, presetName)
debug(None,
method='_buildSideSplashEmitter',
message='pathToPreset: %s' % pathToPreset,
verbose=False)
mel.eval('applyPresetToNode "%s" "" "" "%s" 1;' %
(emitter[1], pathToPreset))
## Now parent it
try:
cmds.parent(emitterGroup, 'nPARTICLE_EMITTERS_hrc')
except:
pass
## Connect the emitter to the particles
debug(None,
method='_buildSideSplashEmitter',
message='Connected %s: %s' % (splashParticleName, emitter[1]),
verbose=False)
for each in splashParticleName:
_connect_NParticleShape_to_NParticleEmitter(particleShapeNode=each,
emitter=emitter[1])
## Now do the expression for the side emitter
if 'IntersectCurveRight' in emitter[1]:
direction = 'R'
else:
direction = 'L'
expStringList = [
'float $minSpeed = %s.minSpeed;\n' % sideAnimatable,
'float $maxSpeed = %s.maxSpeed;\n' % sideAnimatable,
'float $speed = %s:world_ctrl.speed;\n' % boatName,
'float $curve = smoothstep($minSpeed, $maxSpeed, $speed);\n',
'float $rateMuliplier = %s.rateMultiplier%s;\n' %
(sideAnimatable, direction),
'float $splashMaxSpeed = %s.splashMaxSpeed%s;\n' %
(sideAnimatable, direction),
'\n',
'if (%s.useSpeed == 1)\n' % sideAnimatable,
'{\n\t',
'%s.rate = $rateMuliplier * $curve;\n' % emitter[1],
'\n\t\t',
'float $emitterSpeed = $splashMaxSpeed * $curve;\n\t\t',
'if ($emitterSpeed == 0)\n\t\t',
'{\n\t\t\t',
'$emitterSpeed = 0.1;\n\t\t',
'}\n\t\t',
'%s.speed = $emitterSpeed;\n' % emitter[1],
'}\n',
'else\n',
'{\n\t',
'%s.rate = $rateMuliplier;\n\t' % emitter[1],
'%s.speed = $splashMaxSpeed;\n' % emitter[1],
'}\n',
]
## Check if the expression already exists in the scene, if so delete it
utils.checkExpressionExists('%s_sideSplashEmitter' % boatName)
## Build new expression
cmds.expression(emitter[1],
n='%s_sideSplashEmitter' % emitter[1],
string=utils.processExpressionString(expStringList))
## Connect some attributes
if not cmds.isConnected('%s.normalSpeed%s' % (sideAnimatable, direction),
'%s.normalSpeed' % emitter[1]):
cmds.connectAttr('%s.normalSpeed%s' % (sideAnimatable, direction),
'%s.normalSpeed' % emitter[1])
if not cmds.isConnected('%s.randomSpeed%s' % (sideAnimatable, direction),
'%s.speedRandom' % emitter[1]):
cmds.connectAttr('%s.randomSpeed%s' % (sideAnimatable, direction),
'%s.speedRandom' % emitter[1])
return cPoS
