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 copyAndLayout(self):
self.currentMap = cmds.optionMenuGrp(self.uvSetChoice, q=True, v=True)
cmds.polyCopyUV(self.selFace, cm=True, uvi=self.currentMap, uvs=self.inputLightmap)
cmds.polyMultiLayoutUV(scale=1, rotateForBestFit=2, layout=2, ps=3.2, uvs=self.inputLightmap)
cmds.TextureViewWindow() #opens uv texture editor
cmds.select(self.sel) #selects original objects to get out of face selection
cmds.deleteUI(self.optionWindow)
def prescaleUVsShells(object): """ Prescales object UVs shells. :param objects: Object. :type objects: str :return: Definition succes. :rtype: bool """ 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 fixUVscale(*args):
try:
if not cmds.pluginInfo("rainUVPrescale", q=True, l=True):
cmds.loadPlugin('rainUVPrescale.py')
except:
pass
mel.eval('rainUVPrescale;')
cmds.polyMultiLayoutUV(lm=1, sc=1, rbf=1, fr=0, ps=0.1, l=2)
def clean(tube_name, transform, temp_stroke, new_curve, caps):
cmds.polyMultiLayoutUV( scale=1, rotateForBestFit=2, layout=2 )
cmds.delete(transform, ch=1)
cmds.delete(temp_stroke)
if new_curve:
cmds.delete(new_curve)
cmds.rename(transform, tube_name)
if caps:
try:
[ mel.eval (' select -r {}; performNormalBasedProjection 0; '.format(i)) for i in caps ]
except:
pass
def copyAndLayout(self):
global preScale
percentageSpace = cmds.floatSliderGrp(self.shellSpacingSlider, q=True, v=True) #get percentage space from slider
self.currentMap = cmds.optionMenuGrp(self.uvSetChoice, q=True, v=True)
cmds.polyCopyUV(self.selFace, cm=True, uvi=self.currentMap, uvs=self.inputLightmap)
#cmds.polyMultiLayoutUV(psc=2, scale=1, rotateForBestFit=2, layout=2, ps=percentageSpace, uvs=self.inputLightmap) Default settings
cmds.polyMultiLayoutUV(psc=preScale, scale=layoutScale, lm=layoutMapping, rotateForBestFit=layoutRotate, layout=shellLayout, ps=percentageSpace, uvs=self.inputLightmap)
cmds.TextureViewWindow() #opens uv texture editor
cmds.select(self.sel) #selects original objects to get out of face selection
cmds.deleteUI(self.optionWindow)
print preScale
print shellLayout
def doit(self, *argvs):
sels = cmds.ls(sl=1)
alluvs = cmds.polyListComponentConversion(sels, tuv=1)
if self.topoCheck(sels):
self.transferUVs(sels)
cmds.select(cmds.polyListComponentConversion(sels[0], tuv=1))
umin, umax, vmin, vmax = calc.getMinMax()
values = self.uvField.getValue()
space = self.space.getValue()
countU = values[0]
countV = values[1]
interval = space[0]
select = self.mode.getSelect()
direction = 'U'
if select != 1:
direction = 'V'
select = self.dirc.getSelect()
dirc = 1
if select != 1:
dirc = -1
lengthU = umax - umin + interval
lengthV = vmax - vmin + interval
j = 0
iCnt = 0
maxShellCount = self.shellCount.getValue1()
values = []
## get uv positions to move
for i in range(len(sels)):
cur = i + 1
uvalue = lengthU * iCnt
vvalue = lengthV * iCnt
if direction == 'U':
if j == 0:
values.append((uvalue * dirc, -lengthV * j))
else:
values.append(
((uvalue - lengthU) * dirc, -lengthV * j))
if cur % countU == 0 and i != 0:
j += 1
iCnt = 0
else:
if j == 0:
values.append((lengthU * j, -vvalue * dirc))
else:
values.append(
(lengthU * j, (-vvalue + lengthV) * dirc))
if cur % countV == 0 and i != 0:
j += 1
iCnt = 0
iCnt += 1
shuffled = []
origin = values[0]
if self.shuffleCB.getValue1() and not self.useOverlap.getValue1():
random.shuffle(values)
## move uvs
for i in range(len(sels)):
v = i
if self.useOverlap.getValue1():
v = i % maxShellCount
if self.shuffleCB.getValue1() and i > 0:
v = random.randint(0, maxShellCount - 1)
if i == 0:
self.offsetUVs(sels[i], origin[0], origin[1])
else:
self.offsetUVs(sels[i], values[v][0], values[v][1])
cmds.select(alluvs)
if self.fitCB.getValue1():
cmds.polyMultiLayoutUV(lm=1,
sc=2,
rbf=0,
fr=1,
ps=0.2,
l=0,
psc=0,
su=1,
sv=1,
ou=0,
ov=0)
if self.adjustCB.getValue1():
cmds.polyMultiLayoutUV(lm=0,
sc=1,
rbf=0,
fr=1,
ps=0.05,
l=0,
psc=0,
su=1,
sv=1,
ou=0,
ov=0)
cmds.select(sels)
else:
pm.warning(
'There are wrong topology object. please check selected objects'
)
def createLightmap(self, *args):
selection = cmds.ls(sl=True)
if len(selection) == 0:
return
mesh = selection[0]
if cmds.checkBox("cbDeleteHistory", q=True, v=True) == True:
cmds.delete(mesh, ch=True)
maxArc = cmds.textFieldGrp("tTolerance", q=True, text=True)
if re.search("[a-zA-Z]", maxArc) != None:
cmds.textFieldGrp("tTolerance", e=True, text="5")
maxArc = int(cmds.textFieldGrp("tTolerance", q=True, text=True))
# 1. Create a new UV Set
if "lightmap" in cmds.polyUVSet(q=True, auv=True):
cmds.polyUVSet(uvs="lightmap", delete=True)
faceCount = cmds.polyEvaluate(mesh, f=True)
cmds.polyUVSet(copy=True, nuv="lightmap")
cmds.polyUVSet(mesh, cuv=True, uvs="lightmap")
# 2. Cut every UV Edge
edgeCount = cmds.polyEvaluate(mesh, e=True)
cmds.polyMapCut(mesh + ".e[0:" + str(edgeCount - 1) + "]", cch=True, ch=False)
cmds.progressWindow(
title="Creating Lightmap...",
progress=0,
maxValue=faceCount + 1,
isInterruptable=True,
status="Facecount: " + str(faceCount),
)
# 3. Check if faces are connected and facing the same direction, if they do, then sew the uv edge
i = 0
while i < faceCount:
if cmds.progressWindow(query=True, isCancelled=True):
break
face = mesh + ".f[" + str(i) + "]"
adjacentFaces = self.getAdjacentFaces(mesh, i)
normal1 = self.getFaceNormal(face)
for adj in adjacentFaces:
normal2 = self.getFaceNormal(adj)
arc = self.getAngle(normal1, normal2)
if arc < maxArc:
self.sewFaces(face, adj)
cmds.progressWindow(edit=True, progress=i)
i += 1
cmds.select(mesh)
# 4. unfold
cmds.unfold(i=5000, ss=0.001, gb=False, gmb=0.5, ps=0, oa=0, us=True)
# 5. layout
preset = self.maps[cmds.optionMenuGrp("omTexSize", q=True, value=True)]
cmds.polyMultiLayoutUV(lm=1, sc=1, rbf=1, fr=True, l=2, ps=preset)
cmds.progressWindow(endProgress=True)
def generate(self):
exist, hairList = self.getGeos()
if not exist:
return
if self.useUI:
valueToBar = 100.0 / len(hairList)
varNormal = 0
allCurvesGrp = cmds.createNode("transform", name="hair_curves_GRP")
for hair in hairList:
if self.useUI:
varNormal += valueToBar
self.bar.setValue(varNormal)
# esto me selecciona todos los edge vertex , recordar apagar los constraints de seleccion :
pym.select(hair)
cmds.polySelectConstraint(m=3, t=1, w=1)
cmds.polySelectConstraint(dis=True)
vtxL = pym.ls(sl=1, fl=1)
# getOrderedLoops .- es el proceso para generar un dict de todos los loops de la geometria ordenados
loopDict = self.getOrderedLoops(vtxL)
if self.multCrvOn:
tempFolyGrp = cmds.createNode("transform",
name="{0}_follicles_GRP".format(
hair.name()))
curveGrp = cmds.createNode("transform",
name="{0}_curves_GRP".format(
hair.name()))
centerList = []
tempPlane = None
folNames = []
folAllPos = {}
if self.locsOn:
centerGrp = cmds.createNode("transform",
name="{0}_locators_GRP".format(
hair.name()))
cmds.parent(centerGrp, curveGrp)
for edgeLoop in sorted(loopDict.keys()):
strNames = [v.name() for v in loopDict[edgeLoop]]
vtxPos = [
cmds.xform(v, q=True, ws=True, t=True) for v in strNames
]
center = self.getCenterFromSel(strNames)
if (self.snapToGeo is not None) and (edgeLoop == "0000"):
snappedCenter = self.getClosestMeshPoint(
self.snapToGeo, center)
center = (snappedCenter[0], snappedCenter[1],
snappedCenter[2])
centerList.append(center)
if self.multCrvOn:
if not tempPlane:
tempCir = cmds.circle(d=1,
nr=(0, 1, 0),
s=len(vtxPos),
n="{0}_tempCircle".format(hair))
cirPos = []
for i in range(len(vtxPos)):
cirPos.append(
cmds.xform("{0}.cv[{1}]".format(tempCir[0], i),
ws=True,
t=True,
q=1))
if i == len(vtxPos) - 1:
cirPos.append(
cmds.xform("{0}.cv[{1}]".format(
tempCir[0], len(vtxPos)),
ws=True,
t=True,
q=1))
cmds.delete(tempCir)
tempPlane = cmds.polyCreateFacet(
name="{0}_follyPlane".format(hair), p=cirPos[:-1])
cmds.polyMultiLayoutUV(
tempPlane[0],
lm=1,
sc=2,
rbf=1,
fr=1,
ps=0.1,
psc=0,
su=2.1,
sv=2.1,
ou=-1.05,
ov=-1.05) # scale all the uv t the FULL U V space
pmPlane = pym.PyNode(tempPlane[0])
# Vogels algorthm
golden_angle = math.pi * (3 - math.sqrt(5))
points = []
for i in xrange(self.crvNumber):
theta = i * golden_angle
r = math.sqrt(i) / math.sqrt(self.crvNumber)
points.append(
(r * math.cos(theta), r * math.sin(theta)))
# Vogels algorthm end
for i in points:
oFoll = self.create_follicle(pmPlane, i[0], i[1])
cmds.parent(oFoll.getParent().name(), tempFolyGrp)
folNames.append(oFoll.getParent().name())
folAllPos[oFoll.getParent().name()] = []
for pos in vtxPos:
cmds.xform("{0}.vtx[{1}]".format(
tempPlane[0], vtxPos.index(pos)),
ws=True,
t=(pos[0], pos[1], pos[2]))
else:
for pos in vtxPos:
cmds.xform("{0}.vtx[{1}]".format(
tempPlane[0], vtxPos.index(pos)),
ws=True,
t=(pos[0], pos[1], pos[2]))
if (self.snapToGeo is not None) and (edgeLoop == "0000"):
for fol in folNames:
pos = cmds.xform(fol, ws=1, q=1, t=1)
snappedCenterFol = self.getClosestMeshPoint(
self.snapToGeo, pos)
centerFol = [
snappedCenterFol[0], snappedCenterFol[1],
snappedCenterFol[2]
]
folAllPos[fol].append(centerFol)
else:
for fol in folNames:
pos = cmds.xform(fol, ws=1, q=1, t=1)
folAllPos[fol].append(pos)
if self.locsOn:
spaceLoc, = cmds.spaceLocator(
name="{0}_{1}_center_LOC".format(
hair.name(), edgeLoop))
cmds.setAttr(spaceLoc + ".t", *center)
cmds.setAttr(spaceLoc + ".s", *[0.1, 0.1, 0.1])
cmds.parent(spaceLoc, centerGrp)
if self.crvOn:
centerCurveGrp = cmds.createNode(
"transform",
name="{0}_centerCurve_GRP".format(hair.name()))
centerCurve = cmds.curve(
d=float(self.crvDgree),
p=centerList,
name="{0}_center_curve_d1".format(hair))
cmds.parent(centerCurve, centerCurveGrp)
cmds.parent(centerCurveGrp, curveGrp)
if self.multCrvOn:
multiGrp = cmds.createNode("transform",
name="{0}_multiCurve_GRP".format(
hair.name()))
for fol in folNames:
multCurve = cmds.curve(d=float(self.crvDgree),
p=folAllPos[fol],
name="multi_curve_d1_{0}".format(
fol.split("_")[-1]))
cmds.parent(multCurve, multiGrp)
cmds.parent(multiGrp, curveGrp)
cmds.delete(tempPlane, tempFolyGrp)
cmds.parent(curveGrp, allCurvesGrp)
if self.chuncksGeoOn:
origHairParent = cmds.listRelatives(hair.name(), p=1)
hairChunksGRP, newhair = self.createChunksFromGeo(
hair, loopDict)
cmds.parent(hairChunksGRP, allCurvesGrp)
if origHairParent != None:
cmds.parent(newhair, origHairParent)
# auto generate atlasUV for all selected meshes
import maya.cmds as cmds
meshes = cmds.ls(sl=1, fl=1)
for mesh in meshes:
allUVSets = cmds.polyUVSet(mesh,q=1,auv=1)
if 'atlasUV' in allUVSets:
cmds.polyUVSet(mesh, delete=True, uvSet='atlasUV')
cmds.polyUVSet(mesh, copy=True, uvSet='map1', newUVSet='atlasUV')
cmds.polyUVSet(mesh, currentUVSet=True, uvSet='atlasUV')
cmds.polyMultiLayoutUV(meshes,uvs="atlasUV",l=2,rbf=1,sc=1,lm=1,fr=1,ps=0.2)
# toggle between map1 and atlasUV
# This script will switch UV Set between "map1" and "atlasmap".
# Useage:
# Select meshes which have both map1 and atlas map. Run this script
import maya.cmds as cmds
spnd = cmds.ls(sl=True, fl=True, dag=True, type='shape')
curUVset = cmds.polyUVSet(spnd[0],q=True, currentUVSet=True)
if curUVset[0] == 'map1':
for sp in spnd:
cmds.polyUVSet(sp, currentUVSet=True, uvSet="atlasUV")
elif curUVset[0] == 'atlasUV':
for sp in spnd:
cmds.polyUVSet(sp, currentUVSet=True, uvSet="map1")
