def CentreUVs():
objSel = cmds.ls(sl=True)
try:
for item, x in enumerate(objSel):
cmds.select('%s.map[*]' %objSel[item])
mm.eval("PolySelectConvert 4;")
mm.eval('TranslateToolWithSnapMarkingMenu')
objPiv = cmds.getAttr('%s.uvPivot' %objSel[0])
mm.eval('MarkingMenuPopDown')
objCenterU = 0.5 - objPiv[0][0]
objCenterV = 0.5 - objPiv[0][1]
cmds.polyEditUV(u=objCenterU, v=objCenterV, r=1)
cmds.select(objSel)
except ValueError:
objQuery = cmds.listRelatives(objSel[0], ap=True)
cmds.select('%s.map[*]' %objQuery[0])
mm.eval("PolySelectConvert 4;")
mm.eval('TranslateToolWithSnapMarkingMenu')
objPiv = cmds.getAttr('%s.uvPivot' %objQuery[0])
mm.eval('MarkingMenuPopDown')
objCenterU = 0.5 - objPiv[0][0]
objCenterV = 0.5 - objPiv[0][1]
cmds.polyEditUV(u=objCenterU, v=objCenterV, r=1)
cmds.select(objQuery)
def layoutUVsToUDIM(self, *args):
sels = cmds.ls(sl=1)
for i, x in enumerate(sels):
x = cmds.listRelatives(x,s=True)[0]
cmds.select('{0}.map[:]'.format(x), r=1)
cmds.polyEditUV(u=i % 10, v=int(math.floor(i / 10)))
cmds.select(sels, r=1)
def setUpClass(cls):
standalone.initialize('usd')
cmds.loadPlugin('pxrUsd')
if not UsdMaya.WriteUtil.WriteUVAsFloat2():
cmds.file(os.path.abspath('UsdExportUVSetsTest.ma'), open=True,
force=True)
else:
cmds.file(os.path.abspath('UsdExportUVSetsTest_Float.ma'), open=True,
force=True)
# Make some live edits to the box with weird UVs for the
# testExportUvVersusUvIndexFromIterator test.
cmds.select("box.map[0:299]", r=True)
cmds.polyEditUV(u=1.0, v=1.0)
usdFilePath = os.path.abspath('UsdExportUVSetsTest.usda')
cmds.usdExport(mergeTransformAndShape=True,
file=usdFilePath,
shadingMode='none',
exportColorSets=False,
exportDisplayColor=False,
exportUVs=True)
cls._stage = Usd.Stage.Open(usdFilePath)
def prescaleUVsShells(object): """ This definition prescales object UVs shells. :param objects: Object. ( String ) :return: Definition succes. ( Boolean ) """ uvs = getUVsFromComponents(object) uMin, vMin, uMax, vMax = getComponentsBoundingBox(uvs) uCenter, vCenter = (uMin + uMax) / 2.0, (vMin + vMax) / 2.0 width, height = uMax - uMin, vMax - vMin scale = max(width, height) cmds.polyMultiLayoutUV(object, lm=0, sc=1, rbf=0, fr=False, ps=0.2, l=2, psc=True) currentUMin, currentVMin, currentUMax, currentVMax = getComponentsBoundingBox(uvs) currentUCenter, currentVCenter = (currentUMin + currentUMax) / 2.0, (currentVMin + currentVMax) / 2.0 currentWidth, currentHeight = currentUMax - currentUMin, currentVMax - currentVMin currentScale = max(currentWidth, currentHeight) scaleFactor = scale / currentScale cmds.polyEditUV(uvs, u=uCenter - currentUCenter, v=vCenter - currentVCenter) scaleComponentsUVs(uvs, su=scaleFactor, sv=scaleFactor) return True
def unfoldBandUVs(object, divisions=1, history=True):
"""
This definition unfolds object band UVs.
:param object: Object. ( String )
:param divisions: Extrusion divisions. ( Integer )
:param history: Keep construction history. ( Boolean )
"""
edgesCount = cmds.polyEvaluate(object, edge=True)
edges = cmds.ls(object + ".e[0:" + str(edgesCount - 1) + "]", fl=True, l=True)
cmds.select(object)
cmds.polySelectConstraint(m=3, t=0x8000, w=1)
cmds.polySelectConstraint(m=0)
for i in range(divisions):
mel.eval("GrowPolygonSelectionRegion();")
bandEdges = cmds.ls(sl=True, fl=True, l=True)
bandFaces = cmds.ls(cmds.polyListComponentConversion(bandEdges, fe=True, tf=True), fl=True)
cmds.select(bandFaces)
cmds.polyForceUV(unitize=True)
cmds.polySelectConstraint(m=3, t=0x8000, sm=1)
seamsEdges = cmds.ls(sl=True, fl=True, l=True)
weldEdges = list(set(bandEdges).difference(set(seamsEdges)))
cmds.polyMapSewMove(weldEdges)
cmds.polyLayoutUV(bandFaces, scale=1, rotateForBestFit=0, layout=1)
uvs = cmds.polyListComponentConversion(bandFaces, toUV=1)
cmds.polyEditUV(uvs, u=1, v=0)
not history and cmds.delete(object, ch=True)
def extrude_edge_uv(self):
self.ex_edges = []
sel = cmds.ls(sl=True)
self.s_edges = common.conv_comp(sel, mode='edge')
s_vtx = common.conv_comp(sel, mode='vtx')
#self.saw_uvs(mode='pre')#事前に押し出し対象のUVを縫い合わせておく
self.marge_uvs(mode='pre')
if not self.s_edges:
return
ev_dict ,vec_dict, ev_uv_dict = self.make_edge_vtx_dict(self.s_edges)
#print 'ev_dict :', ev_dict
#print 'vec_dict :', vec_dict
#押し出しを実行する
cmds.polyExtrudeEdge(self.s_edges,
keepFacesTogether=True,
smoothingAngle=self.soft_angle.value(),
translate=[0, 0, 0])
self.ex_edges = cmds.ls(sl=True)
n_edges = common.conv_comp(self.ex_edges, mode='edge')
n_faces = common.conv_comp(self.ex_edges, mode='face')
self.n_uvs = common.conv_comp(n_faces, mode='uv')
#print 'pre_move_uvs :', self.n_uvs
#根本の位置合わせする
new_vec_dict = {}
for nuv in self.n_uvs[:]:
vtx = common.conv_comp(nuv, mode='vtx')[0]
edge = common.conv_comp(nuv, mode='edge')[0]
if edge+' '+vtx in ev_dict.keys():
uv_pos = ev_dict[edge+' '+vtx]
#print 'get_uv_pos', nuv, uv_pos
cmds.polyEditUV(nuv, u=uv_pos[0], v=uv_pos[1] ,r=False)
self.n_uvs.remove(nuv)
key_uv = ev_uv_dict[edge+' '+vtx]
new_vec_dict[nuv] = vec_dict[key_uv]
#print 'post push uvs :', self.n_uvs
#押し出し先を根本につけて押し出しベクトル辞書をつくる
self.uv_vec_dict = {}
self.base_pos_dict = {}
for nuv in self.n_uvs:
edges = common.conv_comp(nuv, mode='edge')
face = common.conv_comp(nuv, mode='face')
f_uvs = common.conv_comp(face, mode='uv')
for edge in edges:
if edge in n_edges:
continue
#print 'get new edge :', edge
e_uvs = common.conv_comp(edge, mode='uv')
l_uvs = list(set(f_uvs) & set(e_uvs))
#print 'new edge uvs :', l_uvs
for uv in l_uvs:
if not uv in new_vec_dict.keys():
continue
uv_pos = cmds.polyEditUV(uv, query=True)
cmds.polyEditUV(nuv, u=uv_pos[0], v=uv_pos[1] ,r=False)
self.uv_vec_dict[nuv] = new_vec_dict[uv]
self.base_pos_dict[nuv] = uv_pos
self.saw_edges.append(edge)#縫い合わせ用リストに入れておく
self.push_out()
cmds.setToolTo('moveSuperContext')
def ArrangeUVByMat(shape, mat, su=1.0, sv=1.0, u=0.0, v=0.0):
print 'ArrangeUVByMat shape={0} mat={1} scale=[{2}, {3}], translate=[{4}, {5}]'.format(
shape, mat, su, sv, u, v)
faces = GetFacesByMat(shape, mat)
cmds.select(faces)
cmds.select(cmds.polyListComponentConversion(tuv=True), r=True)
cmds.polyEditUV(su=su, sv=sv)
cmds.polyEditUV(u=u, v=v)
cmds.select(clear=True)
def flipUVsByLocal(*args):
sel = cmds.ls(sl=True, fl=True, long=True)
u = 0.0
for i in sel:
uv = cmds.polyEditUV(i, relative=False, q=True, uValue=True)
u += uv[0]
uAve = u / len(sel)
u_tile = int(str(uAve)[0])
flipAxis = u_tile + 0.5
cmds.polyEditUV(relative=False, pivotU=flipAxis, scaleU=-1)
def flipUVsByLocal(*args):
sel = cmds.ls(sl=True, fl=True, long=True)
u = 0.0
for i in sel:
uv = cmds.polyEditUV(i, relative=False, q=True, uValue=True)
u += uv[0]
uAve = u / len(sel)
u_tile = int(str(uAve)[0])
flipAxis = u_tile + 0.5
cmds.polyEditUV(relative=False, pivotU=flipAxis, scaleU=-1)
def createAtlas(aItems):
'''Create UV atlas.'''
mel.eval('scriptEditorInfo -e -suppressWarnings true;') # @UndefinedVariable
for k in aItems:
cmds.select("%s.map[0:]" % k.mesh) # @UndefinedVariable
cmds.polyEditUV(pivotU=0, pivotV=1, scaleU=k.sizeX, scaleV=k.sizeY) # @UndefinedVariable
cmds.polyMoveUV(tu=k.posX, tv=-k.posY) # @UndefinedVariable
def modifyUVs(item, id, *args):
cmds.select(item)
cmds.select(cmds.polyListComponentConversion(tuv=True), r=True)
uvs = cmds.ls(sl=True, fl=True)
number = 0.5 + id
for uv in uvs:
cmds.select(uv)
cmds.polyEditUV(uv, relative=False, uValue=number, vValue=0.5)
def createUv(self,mesh):
cmds.polyForceUV(mesh, unitize = True)
edges = cmds.polyEvaluate(mesh, e = True)
cmds.select('%s.e[2:%s]' %(mesh, (edges-1)), r=True)
cmds.StitchTogether()
bbox = cmds.polyEvaluate(mesh, bc2 = True)
if bbox[0]>bbox[1]:
cmds.polyEditUV (mesh, r = True, a = 90)
cmds.polyNormalizeUV(mesh,normalizeType = 1, pa = True, cot = False, nd = 1)
cmds.unfold(mesh, i = 5000, ss=0.001, gb = 0, pub = False, ps = False, oa = 1, us = False)
cmds.select(cl=True)
def move(dTuple, *args):
if not mc.polyListComponentConversion(fuv=True):
mel.eval('warning "Please select some UVs"')
else:
steps = mc.floatField('steps', q=True, v=True)
sel = mc.ls(sl=True)
mel.eval('polySelectBorderShell 0')
mc.polyEditUV(u=(steps * dTuple[0]), v=(steps * dTuple[1]))
#Refocus selection
mc.select(sel, r=True)
return
def _get_uvmap_uvmin_uvmax(poly_name):
vertex_num = cmds.polyEvaluate(poly_name, v=True)
u_values = cmds.polyEditUV("%s.map[%d:%d]" % (poly_name, 0, vertex_num),
q=True,
u=True)
u_min, u_max = _get_min_max(u_values)
v_values = cmds.polyEditUV("%s.map[%d:%d]" % (poly_name, 0, vertex_num),
q=True,
v=True)
v_min, v_max = _get_min_max(v_values)
return u_min, u_max, v_min, v_max
def setMinMax(self):
xPositions = sorted(
[mc.polyEditUV(i, query=True)[0] for i in self.uvs])
yPositions = sorted(
[mc.polyEditUV(i, query=True)[1] for i in self.uvs])
self.minMax = (xPositions[0], xPositions[-1]), (yPositions[0],
yPositions[-1])
self.xMin = self.minMax[0][0]
self.xMax = self.minMax[0][1]
self.yMin = self.minMax[1][0]
self.yMax = self.minMax[1][1]
def stackShells():
shellBox = mc.polyEvaluate(bc2=True)
MPU = 0.5 * (shellBox[0][0] + shellBox[0][1])
MPV = 0.5 * (shellBox[1][0] + shellBox[1][1])
shells = uvShells()
for shell in shells:
shellBox = mc.polyEvaluate(shell, bc2=True)
piU = 0.5 * (shellBox[0][0] + shellBox[0][1])
piV = 0.5 * (shellBox[1][0] + shellBox[1][1])
posU = MPU - piU
posV = MPV - piV
mc.polyEditUV(shell, pu=piU, pv=piV, u=posU, v=posV)
def findAngle(tuple):
#Returns angle of two UV points
uv0 = tuple[0]
uv1 = tuple[1]
p1 = mc.polyEditUV(uv0, q=True)
p2 = mc.polyEditUV(uv1, q=True)
X = (p2[0] - p1[0])
Y = (p2[1] - p1[1])
radians = math.atan2(Y, X)
angle = radians * 57.2957795
return angle
def moveComponentsUVs(components, u=0, v=0): """ This definition moves given components UVs. :param components: Components. ( Tuple / List ) :param u: U value. ( Float ) :param v: V value. ( Float ) :return: Definition succes. ( Boolean ) """ uvs = getUVsFromComponents(components, flatten=False) cmds.polyEditUV(uvs, u=u, v=v) return True
def multi_merge(threshold):
selected_uv = cmds.ls(sl=True, flatten=True)
selected_uv_pos = cmds.polyEditUV(query=True)
length = len(selected_uv_pos)
pos_u = [selected_uv_pos[i] for i in range(length) if i % 2 == 0]
pos_v = [selected_uv_pos[i] for i in range(length) if i % 2 != 0]
for name in selected_uv:
current_u, current_v = cmds.polyEditUV(name, query=True)
for i in range(length / 2):
if sqrt( (pos_u[i] - current_u) ** 2 + (pos_v[i] - current_v) ** 2 ) < threshold:
cmds.select(selected_uv[i], r=True)
cmds.polyEditUV(u=current_u, v=current_v, r=False)
cmds.select(selected_uv)
def alignUVs(doU, minU, doV, inV):
"""
align selected uvs based on the one most on top, bottom, left, right
"""
# get the selected UVs from current selection
selectedItems = cmds.filterExpand(ex=False, sm=35) # 35 means UVs
uvMin = []
uvMax = []
# get the 3d bounding box of selection
uvInfo = cmds.polyEvaluate(bc2=True)
uvMin[0] = uvInfo[0]
uvMin[1] = uvInfo[2]
uvMax[0] = uvInfo[1]
uvMax[1] = uvInfo[3]
if doU:
if minU:
cmds.polyEditUV(r=False, u=uvMin[0])
else:
cmds.polyEditUV(r=False, u=uvMax[0])
if doV:
if minV:
cmds.polyEditUV(r=False, v=uvMin[1])
else:
cmds.polyEditUV(r=False, v=uvMax[1])
def mirrorGeometry(*args, **keywords):
# Mirror geometry together with UV. The UV of character can be splited into a number of U regions.
# usage: select geometry which is present in the +x side and UVs in U=0.5-1 region (and U=1.5-2, U=2.5-3, ...)
meshes = cmds.listRelatives(s=True, type="mesh", ni=True, f=True)
if meshes == None:
raise Exception, "No mesh selected"
results = []
for mesh in cmds.listRelatives(meshes, p=True, f=True):
verticesInRegion = {}
parent = cmds.listRelatives(mesh, p=True, f=True, pa=True)
mesh1 = cmds.duplicate(mesh)
mesh2 = cmds.duplicate(mesh)
cmds.scale(-1, 1, 1, mesh2, r=True)
# detect uv regions
# scan all vertices
vertices = cmds.ls(cmds.polyListComponentConversion(mesh2, tuv=True), fl=True)
for vertex in vertices:
uv = cmds.polyEditUV(vertex, query=True)
region = math.ceil(uv[0]) - 1
if region < 0:
region = 1
if not verticesInRegion.has_key(region):
verticesInRegion[region] = []
verticesInRegion[region].append(vertex)
# choose vertices in regions
# flip uv upon middle of regions
for region,vertices in verticesInRegion.iteritems():
cmds.select(vertices, r=True)
cmds.polyEditUV(pu=(region + 0.5), pv=0.5, su=-1, sv=1)
# combine objects and merge vertices
combined = cmds.polyUnite(mesh1, mesh2, ch=False)
if parent:
results += cmds.parent(combined, parent)
else:
results += combined
cmds.polyMergeVertex(d=0.005, ch=0)
cmds.select(results, r=True)
return results
def getUVFaceNormal( facepath ): uvs = getWindingOrder(facepath) if len(uvs) < 3: return (1,0,0) #if there are less than 3 uvs we have no uv area so bail #get edge vectors and cross them to get the uv face normal uvAPos = cmd.polyEditUV(uvs[0], query=True, uValue=True, vValue=True) uvBPos = cmd.polyEditUV(uvs[1], query=True, uValue=True, vValue=True) uvCPos = cmd.polyEditUV(uvs[2], query=True, uValue=True, vValue=True) uvAB = Vector( [uvBPos[0]-uvAPos[0], uvBPos[1]-uvAPos[1], 0] ) uvBC = Vector( [uvCPos[0]-uvBPos[0], uvCPos[1]-uvBPos[1], 0] ) uvNormal = uvAB.cross( uvBC ).normalize() return uvNormal
def getUVFaceNormal( facepath ): uvs = getWindingOrder(facepath) if len(uvs) < 3: return (1,0,0) #if there are less than 3 uvs we have no uv area so bail #get edge vectors and cross them to get the uv face normal uvAPos = cmd.polyEditUV(uvs[0], query=True, uValue=True, vValue=True) uvBPos = cmd.polyEditUV(uvs[1], query=True, uValue=True, vValue=True) uvCPos = cmd.polyEditUV(uvs[2], query=True, uValue=True, vValue=True) uvAB = Vector( [uvBPos[0]-uvAPos[0], uvBPos[1]-uvAPos[1]] ) uvBC = Vector( [uvCPos[0]-uvBPos[0], uvCPos[1]-uvBPos[1]] ) uvNormal = (uvAB ^ uvBC).normalize() return uvNormal
def centerComponentsUVs(components): """ This definition centers given components UVs. :param components: Components. ( Tuple / List ) :return: Definition succes. ( Boolean ) """ uvs = getUVsFromComponents(components) uMin, vMin, uMax, vMax = getComponentsBoundingBox(uvs) uCenter, vCenter = (uMin + uMax) / 2.0, (vMin + vMax) / 2.0 uTargetCenter, vTargetCenter = math.floor(uCenter), math.floor(vCenter) cmds.polyEditUV(uvs, u=uTargetCenter - uCenter + 0.5, v=vTargetCenter - vCenter + 0.5) return True
def scaleUV ( SelectedShapes, Action, sU, sV ):
print "UV Scale:"
try:
for i in range(len(SelectedShapes)):
SelectedFacesTemp = [ SelectedShapes[i] + '.f[:]']
cmds.select(SelectedFacesTemp)
cmds.polyEditUV( pivotU=0, pivotV=0, scaleU=sU, scaleV=sV )
print "PolygonTools. UV successfully scaled", Action, "for", gen_func.shortNamer(SelectedShapes[i])
cmds.select(SelectedShapes)
except:
pass
def moveUV ( SelectedShapes, Action, vU, vV ):
print "UV Move:"
try:
for i in range(len(SelectedShapes)):
SelectedFacesTemp = [ SelectedShapes[i] + '.f[:]']
cmds.select(SelectedFacesTemp)
cmds.polyEditUV( uValue = vU, vValue = vV )
print "PolygonTools. UV successfully moved", Action, "for", gen_func.shortNamer(SelectedShapes[i])
cmds.select(SelectedShapes)
except:
pass
def add_UV_grid_atter(self):
## make mi_object local
mi_object = self.mi_object
## get all UVs
UV_locations = mc.polyEditUV(mi_object.mNode + ".map[:]",
q=True,
u=True,
v=False)
## make a list for U and one for V
U_gridSpaces = []
V_gridSpaces = []
for i in range(len(UV_locations)):
if i % 2 == 0: #Why are you doing this? i in this case is going to always be an int, no?
#Check U'''
GridSpace = int(UV_locations[i])
if GridSpace not in U_gridSpaces:
U_gridSpaces.append(GridSpace)
else:
GridSpace = int(UV_locations[i])
if GridSpace not in V_gridSpaces:
V_gridSpaces.append(GridSpace)
## add atter to metaObject
mi_object.addAttr("U_gridSpace", U_gridSpaces)
mi_object.addAttr("V_gridSpace", V_gridSpaces)
def udimFromNode(node):
uPos, vPos = cmds.polyEditUV(node+'.map[1]', q=True)
uTile = int(math.floor(uPos))
vTile = int(math.floor(vPos))
udim = 1000+(uTile+1)+(vTile*10)
return udim, uTile, vTile
def getUVs(self):
# Getting current uvset
currUVSet = cmds.polyUVSet(self.name, q=True, currentUVSet=True)[0]
for i, uvSet in enumerate(self.uvSets):
self.uvs[uvSet] = []
# Setting uvSet temp
cmds.polyUVSet(self.name, currentUVSet=True, uvSet=uvSet)
# Get uv maps
uvMaps = cmds.polyListComponentConversion(self.name, ff=1, tuv=1)
if (uvMaps):
uvMaps = [
cmds.polyListComponentConversion(vtxFace, tuv=1)
for vtxFace in self.vtxFaceNames
]
# Check to make sure there are uv's on this face.
for uvMap in uvMaps:
# Get my uvValues
uvCoords = cmds.polyEditUV(uvMap, q=True)
self.uvs[uvSet].append(uvCoords)
# Returning to orginal uvSet
cmds.polyUVSet(self.name, currentUVSet=True, uvSet=currUVSet)
def resize(self, new_ratio):
"""
Resize ratio
"""
scale_amt = new_ratio / self.ratio
for i, transform in enumerate(self.transforms):
cmds.polyEditUV(
["{0}.map[{1}]".format(transform, m)
for m in self.uv_indexes[i]],
pivotU=self.centers[i][0],
pivotV=self.centers[i][1],
scaleU=scale_amt,
scaleV=scale_amt)
self.ratio = new_ratio
def StickObjectToMesh(vertex, mesh):
#*********** Get parent name ******************
ObjectParent = cmds.listRelatives(mesh, p=True)
#*********** Get object position ******************
position = cmds.xform(vertex, q=True, ws=True, t=True)
#******* Create a group driven by pointOnPolyContraint **********
groupName = cmds.group(em=True, name=("grp_ptc_" + mesh))
cmds.parent(groupName, ObjectParent[0])
#******* Get the UV map relationed with the vtx **********
mapList = cmds.polyListComponentConversion(vertex, fv=- True, tuv=True)
#******* Create a pointOnPolyContraint **********
contraintNames = cmds.pointOnPolyConstraint(vertex,
groupName,
mo=False,
o=[0, 0, 0],
w=1)
#************* Disconnect rotation chanel ****************************************
mel.eval("CBdeleteConnection " + groupName + ".rotateX;")
mel.eval("CBdeleteConnection " + groupName + ".rotateY;")
mel.eval("CBdeleteConnection " + groupName + ".rotateZ;")
#******* Get U and V values from map array **********
uvvalues = cmds.polyEditUV(mapList, q=True)
contraintAttr = cmds.listAttr(contraintNames[0], k=True)
#******* Assign the U and V values respectively from maplist **********
cmds.setAttr((contraintNames[0] + "." + contraintAttr[10]), uvvalues[0])
cmds.setAttr((contraintNames[0] + "." + contraintAttr[11]), uvvalues[1])
groupDrv = _2GrpUp(mesh)
cmds.parent(groupDrv, groupName)
GrpSubsTranslation(mesh)
def makeFollicle():
selection = cm.ls(sl=True)
for i in range(0, len(selection)):
pos = cm.xform(selection[i], q=True, t=True, ws=True)
follicleShape = cm.createNode('follicle')
maya.mel.eval('pickWalk -d up;')
follicle = cm.listRelatives(follicleShape, p=True)
follicle = follicle[0]
cm.move(pos[0], pos[1], pos[2], follicleShape, ws=True)
mesh = selection[0].split('.vtx')[0]
cm.connectAttr(mesh+'.outMesh', follicleShape+'.inputMesh', f=True)
cm.connectAttr(mesh+'.worldMatrix', follicleShape+'.inputWorldMatrix', f=True)
cm.connectAttr(follicleShape+'.outRotate', follicle+'.rotate', f=True)
cm.connectAttr(follicleShape+'.outTranslate', follicle+'.translate', f=True)
VtxToUV = cm.polyListComponentConversion(selection[i], fv=True, tuv=True)
cm.select(VtxToUV)
UV = cm.polyEditUV( query=True,)
print UV, mesh
cm.setAttr(follicleShape+'.parameterU', UV[0])
cm.setAttr(follicleShape+'.parameterV', UV[1])
def centerComponentsUVs(components): """ Centers given components UVs. :param components: Components. :type components: tuple or list :return: Definition succes. :rtype: bool """ uvs = getUVsFromComponents(components) uMin, vMin, uMax, vMax = getComponentsBoundingBox(uvs) uCenter, vCenter = (uMin + uMax) / 2.0, (vMin + vMax) / 2.0 uTargetCenter, vTargetCenter = math.floor(uCenter), math.floor(vCenter) cmds.polyEditUV(uvs, u=uTargetCenter - uCenter + 0.5, v=vTargetCenter - vCenter + 0.5) return True
def createFollicle():
sel = cmds.ls(sl = True,fl = True)
for i in range(len(sel)):
surfaceTransform = sel[i].split('.')[0]
surfaceShape = cmds.listRelatives(surfaceTransform,type = 'shape')[0]
uvPoint = sel[i]
uvValues = cmds.polyEditUV(uvPoint,query = True)
uValue = uvValues[0]
vValue = uvValues[1]
follicle = cmds.createNode('follicle')
follicleTransform = cmds.listRelatives(follicle,parent = True)[0]
cmds.connectAttr('%s.outTranslate'%follicle,'%s.translate'%follicleTransform)
cmds.connectAttr('%s.outRotate'%follicle,'%s.rotate'%follicleTransform)
cmds.setAttr('%s.parameterU'%follicle,uValue)
cmds.setAttr('%s.parameterV'%follicle,vValue)
cmds.connectAttr('%s.outMesh'%surfaceShape, '%s.inputMesh'%follicle,f = True)
cmds.connectAttr('%s.worldMatrix[0]'%surfaceShape, '%s.inputWorldMatrix'%follicle)
def testPolyUVs(self):
MayaCmds.polyCube(name='cube')
cubeObj = getObjFromName('cubeShape')
fnMesh = OpenMaya.MFnMesh(cubeObj)
# get the name of the current UV set
uvSetName = fnMesh.currentUVSetName()
uArray = OpenMaya.MFloatArray()
vArray = OpenMaya.MFloatArray()
fnMesh.getUVs(uArray, vArray, uvSetName)
newUArray = [0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 2, 2, -1, -1]
newVArray = [0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 0, 1, 0, 1]
for i in range(0, 14):
uArray[i] = newUArray[i]
vArray[i] = newVArray[i]
fnMesh.setUVs(uArray, vArray, uvSetName)
self.__files.append(util.expandFileName('polyUvsTest.abc'))
MayaCmds.AbcExport(j='-uv -root cube -file ' + self.__files[-1])
# reading test
MayaCmds.AbcImport(self.__files[-1], mode='open')
MayaCmds.select('cube.map[0:13]', replace=True)
uvs = MayaCmds.polyEditUV(query=True)
for i in range(0, 14):
self.failUnlessAlmostEqual(newUArray[i], uvs[2 * i], 4,
'map[%d].u is not the same' % i)
self.failUnlessAlmostEqual(newVArray[i], uvs[2 * i + 1], 4,
'map[%d].v is not the same' % i)
def testPolyUVs(self):
MayaCmds.polyCube(name = 'cube')
cubeObj = getObjFromName('cubeShape')
fnMesh = OpenMaya.MFnMesh(cubeObj)
# get the name of the current UV set
uvSetName = fnMesh.currentUVSetName()
uArray = OpenMaya.MFloatArray()
vArray = OpenMaya.MFloatArray()
fnMesh.getUVs(uArray, vArray, uvSetName)
newUArray = [0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 2, 2, -1, -1]
newVArray = [0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 0, 1 , 0, 1]
for i in range(0, 14):
uArray[i] = newUArray[i]
vArray[i] = newVArray[i]
fnMesh.setUVs(uArray, vArray, uvSetName)
self.__files.append(util.expandFileName('polyUvsTest.abc'))
MayaCmds.AbcExport(j='-uv -root cube -file ' + self.__files[-1])
# reading test
MayaCmds.AbcImport(self.__files[-1], mode='open')
MayaCmds.select('cube.map[0:13]', replace=True)
uvs = MayaCmds.polyEditUV(query=True)
for i in range(0, 14):
self.failUnlessAlmostEqual(newUArray[i], uvs[2*i], 4,
'map[%d].u is not the same' % i)
self.failUnlessAlmostEqual(newVArray[i], uvs[2*i+1], 4,
'map[%d].v is not the same' % i)
def flatten_marvelous_shells(shells):
"""
Usage:
flatten_marvelous_shells(mc.ls(sl=True))
"""
for obj in shells:
start_vert, end_vert = mc.ls(
mc.polyListComponentConversion(cmds.ls(obj + ".e[0]")[0], fe=True, tv=True), fl=True
)
start_scale = distance.euclidean(
mc.xform(start_vert, q=True, t=True, ws=True), mc.xform(end_vert, q=True, t=True, ws=True)
)
for uv in cmds.ls(obj + ".map[:]", fl=True):
uv_pos = mc.polyEditUV(uv, q=True)
uv_index = re.findall("\[([0-9]+)\]", uv)[0]
vertex = mc.polyListComponentConversion(uv, fuv=True, tv=True)[0]
mc.xform(vertex, t=[uv_pos[0]] + [0] + [uv_pos[1]], ws=True)
# Finally, scale it
end_scale = distance.euclidean(
mc.xform(start_vert, q=True, t=True, ws=True), mc.xform(end_vert, q=True, t=True, ws=True)
)
scale_by = start_scale / end_scale
mc.xform(mc.ls(obj + ".vtx[:]"), s=[scale_by, scale_by, scale_by], ws=True)
def getUVs(self):
# Getting current uvset
currUVSet = cmds.polyUVSet( self.name, q=True, currentUVSet=True )[0]
for i, uvSet in enumerate(self.uvSets):
self.uvs[uvSet] = []
# Setting uvSet temp
cmds.polyUVSet( self.name, currentUVSet=True, uvSet=uvSet )
# Get uv maps
uvMaps = cmds.polyListComponentConversion( self.name, ff=1, tuv=1 )
# verts = PolyFace.findWindingOrder(self.name)
# print(self.vtxFaceNames)
# cmds.polyListComponentConversion('pPlane2.vtxFace[2][1]', tuv=1 )
if( uvMaps ):
# uvMaps = cmds.filterExpand( uvMaps, expand=True, sm=35 )
uvMaps = [cmds.polyListComponentConversion(vtxFace, tuv=1 ) for vtxFace in self.vtxFaceNames ]
# Check to make sure there are uv's on this face.
for uvMap in uvMaps:
# Get my uvValues
uvCoords = cmds.polyEditUV( uvMap, q=True )
self.uvs[uvSet].append(uvCoords)
# Returning to orginal uvSet
cmds.polyUVSet( self.name, currentUVSet=True, uvSet=currUVSet)
def rotateComponentsUVs(components, value, clockWise=True): """ This definition rotates given components UVs. :param components: Components. ( Tuple / List ) :param value: Rotation value. ( Float ) :param clockWise: Rotation direction. ( Boolean ) :return: Definition succes. ( Boolean ) """ uvs = getUVsFromComponents(components) uCenter, vCenter = getComponentsUVsCenter(uvs) if not clockWise: value = -value cmds.polyEditUV(uvs, pu=uCenter, pv=vCenter, a= -value) return True
def hSewUvs(self, *args):
nodes = mc.ls(sl=True)
edges = mc.ls(mc.polyListComponentConversion(te=True), fl=True)
a = []
b = []
for edge in edges:
mc.select(edge)
uvs = mc.ls(mc.polyListComponentConversion(tuv=True), fl=True)
for uv in uvs:
p = mc.polyEditUV(uv, query=True)
a.append(p)
if len(a) == 4:
if a[0] == a[1] and a[2] == a[3]:
b.append(edge)
elif a[0] == a[2] and a[1] == a[3]:
b.append(edge)
elif a[0] == a[3] and a[1] == a[2]:
b.append(edge)
a = []
mc.progressBar(self.progress,
edit=True,
step=1,
maxValue=len(edges))
mc.select(b)
mc.SewUVs()
mc.select(nodes)
def mirrorComponentsUVs(components, horizontal=True): """ This definition mirrors given components UVs. :param components: Components. ( Tuple / List ) :param horizontal: Horizontal mirror. ( Boolean ) :return: Definition succes. ( Boolean ) """ uvs = getUVsFromComponents(components) uCenter, vCenter = (math.floor(value) for value in getComponentsUVsCenter(uvs)) if horizontal: cmds.polyEditUV(uvs, pu=uCenter + 0.5, pv=vCenter + 0.5, su= -1) else: cmds.polyEditUV(uvs, pu=uCenter + 0.5, pv=vCenter + 0.5, sv= -1) return True
def saw_uvs(self, mode='after'):
if mode == 'after':
saw_edges = self.saw_edges
self.n_uvs = []
else:
saw_edges = common.conv_comp(self.s_edges, mode='vtx')
saw_edges = common.conv_comp(saw_edges, mode='edge')
for edge in self.s_edges:
saw_edges.remove(edge)
if not saw_edges:
return
checked_edges = []
for edge in saw_edges:
uvs = common.conv_comp(edge, mode='uv')
uv_pos = [
str(map(lambda x: round(x, 5), cmds.polyEditUV(uv, q=True)))
for uv in uvs
]
#print len(uv_pos)
uv_pos = list(set(uv_pos))
#if mode=='pre':
#print edge, len(uv_pos)
if len(uv_pos) > 2:
continue
checked_edges.append(edge)
if checked_edges:
cmds.polyMapSew(checked_edges, ch=True)
cmds.polyMapSew(self.s_edges, ch=True) #付け根のUVを縫合する
self.saw_edges = []
cmds.select(self.ex_edges, r=True)
#ExtrudeEdgeUV()._init_ui()
def to_vals(self):
"""Get UV values.
Returns:
(float tuple): U/V values
"""
return cmds.polyEditUV(self, query=True)
def getUVs(self):
# Getting current uvset
currUVSet = cmds.polyUVSet(self.name, q=True, currentUVSet=True)[0]
for i, uvSet in enumerate(self.uvSets):
self.uvs[uvSet] = []
# Setting uvSet temp
cmds.polyUVSet(self.name, currentUVSet=True, uvSet=uvSet)
# Get uv maps
uvMaps = cmds.polyListComponentConversion(self.name, ff=1, tuv=1)
# verts = PolyFace.findWindingOrder(self.name)
# print(self.vtxFaceNames)
# cmds.polyListComponentConversion('pPlane2.vtxFace[2][1]', tuv=1 )
if (uvMaps):
# uvMaps = cmds.filterExpand( uvMaps, expand=True, sm=35 )
uvMaps = [
cmds.polyListComponentConversion(vtxFace, tuv=1)
for vtxFace in self.vtxFaceNames
]
# Check to make sure there are uv's on this face.
for uvMap in uvMaps:
# Get my uvValues
uvCoords = cmds.polyEditUV(uvMap, q=True)
self.uvs[uvSet].append(uvCoords)
# Returning to orginal uvSet
cmds.polyUVSet(self.name, currentUVSet=True, uvSet=currUVSet)
def set_UV_ratio(obj):
try:
print active_ratio
except:
om.MGlobal.displayError("Please pick a checker size first")
return
orig_sele = cmds.ls(sl=True, fl=True)
if len(orig_sele) == 0:
om.MGlobal.displayError("Select at least one object")
return
prog = 0.00
cmds.progressBar(progressControl, edit=True, visible=True)
cmds.progressBar(progressControl, edit=True, beginProgress=True)
for i in range(0, len(orig_sele)):
if (len(orig_sele) != 0):
if (obj == 1):
prog += (i * 1.000 / len(orig_sele) * 1.000) * 20
cmds.progressBar(progressControl, edit=True, pr=prog)
else:
prog += (i * 1.000 / len(orig_sele) * 1.000) * 15
cmds.progressBar(progressControl, edit=True, pr=4 + prog)
cmds.select(cl=True)
mel.eval("select " + orig_sele[i])
current_ratio = get_sel_faces_UV_ratio(0)
if current_ratio == 0:
current_ratio = 1
scale_factor = active_ratio / current_ratio
scale_factor = math.sqrt(scale_factor)
mel.eval("PolySelectConvert 4")
UV_bounds = cmds.polyEvaluate(bc2=True)
u_pivot = (UV_bounds[0][0] + UV_bounds[0][1]) / 2
v_pivot = (UV_bounds[1][0] + UV_bounds[1][1]) / 2
cmds.polyEditUV(pu=u_pivot,
pv=v_pivot,
su=scale_factor,
sv=scale_factor)
cmds.select(cl=True)
for i in range(0, len(orig_sele)):
mel.eval("select -add " + orig_sele[i])
cmds.progressBar(progressControl, edit=True, endProgress=True)
cmds.progressBar(progressControl, edit=True, visible=False)
om.MGlobal.displayInfo("Done")
def getCurrentCoords( vertex ): uv = cmds.polyListComponentConversion( vertex, fv=True, tuv=True ) if( uv ): uvAll = cmds.filterExpand( uv, expand=True, sm=35 ) uvCoords = cmds.polyEditUV( uvAll , q=True ) return uvCoords else: return []
def move_uv(self, face):
#print 'uv_edge :', self.uv_edge
uvs = common.conv_comp(face, mode='uv') #作成したフェースのUV
edge_uvs = common.conv_comp(self.uv_edge, mode='uv') #選択エッジのUV
for uv in uvs:
try:
vtx = common.conv_comp(uv, mode='vtx') #UVが属する頂点
vtx_uv = common.conv_comp(vtx, mode='uv') #頂点の共有UVたち
target_uv = list((set(vtx_uv) & set(edge_uvs)) - set(uvs))
#print 'get_target uv', target_uv, uv
pos = cmds.polyEditUV(target_uv[0], query=True)
cmds.polyEditUV(uv, u=pos[0], v=pos[1], r=False)
except:
return
#UVつないでおく
face_edges = common.conv_comp(face, mode='edge')
cmds.polyMergeUV(face_edges, ch=1, d=0.01)
def solidifyObject(object, height=1, divisions=2, history=True): """ Solidifies given object. :param object: Object. :type object: str :param height: Extrusion height. :type height: float :param division: Extrusion divisions. :type division: float :param history: Keep construction history. :type history: bool """ if hasBorderEdges(object): transform = getTransform(object) vertices = cmds.ls(cmds.polyListComponentConversion(object, toVertex=True), fl=True) barycenters = cmds.xform(vertices, q=True, t=True, ws=True) barycenter = getAverageVector([(barycenters[i], barycenters[i + 1], barycenters[i + 2]) for i in range(0, len(barycenters), 3)]) normals = cmds.polyNormalPerVertex(cmds.polyListComponentConversion(object, toVertexFace=True), q=True, xyz=True) normals = [(normals[i], normals[i + 1], normals[i + 2]) for i in range(0, len(normals), 3)] averageNormal = vectorMatrixMultiplication(normalize(getAverageVector(normals)), cmds.xform(transform, query=True, matrix=True, worldSpace=True)) facesCount = cmds.polyEvaluate(object, face=True) faces = object + ".f[0:" + str(facesCount - 1) + "]" extrude = cmds.polyExtrudeFacet(faces, constructionHistory=1, keepFacesTogether=1, divisions=divisions) cmds.setAttr(extrude[0] + ".localTranslateZ", height) borderEdges = cmds.polyListComponentConversion(faces, te=True, bo=True) cmds.polyMapCut(borderEdges) uvs = cmds.polyListComponentConversion(object + ".f[0:" + str(facesCount - 1) + "]", toUV=1) cmds.polyEditUV(uvs, u=0, v=-5) extendedFaces = cmds.ls(faces, fl=True) for i in range(divisions): adjacentEdges = cmds.polyListComponentConversion(extendedFaces, ff=True, te=True) extendedFaces.extend(cmds.ls(cmds.polyListComponentConversion(adjacentEdges, fe=True, tf=True), fl=True)) borderFaces = list(set(extendedFaces).difference(set(cmds.ls(faces, fl=True)))) cmds.select(borderFaces) cmds.polyAutoProjection(borderFaces, t=barycenter, ry=getAngle((0, 0, 1), averageNormal), rz=getAngle((1, 0, 0), averageNormal)) uvs = cmds.polyListComponentConversion(borderFaces, toUV=1) cmds.polyEditUV(uvs, u=0, v=-5) not history and cmds.delete(object, ch=True)
def moveComponentsUVs(components, u=0, v=0): """ Moves given components UVs. :param components: Components. :type components: tuple or list :param u: U value. :type u: float :param v: V value. :type v: float :return: Definition succes. :rtype: bool """ uvs = getUVsFromComponents(components, flatten=False) cmds.polyEditUV(uvs, u=u, v=v) return True
def getCurrentCoords(vertex):
uv = cmds.polyListComponentConversion(vertex, fv=True, tuv=True)
if (uv):
uvAll = cmds.filterExpand(uv, expand=True, sm=35)
uvCoords = cmds.polyEditUV(uvAll, q=True)
return uvCoords
else:
return []
def setmesh(nodename):
cmds.select(nodename)
exts = getnames()
va, na, pa, uva = exts
nva, nna, npa, nuva = [nodename+"."+ext for ext in exts]
# Vertices first.
vl = cmds.xform(nodename+'.vtx[:]', q=True, os=True, t=True)
cmds.addAttr(longName=va, dt="string")
cmds.setAttr(nva, str(vl), type="string")
# Polygons (called faces in Maya).
pcnt = cmds.polyEvaluate(f=True)
cmds.addAttr(longName=pa, dt="string")
pll = []
for x in range(pcnt):
fvl = cmds.polyInfo(nodename+".f[%i]" % x, faceToVertex=True)
p = fvl[0].split()[2:]
pll += ["[" + ",".join(p) + "]"]
pll = "[" + ",".join(pll) + "]"
cmds.setAttr(npa, pll, type="string")
pl = eval(pll)
# Normals and UVs (needs polygons).
nll = []
# UVs are only used if user has set a non-default UV-set
# name (use right-click menu).
cmds.select(nodename)
hasUv = (cmds.polyUVSet(q=True, allUVSets=True) != ['map1'])
uvcnt = 0
#print("Set is: "+str(cmds.polyUVSet(q=True, allUVSets=True)))
cmds.addAttr(longName=na, dt="string")
if hasUv:
cmds.addAttr(longName=uva, dt="string")
uvll = []
for polyidx in range(pcnt):
poly = pl[polyidx]
for vtxidx in poly:
sel = nodename+".vtxFace["+str(vtxidx)+"]["+str(polyidx)+"]"
cmds.select(sel)
n = cmds.polyNormalPerVertex(q=True, xyz=True);
nll += n
if hasUv:
uv_names = cmds.polyListComponentConversion(fromVertexFace=True, toUV=True)
if uv_names:
uv_name = uv_names[0]
cmds.select(uv_name)
uv = cmds.polyEditUV(q=True)
uvll += uv
uvcnt += 1
#print "Normals: "+str(nll)
cmds.setAttr(nna, str(nll), type='string')
if hasUv:
#print "UVs: "+str(uvll)
cmds.setAttr(nuva, str(uvll), type='string')
return (1, len(vl)/3+len(pl)+len(nll)/3+uvcnt)
def stackObjectsUVs(objects, alignement="center", horizontal=True, margin=0): """ Stacks given objects UVs. :param objects: Objects. :type objects: tuple or list :param alignement: Alignement ( "bottom", "top", "left", "right", "center" ). :type alignement: str :param horizontal: Horizontal stack. :type horizontal: bool :return: Definition succes. :rtype: bool """ if not objects: return uvs = getUVsFromComponents(objects.pop(0)) uCenter, vCenter = getComponentsUVsCenter(uvs) uMin, vMin, uMax, vMax = getComponentsBoundingBox(uvs) uBorder = uMax - uMin + uMin vBorder = vMax - vMin + vMin for object in objects: uvs = getUVsFromComponents(object) currentUMin, currentVMin, currentUMax, currentVMax = getComponentsBoundingBox(uvs) if horizontal: offsetU = uBorder - currentUMin + margin if alignement == "bottom": offsetV = vMin - currentVMin elif alignement == "center": offsetV = (vMin - currentVMin) / 2 + (vMax - currentVMax) / 2 elif alignement == "top": offsetV = vMax - currentVMax uBorder = uBorder + currentUMax - currentUMin + margin else: offsetV = vBorder - currentVMin + margin if alignement == "left": offsetU = uMin - currentUMin elif alignement == "center": offsetU = (uMin - currentUMin) / 2 + (uMax - currentUMax) / 2 elif alignement == "right": offsetU = uMax - currentUMax vBorder = vBorder + currentVMax - currentVMin + margin cmds.polyEditUV(uvs, u=offsetU, v=offsetV) return True
def surfCts(name, vertSets):
'''
jntsIks[0] = lists of 3 joint sets
jntsIks[1] = list of ik handles, one for each three joint set
'''
#controllers, constraints
geoParent = []
j = 0
for vSet in vertSets:
i = 0
setName = ["", "_aim", "_up"]
rootCtGp = None
aimCt = None
upCt = None
for point in vSet:
if i < 3:
# controller
diamond = place.Controller(name + '_' + str(('%0' + str(2) + 'd') % (j)) + setName[i], point, False, 'diamond_ctrl', 5, 12, 8, 1, (0, 0, 1), True, True)
DiamondCt = diamond.createController()
place.cleanUp(DiamondCt[0], Ctrl=True)
cnst = cmds.pointOnPolyConstraint(point, DiamondCt[0])[0]
# convert vertex to uv
uv = cmds.polyListComponentConversion(point, fv=True, tuv=True)
# get uv space
space = cmds.polyEditUV(uv, q=True)
# set uv attrs on constraint
cmds.setAttr(cnst + '.' + point.rsplit('.')[0] + 'U0', space[0])
cmds.setAttr(cnst + '.' + point.rsplit('.')[0] + 'V0', space[1])
# append geoParent
if i == 0:
geoParent.append(DiamondCt[4])
rootCtGp = DiamondCt[1]
elif i == 1:
aimCt = DiamondCt[4]
cmds.setAttr(DiamondCt[0] + '.visibility', False)
elif i == 2:
upCt = DiamondCt[4]
cmds.setAttr(DiamondCt[0] + '.visibility', False)
# constraint
'''
if i==1:
##ik
cmds.pointConstraint(DiamondCt[4], jntsIks[1][j])
else:
##joint
cmds.pointConstraint(DiamondCt[4], jntsIks[0][j][i])
'''
else:
# constrain joint to first controller of vert set list
cmds.parentConstraint(geoParent[j], point, mo=True)
i = i + 1
# aim constraint
cmds.aimConstraint(aimCt, rootCtGp, mo=True,
aimVector=(0, 0, 1), upVector=(0, 1, 0),
worldUpType='object', worldUpObject=upCt)
j = j + 1
return geoParent
def scaleCenterComponentsUVs(components, coverage=DEFAULT_SCALE_COVERAGE): """ This definition scales / centers given components UVs. :param components: Components. ( Tuple / List ) :return: Definition succes. ( Boolean ) """ uvs = getUVsFromComponents(components) uMin, vMin, uMax, vMax = getComponentsBoundingBox(uvs) uCenter, vCenter = (uMin + uMax) / 2.0, (vMin + vMax) / 2.0 uTargetCenter, vTargetCenter = math.floor(uCenter), math.floor(vCenter) cmds.polyEditUV(uvs, u=uTargetCenter - uCenter + 0.5, v=vTargetCenter - vCenter + 0.5) uScale = math.fabs(uMin - uMax) vScale = math.fabs(vMin - vMax) scaleFactor = 1 / max(uScale, vScale) * coverage cmds.polyEditUV(uvs, pu=uTargetCenter + 0.5, pv=vTargetCenter + 0.5, su=scaleFactor, sv=scaleFactor) return True
def scaleComponentsUVs(components, su=1, sv=1): """ This definition scales given components UVs. :param components: Components. ( Tuple / List ) :param su: Scale U value. ( Float ) :param sv: Scale V value. ( Float ) :return: Definition succes. ( Boolean ) """ if su == 0.0: su = 1e-15 if sv == 0.0: sv = 1e-15 uvs = getUVsFromComponents(components) uCenter, vCenter = getComponentsUVsCenter(uvs) cmds.polyEditUV(uvs, pu=uCenter, pv=vCenter, su=su, sv=sv) return True
def lineup_V_in_UDIM(self,*args):
sels = cmds.ls(os=1)
gap_w = cmds.floatField("gapWValueField", q=True, v=True)
gap_h = cmds.floatField("gapHValueField", q=True, v=True)
initGap = 0.003
fst_in_UDIM = 0
for i, x in enumerate(sels):
cmds.select('{0}.map[:]'.format(x), r=1)
if i == 0:
# move to the init place
cmds.polyEditUV(u=-cmds.polyEvaluate(x, b2=1)[0][0] + initGap, v=-cmds.polyEvaluate(x, b2=1)[1][0] + initGap)
elif i >= 1:
# get the size of the last shell
w_last = cmds.polyEvaluate(sels[i-1], b2=1)[0][1]-cmds.polyEvaluate(sels[i-1], b2=1)[0][0]
h_last = cmds.polyEvaluate(sels[i-1], b2=1)[1][1]-cmds.polyEvaluate(sels[i-1], b2=1)[1][0]
# calc the distance to the last shell
dist_u = cmds.polyEvaluate(x, b2=1)[0][0]-cmds.polyEvaluate(sels[i-1], b2=1)[0][0]
dist_v = cmds.polyEvaluate(x, b2=1)[1][0]-cmds.polyEvaluate(sels[i-1], b2=1)[1][0]
# move current shell to the last shell
cmds.polyEditUV(u=-dist_u, v=-dist_v+h_last+gap_h)
# get the UDIM ID of the current shell and the last shell
UDIM = int((math.floor(cmds.polyEvaluate(x, b2=1)[0][1])+1)+(math.floor(cmds.polyEvaluate(x, b2=1)[1][1])*10))
UDIM_last = int((math.floor(cmds.polyEvaluate(sels[i-1], b2=1)[0][1])+1)+(math.floor(cmds.polyEvaluate(sels[i-1], b2=1)[1][1])*10))
# if shell V is out of UDIM
if int((math.floor(cmds.polyEvaluate(x, b2=1)[0][1])+1)+(math.floor(cmds.polyEvaluate(x, b2=1)[1][1])*10))-UDIM_last==10:
new_u = -(cmds.polyEvaluate(x, b2=1)[0][0]-cmds.polyEvaluate(sels[fst_in_UDIM:i], b2=1)[0][1])+gap_w
new_v = -(cmds.polyEvaluate(x, b2=1)[1][0]-initGap)#+int(math.floor((UDIM-11) / 10))
cmds.polyEditUV(u=new_u, v=new_v)
if int((math.floor(cmds.polyEvaluate(x, b2=1)[0][1])+1)+(math.floor(cmds.polyEvaluate(x, b2=1)[1][1])*10))-UDIM_last==1:
new_u = -(cmds.polyEvaluate(x, b2=1)[0][0]-initGap)+(int((math.floor(cmds.polyEvaluate(x, b2=1)[0][1])+1)+(math.floor(cmds.polyEvaluate(x, b2=1)[1][1])*10))-1)
new_v = -(cmds.polyEvaluate(x, b2=1)[1][0]-initGap)#+int(math.floor((UDIM-11) / 10))
cmds.polyEditUV(u=new_u, v=new_v)
# elif cmds.polyEvaluate(x, b2=1)[0][0] > 10:
# new_u = -cmds.polyEvaluate(x, b2=1)[0][0]+initGap
# new_v = cmds.polyEvaluate(x, b2=1)[1][0]+1
# cmds.polyEditUV(u=new_u, v=new_v)
elif int((math.floor(cmds.polyEvaluate(x, b2=1)[0][1])+1)+(math.floor(cmds.polyEvaluate(x, b2=1)[1][1])*10))-UDIM_last==1:
new_u = -(cmds.polyEvaluate(x, b2=1)[0][0]-cmds.polyEvaluate(sels[fst_in_UDIM:i], b2=1)[0][1])+gap_w
new_v = -(cmds.polyEvaluate(x, b2=1)[1][0]-initGap)+int(math.floor((UDIM-11) / 10))
cmds.polyEditUV(u=new_u, v=new_v)
cmds.select(sels,r=1)
def uvOffsetor() : sels = mc.ls( sl=True ) for ix in range( len( sels ) ) : obj = sels[ix] vtxNo = mc.polyEvaluate( obj , v=True ) mc.select( '%s.vtx[0:%d]' % ( obj , vtxNo ) , r=True ) cmd = 'PolySelectConvert 4;' mm.eval( cmd ) mc.polyEditUV( u=ix ) mc.select( sels )
def getComponentUVDims(component): """ This definition returns the UVDims of the given component. :param component: Component to retrieve the UVDims. ( String ) :return: UVDims. ( Tuple ) """ u, v = cmds.polyEditUV(component, q=True, uValue=True, vValue=True) return int(u), int(v)
