def setValue(main,vt,u,v):
p=lx.eval("query layerservice vert.polyList ? %s" % vt)
uv=lx.eval("query layerservice uv.pos ? (%s,%s)" % (p[0],vt))
du=u-uv[0]
dv=v-uv[1]
lx.command("select.element",layer=main,type="vertex",mode="set",index=int(vt))
uvtrans(du,dv)
def getConnectedPolys(polygon_index_list):
connected_poly_list = []
lx.eval("select.drop polygon")
for source_polygon in polygon_index_list:
lx.command("select.element", layer=layer, type="polygon", mode="set", index=source_polygon)
lx.eval("select.connect")
return lx.eval("query layerservice polys ? selected")
def debugAxis (matrix, pos=(0,0,0)):
for i in range(len(matrix)):
lx.eval("tool.set prim.tube on")
lx.eval("tool.attr prim.tube sides 4")
lx.eval("tool.attr prim.tube segments 1")
lx.eval("tool.attr prim.tube radius 0.0188")
lx.eval("tool.attr prim.tube caps false")
lx.eval("tool.attr prim.tube mode add")
lx.eval("tool.attr prim.tube number 1")
lx.eval("tool.attr prim.tube ptX " + str(matrix[i][0] + pos[0]))
lx.eval("tool.attr prim.tube ptY " + str(matrix[i][1] + pos[1]))
lx.eval("tool.attr prim.tube ptZ " + str(matrix[i][2] + pos[2]))
lx.eval("tool.attr prim.tube number 2")
lx.eval("tool.attr prim.tube ptX " + str(pos[0]))
lx.eval("tool.attr prim.tube ptY " + str(pos[1]))
lx.eval("tool.attr prim.tube ptZ " + str(pos[2]))
lx.eval("tool.doapply")
lx.eval("select.drop polygon")
poly_count = lx.eval("query layerservice poly.N ? all")
for poly in range(poly_count - 4, poly_count):
lx.command("select.element", layer=layer, type="polygon", mode="add", index=poly)
if i == 0:
lx.eval("poly.setMaterial x {1.0 0.0 0.0} 0.8 0.2 true false")
elif i == 1:
lx.eval("poly.setMaterial y {0.0 1.0 0.0} 0.8 0.2 true false")
else:
lx.eval("poly.setMaterial z {0.0 0.0 1.0} 0.8 0.2 true false")
lx.eval("select.drop polygon")
def getBestAxis(poly_indices,threshold):
planar_poly_set, planar_normals_set, planar_area_set = getPlanarPolys(poly_indices,threshold)
a_axis = 0
b_axis = 0
c_axis = 0
a_axis_index = 0
b_axis_index = 0
best_edge_index = []
largest_area = 0
for x in range(len(planar_area_set)):
if planar_area_set[x] > largest_area:
largest_area = planar_area_set[x]
a_axis_index = x
a_axis = planar_normals_set[a_axis_index]
lx.eval("select.drop edge")
lx.eval("select.drop polygon")
for poly in planar_poly_set[a_axis_index]:
lx.command("select.element", layer=layer, type="polygon", mode="add", index=poly)
lx.eval("select.boundary")
edges = lx.eval("query layerservice edges ? selected")
max_distance = 0
best_edge = ()
for edge in edges:
x, y = numbersp.findall(edge)
x = lx.eval("query layerservice vert.pos ? " + x)
y = lx.eval("query layerservice vert.pos ? " + y)
distance = modomath.vecDistance(x, y)
if distance > max_distance:
max_distance = distance
best_edge = [x, y]
best_edge_index = edge
b_axis = modomath.vecNormalized(modomath.vecSub(best_edge[0],best_edge[1]))
c_axis = modomath.vecCrossProduct(a_axis,b_axis)
return a_axis,b_axis,c_axis
def selectPolygons(poly_index_list, setp=True):
if setp:
lx.eval("select.drop polygon")
if poly_index_list:
for poly in poly_index_list:
lx.command("select.element", layer=layer, type="polygon", mode="add", index=poly)
return True
else:
return False
def setValue(main, vt, u, v):
p = lx.eval("query layerservice vert.polyList ? %s" % vt)
uv = lx.eval("query layerservice uv.pos ? (%s,%s)" % (p[0], vt))
du = u - uv[0]
dv = v - uv[1]
lx.command("select.element",
layer=main,
type="vertex",
mode="set",
index=int(vt))
uvtrans(du, dv)
def getConnectedPolyLists(polygon_index_list):
connected_poly_list = []
while polygon_index_list:
for source_polygon in polygon_index_list:
lx.eval("select.drop polygon")
lx.command("select.element", layer=layer, type="polygon", mode="set", index=source_polygon)
lx.eval("select.connect")
connected_polys = set(lx.eval("query layerservice polys ? selected"))
connected_poly_list.append (list(polygon_index_list.intersection(connected_polys)))
polygon_index_list = polygon_index_list.difference(connected_polys)
break
return list(connected_poly_list)
def createSqure(vid1,vid2,vid3,vid4,lid):
lx.eval("select.type vertex")
lx.eval("select.drop vertex")
selectPoint(vid1,lid)
selectPoint(vid2,lid)
selectPoint(vid3,lid)
selectPoint(vid4,lid)
lx.command("poly.makeFace")
AddRandomColor()
return lx.eval("query layerservice poly.index ? last")
def __init__(self):
self.l = 3141592641
self.u= 72389504171
#### SEE if any polygons are selected, if not, select random plygons based on user input value
if lx.eval("query layerservice polys ? selected") < 1:
RandomSelectPolygons()
if lx.eval("query scriptsysservice userValue.isDefined ? random.X") :
self.x = lx.eval("user.value random.X ?")
else :
lx.command("user.defNew", name = "random.X" , type = "float" , life = "config")
self.x = int(time.time())
self.x = (self.l*self.x+self.u)%1000000000
lx.command("user.value" , name = "random.X" , value=self.x)
def basic_Execute(self, msg, flags):
# We want to use the testkit preset, and revert any potential edits
lx.eval("preset.fbx testkitFBX")
lx.eval("preset.fbx.edit revert {}")
# Get the scene, and all selected meshes
scene = modo.Scene()
meshes = scene.selectedByType('mesh')
scene_dir = os.path.dirname(scene.filename)
# For each mesh, export them right next to scene.
for mesh in meshes:
scene.select(mesh)
filename = os.path.join(scene_dir, mesh.name + ".fbx")
lx.command("scene.saveAs",
filename=filename,
format="fbx",
export=True)
def setweight(wname):
main = lx.eval("query layerservice layers ? main")
lx.eval("select.type vertex")
lx.eval("select.drop vertex")
lx.command("vert.new", x=0 , y=0 , z=0 )
vert = lx.eval("query layerservice vert.index ? last")
lx.eval("select.element %(main)s vertex set %(vert)s" % vars())
lx.eval("poly.makeFace")
lx.eval("select.type vertex")
lx.eval("select.element %(main)s vertex set %(vert)s" % vars())
lx.eval("select.vertexMap \"%(wname)s\" wght replace" % vars())
lx.eval("tool.set vertMap.setWeight on")
lx.eval("tool.setAttr vertMap.setWeight weight [100.0 %]")
lx.eval("tool.doApply")
lx.eval("tool.set vertMap.setWeight off")
wmaps = lx.eval("query layerservice vmaps ? weight")
for w in wmaps :
if lx.eval("query layerservice vmap.selected ? %(w)s" %vars()) : break
v = lx.eval("query layerservice vert.vmapValue ? %(vert)s" % vars() )
if v == None :
lx.command("vertMap.new" , name = vname ,type="wght")
lx.command("delete")
def setweight(wname):
main = lx.eval("query layerservice layers ? main")
lx.eval("select.type vertex")
lx.eval("select.drop vertex")
lx.command("vert.new", x=0, y=0, z=0)
vert = lx.eval("query layerservice vert.index ? last")
lx.eval("select.element %(main)s vertex set %(vert)s" % vars())
lx.eval("poly.makeFace")
lx.eval("select.type vertex")
lx.eval("select.element %(main)s vertex set %(vert)s" % vars())
lx.eval("select.vertexMap \"%(wname)s\" wght replace" % vars())
lx.eval("tool.set vertMap.setWeight on")
lx.eval("tool.setAttr vertMap.setWeight weight [100.0 %]")
lx.eval("tool.doApply")
lx.eval("tool.set vertMap.setWeight off")
wmaps = lx.eval("query layerservice vmaps ? weight")
for w in wmaps:
if lx.eval("query layerservice vmap.selected ? %(w)s" % vars()): break
v = lx.eval("query layerservice vert.vmapValue ? %(vert)s" % vars())
if v == None:
lx.command("vertMap.new", name=vname, type="wght")
lx.command("delete")
folder = lx.eval('item.channel renderOutput$filename ?')
folder = folder[ : folder.rfind("\\") +1]
strFileName = folder + "body_"
# bake the object to render output
for bakePerFrame in range(firstFrame, lastFrame):
fileOutput = strFileName + str(counter).zfill(4)
lx.out(fileOutput)
lx.eval('bake.obj filename:%s format:openexr cage:{} dist:0.0' %fileOutput)
# get all mdd's
for i in range(n):
itemType = lx.eval("query sceneservice item.type ? %s" % i)
if(itemType == "deformMDD2"):
itemID = lx.eval("query sceneservice item.id ? %s" % i)
lx.out("Item ID:",itemID)
lx.command("select.item",item=itemID)
#offset mdd start frame
lx.eval('item.channel deformMDD2$startFrame %s' %counter)
counter+=1
# set the mdd start frame back to 0
for i in range(n):
itemType = lx.eval("query sceneservice item.type ? %s" % i)
if(itemType == "deformMDD2"):
itemID = lx.eval("query sceneservice item.id ? %s" % i)
lx.out("Item ID:",itemID)
lx.command("select.item",item=itemID)
lx.eval('item.channel deformMDD2$startFrame 0')
try:
poly = set(polys).difference(old_polys).pop()
except:
break
poly_verts.append(lx.eval("query layerservice poly.vertlist ? " + str(poly)))
old_polys.append(poly)
if not poly_verts:
break
poly_edges = []
for verts in poly_verts:
for i in range(0,len(verts)-1):
poly_edges.append(tuple(sorted([verts[i],verts[i+1]])))
poly_edges.append(tuple(sorted([verts[len(verts)-1],verts[0]])))
poly_edges = set(poly_edges).difference(edge_index_list)
edge_index_list = list(ring_edge_set.intersection(poly_edges))
edge_list.append(edge_index_list)
ring_edge_set = ring_edge_set.difference(poly_edges)
my_vmap = None
vmaps = lx.eval("query layerservice vmaps ? texture")
for vmap in lx.eval("query layerservice vmaps ? texture"):
if lx.eval("query layerservice vmap.selected ? " + str(vmap)):
my_vmap = vmap
break
for edges in edge_list:
lx.eval("select.drop edge")
for edge in edges:
lx.command("select.element", layer=fg, type="edge", mode="add", index=edge[0], index2=edge[1])
lx.eval("uv.align Left Average")
def selectPoint(vid,lid):
lx.command("select.element",layer=lid,type="vertex",mode="add",index=vid)
def __del__(self):
lx.command("user.value" , name = "random.X" , value=self.x)
def selectCollisionPolys(self):
for poly in self.collision_poly_indices:
lx.command("select.element", layer=layer, type="polygon", mode="add", index=poly)
for vertex in vertex_index_list:
expX = expY = expZ = 0
X, Y, Z = lx.eval("query layerservice vert.wpos ? " + str(vertex))
# lx.out("-------------------------")
# lx.out(str(X) + "," + str(Y) + "," + str(Z))
expX, X = modf(X)
expY, Y = modf(Y)
expZ, Z = modf(Z)
if (grid_exp != 0):
expX = round(expX / grid_exp) * grid_exp
expY = round(expY / grid_exp) * grid_exp
expZ = round(expZ / grid_exp) * grid_exp
else:
expX = expY = expZ = 0
# lx.out(str(expX) + "," + str(expY) + "," + str(expZ))
if (grid_size != 0):
X = (round(X / grid_size) * grid_size)
Y = (round(Y / grid_size) * grid_size)
Z = (round(Z / grid_size) * grid_size)
X = X + expX
Y = Y + expY
Z = Z + expZ
# lx.out(str(X) + "," + str(Y) + "," + str(Z))
lx.command("vert.move", vertIndex=vertex, posX=X, posY=Y, posZ=Z)
m.step(1)
lx.eval("user.value %(var)s" % vars())
return lx.eval("user.value %(var)s ?" % vars())
main = lx.eval("query layerservice layers ? main")
verts = lx.evalN("query layerservice verts ? selected")
if len(verts) >= 2:
pos1 = lx.eval("query layerservice vert.pos ? " + verts[0])
pos2 = lx.eval("query layerservice vert.pos ? " + verts[1])
n = panel("makepointbydivide.n", None, "integer", "How many", None)
if n > 0:
dx = (pos2[0] - pos1[0]) / (n + 1)
dy = (pos2[1] - pos1[1]) / (n + 1)
dz = (pos2[2] - pos1[2]) / (n + 1)
sx = pos1[0] + dx
sy = pos1[1] + dy
sz = pos1[2] + dz
for i in range(n):
lx.command("vert.new", x=sx, y=sy, z=sz)
sx = sx + dx
sy = sy + dy
sz = sz + dz
v = int(lx.eval("query layerservice vert.index ? last"))
for i in range(n):
lx.command("select.element",
layer=main,
type="vertex",
mode="add",
index=v - i)
mon = lx.Monitor()
main = lx.eval("query layerservice layers ? main")
pseledges = lx.evalN("query layerservice edges ? selected")
lx.eval("select.convert vertex")
everts = list(lx.evalN("query layerservice verts ? selected"))
selverts = set(everts * 1)
lx.eval("select.drop edge")
lx.eval("select.drop vertex")
vs = lx.evalN("query layerservice vert.vertList ? %s" % everts[0])
for v in vs:
if str(v) in selverts:
lx.eval("select.type edge")
lx.command("select.element",
layer=main,
type="edge",
mode="set",
index=int(everts[0]),
index2=int(v))
lx.eval("@lineselect.py")
lx.eval("select.convert vertex")
lx.eval("select.type vertex")
loop0 = set(lx.evalN("query layerservice verts ? selected"))
edge1 = selverts.intersection(loop0)
edge2 = selverts.difference(edge1)
break
mon.init(len(edge1))
vseq = []
while len(edge1) != 0:
mon.step(1)
seedv = edge1.pop()
nextv = lx.evalN("query layerservice vert.vertList ? %s" % seedv)
for v in lx.evalN("query layerservice selection ? edge")]
seledge = []
for e in edges:
if int(e[1]) < int(e[2]):
seledge.append("(%s,%s)" % (e[1], e[2]))
else:
seledge.append("(%s,%s)" % (e[2], e[1]))
if len(seledge) != 0:
seededge = seledge[-1]
plist = set(
lx.evalN("query layerservice edge.polyList ? %s" % seededge))
lx.eval("select.drop edge")
vid = seededge.strip("()").split(",")
lx.command("select.element",
layer=main,
type="edge",
mode="set",
index=int(vid[0]),
index2=int(vid[1]))
lx.eval("select.loop")
edges = [(v.strip("()").split(","))
for v in lx.evalN("query layerservice selection ? edge")]
loopedge = set()
for e in edges:
if int(e[1]) < int(e[2]):
loopedge.add("(%s,%s)" % (e[1], e[2]))
else:
loopedge.add("(%s,%s)" % (e[2], e[1]))
result.append(seededge)
seed = seededge.strip("()").split(",")
loopedge.remove(seededge)
v = seed[0]
if useuv == "U":
sel = 0
else:
sel = 1
lx.eval("tool.set vertMap.setWeight on")
main = lx.eval("query layerservice layers ? main")
seluvs = lx.evalN("query layerservice vmaps ? Texture")
for uv in seluvs:
if lx.eval("query layerservice vmap.selected ? %s" % uv): break
if len(seluvs) != 0:
for v in selverts:
mon.step(1)
uvpos = lx.eval("query layerservice uv.pos ? (-1,%(v)s)" % vars())
w = uvpos[sel] * scale + shift
lx.command("select.element",
layer=main,
type="vertex",
mode="set",
index=int(v))
lx.eval("tool.setAttr vertMap.setWeight weight %s" % w)
lx.eval("tool.doApply")
lx.eval("tool.set vertMap.setWeight off")
lx.eval("select.drop vertex")
if not nonselection:
for v in selverts:
lx.command("select.element",
layer=main,
type="vertex",
mode="add",
index=int(v))
posu = vecu * t + vchain[0][0][0]
posv = vecv * t + vchain[0][0][1]
else:
distance = distance + v[2]
t = distance / sum
posu = vecu * t + vchain[0][0][0]
posv = vecv * t + vchain[0][0][1]
vmid = v[1][0][0].strip("()").split(",")
if not isDisco(vmid[1]):
setValue(main, vmid[1], posu, posv)
else:
for vid in v[1][0]:
vmid = vid.strip("()").split(",")
lx.command("select.element",
layer=main,
type="vertex",
mode="set",
index=int(vmid[1]),
index3=int(vmid[0]))
strpos = str(posu) + " " + str(posv)
lx.command("vertMap.setPValue", value=strpos)
vmid = v[1][1][0].strip("()").split(",")
if not isDisco(vmid[1]):
setValue(main, vmid[1], posu, posv)
else:
for vid in v[1][1]:
vmid = vid.strip("()").split(",")
lx.command("select.element",
layer=main,
type="vertex",
mode="set",
index=int(vmid[1]),
if modoversion >= 700:
lx.eval("!!loaderOptions.wf_OBJ false true")
lx.eval("!!scene.open \"" + obj_file.name + "\" import")
lx.eval("select.itemHierarchy " + filename)
lx.eval("select.drop polygon")
lx.eval("select.all")
lx.eval("cut")
lx.eval("select.layer " + str(layer))
lx.eval("select.all")
lx.eval("paste")
lx.eval("select.invert")
collision_polys = set(lx.eval("query layerservice polys ? selected"))
for obj in object_list:
lx.command("select.element",
layer=layer,
type="polygon",
mode="set",
index=collision_polys.pop())
lx.eval("select.connect")
connected_polys = set(lx.eval("query layerservice polys ? selected"))
obj.collision_poly_indices = connected_polys
collision_polys = collision_polys.difference(connected_polys)
lx.eval("select.item " + filename)
if lx.eval("query sceneservice item.numChildren ? " + filename) > 1:
for item in lx.eval("query sceneservice item.children ? " + filename):
lx.eval("select.item " + item)
lx.eval("item.delete")
else:
lx.eval("select.item " +
lx.eval("query sceneservice item.children ? " + filename))
#select the locator
lx.eval('select.itemPattern GRP_%s add' %character )
locator=lx.eval('query sceneservice selection ? locator')
# set destination file and folder
folder = lx.eval('item.channel renderOutput$filename ?')
folder = folder[ : folder.rfind("/") +1]
strFileName = folder + "body_"
# move to the first frame/intialize
lx.eval("time.step frame first")
# bake the object to render output
for bakePerFrame in range(firstFrame, lastFrame):
fileOutput = strFileName + str(counter).zfill(4)
# increment Y rotation on turntable locator
lx.command("select.item",item=locator)
lx.eval('transform.channel rot.Y %s.0' %counterRot)
# lx.out(fileOutput)
lx.eval('bake.obj filename:%s format:openexr cage:{} dist:0.0' %fileOutput)
counterRot+=3
counter+=1
# reset the locator rotation
lx.command("select.item",item=locator)
lx.eval('transform.channel rot.Y 0.0')
layer = lx.eval("query layerservice layers ? main")
selmode = lx.eval("query layerservice selmode ?")
lx.eval("select.convert vertex")
selected_verts = set(lx.evalN("query layerservice verts ? selected"))
if not selected_verts:
lx.eval("select.all")
selected_verts = set(lx.evalN("query layerservice verts ? selected"))
lx.eval("select.drop vertex")
lx.eval("select.edge add bond equal (none)")
lx.eval("select.convert vertex")
open_verts = set(lx.evalN("query layerservice verts ? selected"))
if not open_verts:
lx.eval("select.typeFrom " + selmode)
sys.exit()
lx.eval("select.drop vertex")
target_verts = set.intersection(selected_verts, open_verts)
for vert in target_verts:
lx.command("select.element",
layer=str(layer),
type="vertex",
mode="add",
index=vert)
if threshold:
lx.eval("!!vert.merge fixed false " + threshold +
" morph:false disco:false")
else:
lx.eval("!!vert.merge auto false morph:false disco:false")
lx.eval("select.typeFrom " + selmode)
def flip(pid,lid):
lx.eval("select.type polygon")
lx.command("select.element",layer=lid,type="polygon",mode="set",index=pid)
lx.eval("poly.flip")
def pymain():
args = lx.arg()
arg_split = args.split()
if len(arg_split) == 0:
try:
arg = panel(
"UVBlockAligner.mode", None, "integer", "which mode:",
"U Center;V Center;Left;Right;Top;Bottom;Max Width;Min Width;"
+
"Max Height;Min Height;Horizontal Distribution;Vertical Distribution;"
+ "Horizontal Space;Vertical Space")
except:
return
elif len(arg_split) > 2:
arg = "%s %s" % (arg_split[0], arg_split[1])
else:
arg = args
spc = 0
if "Space" in arg:
if len(arg_split) > 2:
spc = float(arg_split[2])
else:
try:
spc = panel("UVBlockAligner.space", None, "float",
"Space Distance:", None)
except:
return
all = False
main = lx.eval("query layerservice layer.index ? main")
vmaps = set(lx.evalN("query layerservice vmaps ? selected"))
texture = set(lx.evalN("query layerservice vmaps ? texture"))
seltexture = list(vmaps.intersection(texture))
if len(seltexture) == 0:
return texselerror
seltexture = int(seltexture[0])
lx.eval("query layerservice vmap.name ? %s" % seltexture)
lx.eval("select.type polygon")
backup = lx.evalN("query layerservice polys ? selected")
if len(backup) != 0:
lx.eval("select.connect")
selpolys = set(lx.evalN("query layerservice polys ? selected"))
else:
selpolys = set(lx.evalN("query layerservice polys ? all"))
all = True
lx.eval("select.drop polygon")
block = []
while len(selpolys) != 0:
p = list(selpolys)[0]
lx.command("select.element",
layer=main,
type="polygon",
mode="set",
index=int(p))
lx.eval("select.connect")
bps = lx.evalN("query layerservice polys ? selected")
range = None
for p in bps:
verts = lx.evalN("query layerservice poly.vertList ? %s" % p)
for v in verts:
uv = lx.eval("query layerservice uv.pos ? (%s,%s)" % (p, v))
if range == None:
range = [uv[0], uv[1], uv[0], uv[1]]
else:
if range[0] > uv[0]: range[0] = uv[0]
if range[1] > uv[1]: range[1] = uv[1]
if range[2] < uv[0]: range[2] = uv[0]
if range[3] < uv[1]: range[3] = uv[1]
selpolys = selpolys.difference(set(bps))
block.append([range, bps])
if "Horizontal" in arg: block.sort(hcmp)
if "Vertical" in arg: block.sort(vcmp)
cu = 0
cv = 0
minu = None
n = len(block)
for b in block:
r = b[0]
if minu == None:
minu = r[0]
maxu = r[2]
minv = r[1]
maxv = r[3]
sumw = r[2] - r[0]
sumh = r[3] - r[1]
minwu = maxwu = r[2] - r[0]
minwv = maxwv = r[3] - r[1]
else:
if minu > r[0]: minu = r[0]
if maxu < r[2]: maxu = r[2]
if minv > r[1]: minv = r[1]
if maxv < r[3]: maxv = r[3]
wu = r[2] - r[0]
wv = r[3] - r[1]
if minwu > wu: minwu = wu
if minwv > wv: minwv = wv
if maxwu < wu: maxwu = wu
if maxwv < wv: maxwv = wv
sumw = sumw + r[2] - r[0]
sumh = sumh + r[3] - r[1]
cu = cu + (r[0] + r[2]) / 2
cv = cv + (r[1] + r[3]) / 2
cu = cu / n
cv = cv / n
if n > 1:
spw = ((maxu - minu) - sumw) / (n - 1)
sph = ((maxv - minv) - sumh) / (n - 1)
ptu = (maxu + minu) / 2 - (spc * (n - 1) + sumw) / 2
ptv = (maxv + minv) / 2 - (spc * (n - 1) + sumh) / 2
for ptr, b in enumerate(block):
r = b[0]
lx.eval("select.drop polygon")
for p in b[1]:
lx.command("select.element",
layer=main,
type="polygon",
mode="add",
index=int(p))
if arg == "U Center":
uvtrans(cu - (r[0] + r[2]) / 2, 0, 0)
elif arg == "V Center":
uvtrans(0, cv - (r[1] + r[3]) / 2, 0)
elif arg == "Left":
uvtrans(minu - r[0], 0, 0)
elif arg == "Right":
uvtrans(maxu - r[2], 0, 0)
elif arg == "Bottom":
uvtrans(0, minv - r[1], 0)
elif arg == "Top":
uvtrans(0, maxv - r[3], 0)
elif arg == "Min Width":
lx.eval("tool.set actr.auto on 0")
lx.eval("tool.setAttr center.auto cenU %s" % ((r[0] + r[2]) / 2))
lx.eval("tool.setAttr center.auto cenV %s" % ((r[1] + r[3]) / 2))
uvtrans(minwu / (r[2] - r[0]) * 100, 100, 1)
lx.eval("tool.set actr.auto off 0")
elif arg == "Max Width":
lx.eval("tool.set actr.auto on 0")
lx.eval("tool.setAttr center.auto cenU %s" % ((r[0] + r[2]) / 2))
lx.eval("tool.setAttr center.auto cenV %s" % ((r[1] + r[3]) / 2))
uvtrans(maxwu / (r[2] - r[0]) * 100, 100, 1)
lx.eval("tool.set actr.auto off 0")
elif arg == "Min Height":
lx.eval("tool.set actr.auto on 0")
lx.eval("tool.setAttr center.auto cenU %s" % ((r[0] + r[2]) / 2))
lx.eval("tool.setAttr center.auto cenV %s" % ((r[1] + r[3]) / 2))
uvtrans(100, minwv / (r[3] - r[1]) * 100, 1)
lx.eval("tool.set actr.auto off 0")
elif arg == "Max Height":
lx.eval("tool.set actr.auto on 0")
lx.eval("tool.setAttr center.auto cenU %s" % ((r[0] + r[2]) / 2))
lx.eval("tool.setAttr center.auto cenV %s" % ((r[1] + r[3]) / 2))
uvtrans(100, maxwv / (r[3] - r[1]) * 100, 1)
lx.eval("tool.set actr.auto off 0")
elif arg == "Horizontal Distribution":
if ptr == 0:
pu = r[2]
continue
elif ptr == n - 1:
break
pu = pu + spw
uvtrans(pu - r[0], 0, 0)
pu = pu + (r[2] - r[0])
elif arg == "Vertical Distribution":
if ptr == 0:
pv = r[3]
continue
elif ptr == n - 1:
break
pv = pv + sph
uvtrans(0, pv - r[1], 0)
pv = pv + (r[3] - r[1])
elif arg == "Horizontal Space":
uvtrans(ptu - r[0], 0, 0)
ptu = ptu + spc + r[2] - r[0]
elif arg == "Vertical Space":
uvtrans(0, ptv - r[1], 0)
ptv = ptv + spc + r[3] - r[1]
lx.eval("select.drop polygon")
if not all:
for p in backup:
lx.command("select.element",
layer=main,
type="polygon",
mode="add",
index=int(p))
def alignUVToAxis():
fg = lx.eval("query layerservice layers ? main")
edge_index_list = []
poly_index_list = lx.eval("query layerservice polys ? selected")
try:
edge_index_list = [
tuple(sorted(eval(x)))
for x in lx.eval("query layerservice edges ? selected")
]
except:
edge_index_list.append(
tuple(sorted(eval(
lx.eval("query layerservice edges ? selected")))))
lx.eval("select.typeFrom edge;vertex;polygon;item;pivot;center;ptag true")
lx.eval("select.ring")
ring_edges = [
tuple(sorted(eval(x)))
for x in lx.eval("query layerservice edges ? selected")
]
ring_edge_set = set(ring_edges)
lx.eval("select.convert vertex")
vertex_index_list = lx.eval("query layerservice verts ? selected")
edge_list = [edge_index_list]
old_polys = []
while ring_edge_set:
edge_polys = []
for edge in edge_index_list:
edge_polys.append(
lx.eval("query layerservice edge.polylist ? " +
str(edge).replace(' ', '')))
poly_verts = []
if not old_polys:
for poly in edge_polys:
poly_verts.append(
lx.eval("query layerservice poly.vertlist ? " + str(poly)))
old_polys.extend(edge_polys)
else:
for polys in edge_polys:
try:
poly = set(polys).difference(old_polys).pop()
except:
break
poly_verts.append(
lx.eval("query layerservice poly.vertlist ? " + str(poly)))
old_polys.append(poly)
if not poly_verts:
break
poly_edges = []
for verts in poly_verts:
for i in range(0, len(verts) - 1):
poly_edges.append(tuple(sorted([verts[i], verts[i + 1]])))
poly_edges.append(tuple(sorted([verts[len(verts) - 1], verts[0]])))
poly_edges = set(poly_edges).difference(edge_index_list)
edge_index_list = list(ring_edge_set.intersection(poly_edges))
edge_list.append(edge_index_list)
ring_edge_set = ring_edge_set.difference(poly_edges)
my_vmap = None
vmaps = lx.eval("query layerservice vmaps ? texture")
for vmap in lx.eval("query layerservice vmaps ? texture"):
if lx.eval("query layerservice vmap.selected ? " + str(vmap)):
my_vmap = vmap
break
for edges in edge_list:
lx.eval("select.drop edge")
for edge in edges:
lx.command("select.element",
layer=fg,
type="edge",
mode="add",
index=edge[0],
index2=edge[1])
lx.eval("uv.align Left Average")
def selectRenderPolys(self):
for poly in self.render_poly_indices:
lx.command("select.element", layer=layer, type="polygon", mode="add", index=poly)
(p2[2] - p1[2])) / (v2[2] - v1[2] * v2[1] / v1[1])
else:
t = (v1[0] / v1[1] * (p2[1] - p1[1]) -
(p2[0] - p1[0])) / (v2[0] - v1[0] * v2[1] / v1[1])
else:
if abs(v2[0] - v1[0] * v2[2] / v1[2]) < redundancy:
t = (v1[1] / v1[2] * (p2[2] - p1[2]) -
(p2[1] - p1[1])) / (v2[1] - v1[1] * v2[2] / v1[2])
else:
t = (v1[0] / v1[2] * (p2[2] - p1[2]) -
(p2[0] - p1[0])) / (v2[0] - v1[0] * v2[2] / v1[2])
center = [v2[0] * t + p2[0], v2[1] * t + p2[1], v2[2] * t + p2[2]]
for t in range(divide):
th = t * 360.0 / divide * math.pi / 180
R = Rn(normal, th)
v = mulm(R, vector(pos1, center))
lx.command("vert.new",
x=v[0] + center[0],
y=v[1] + center[1],
z=v[2] + center[2])
lx.eval("select.drop vertex")
n = lx.eval("query layerservice vert.N ? all")
for i in range(n - divide, n):
lx.command("select.element",
layer=main,
type="vertex",
mode="add",
index=i)
lx.eval("poly.makeFace")
lx.eval("select.type polygon")
useuv=panel("uv2weight.use",None,"integer","use","U;V")
shift=panel("uv2weight.shift",None,"float","Shift Value",None)
scale=panel("uv2weight.scale",None,"percent","Scale Value",None)
if weightmap in wmapnameset:
setweight(weightmap)
else:
lx.eval("vertMap.new %s wght [0] [0.0 0.0 0.0] [1.0]" % weightmap)
lx.eval("select.vertexMap %s wght replace" % weightmap)
if useuv=="U":
sel=0
else:
sel=1
lx.eval("tool.set vertMap.setWeight on")
main = lx.eval("query layerservice layers ? main")
seluvs=lx.evalN("query layerservice vmaps ? Texture")
for uv in seluvs:
if lx.eval("query layerservice vmap.selected ? %s" % uv) : break
if len(seluvs)!=0:
for v in selverts:
mon.step(1)
uvpos=lx.eval("query layerservice uv.pos ? (-1,%(v)s)" % vars())
w=uvpos[sel]*scale+shift
lx.command("select.element",layer=main,type="vertex",mode="set",index=int(v))
lx.eval("tool.setAttr vertMap.setWeight weight %s" % w)
lx.eval("tool.doApply")
lx.eval("tool.set vertMap.setWeight off")
lx.eval("select.drop vertex")
if not nonselection :
for v in selverts:
lx.command("select.element",layer=main,type="vertex",mode="add",index=int(v))
def createMatGrp():
lx.command('@W:/WG/WTD_Code/trunk/wtd/modo/resources-modo/configs/wtd_shadingTools/pyscripts/createMatGrp.py')
def createPoint(p):
lx.command("vert.new", x=p[0] , y=p[1] , z=p[2])
return lx.eval("query layerservice vert.index ? last")
def exportMatGrp():
lx.command('@W:/WG/WTD_Code/trunk/wtd/modo/resources-modo/configs/wtd_shadingTools/pyscripts/exportShading.py')
tmp_file.write(
"\nviewsettings\n{\n\t\"bSnapToGrid\" \"1\"\n\t\"bShowGrid\" \"1\"\n\t\"bShowLogicalGrid\" \"0\"\n\t\"nGridSpacing\" \"32\"\n\t\"bShow3DGrid\" \"0\"\n}"
)
tmp_file.write(
"\nworld\n{\n\t\"id\" \"1\"\n\t\"mapversion\" \"34\"\n\t\"classname\" \"worldspawn\"\n\t\"detailmaterial\" \"detail/detailsprites\"\n\t\"detailvbsp\" \"detail.vbsp\"\n\t\"maxpropscreenwidth\" \"-1\"\n\t\"musicpostfix\" \"Waterfront\"\n\t\"skyname\" \"sky_l4d_rural02_hdr\"\n\t\"maxblobcount\" \"250\""
)
while polys:
poly = polys[0]
counter += 1
tmp_file.write("\n\tsolid\n\t{")
tmp_file.write("\n\t\t\"id\" \"" + str(counter) + "\"")
lx.command("select.element",
layer=fg,
type="polygon",
mode="set",
index=poly)
normal = lx.eval("query layerservice poly.normal ? " + str(poly))
best_normal = getDominateNormal(normal)
if extrude:
current_distance = distance
if best_normal == "X" and normal[0] > 0:
current_distance = -current_distance
if best_normal == "Y" and normal[1] > 0:
current_distance = -current_distance
if best_normal == "Z" and normal[2] > 0:
current_distance = -current_distance
def pymain():
args = lx.arg()
arg_split = args.split()
if len(arg_split) == 0:
try:
arg=panel("UVBlockAligner.mode",None,"integer","which mode:",
"U Center;V Center;Left;Right;Top;Bottom;Max Width;Min Width;"
+"Max Height;Min Height;Horizontal Distribution;Vertical Distribution;"
+"Horizontal Space;Vertical Space")
except:
return
elif len(arg_split) > 2:
arg = "%s %s" % (arg_split[0], arg_split[1])
else:
arg = args
spc=0
if "Space" in arg:
if len(arg_split) > 2:
spc = float(arg_split[2])
else:
try:
spc=panel("UVBlockAligner.space",None,"float","Space Distance:",None)
except:
return
all=False
main=lx.eval("query layerservice layer.index ? main")
vmaps=set(lx.evalN("query layerservice vmaps ? selected"))
texture=set(lx.evalN("query layerservice vmaps ? texture"))
seltexture=list(vmaps.intersection(texture))
if len(seltexture)==0:
return texselerror
seltexture=int(seltexture[0])
lx.eval("query layerservice vmap.name ? %s" % seltexture)
lx.eval("select.type polygon")
backup=lx.evalN("query layerservice polys ? selected")
if len(backup)!=0:
lx.eval("select.connect")
selpolys=set(lx.evalN("query layerservice polys ? selected"))
else:
selpolys=set(lx.evalN("query layerservice polys ? all"))
all=True
lx.eval("select.drop polygon")
block=[]
while len(selpolys)!=0:
p=list(selpolys)[0]
lx.command("select.element",layer=main,type="polygon",mode="set",index=int(p))
lx.eval("select.connect")
bps=lx.evalN("query layerservice polys ? selected")
range=None
for p in bps:
verts=lx.evalN("query layerservice poly.vertList ? %s" % p)
for v in verts:
uv=lx.eval("query layerservice uv.pos ? (%s,%s)" % (p,v))
if range==None:
range=[uv[0],uv[1],uv[0],uv[1]]
else:
if range[0]>uv[0]:range[0]=uv[0]
if range[1]>uv[1]:range[1]=uv[1]
if range[2]<uv[0]:range[2]=uv[0]
if range[3]<uv[1]:range[3]=uv[1]
selpolys=selpolys.difference(set(bps))
block.append([range,bps])
if "Horizontal" in arg:block.sort(hcmp)
if "Vertical" in arg:block.sort(vcmp)
cu=0
cv=0
minu=None
n=len(block)
for b in block:
r=b[0]
if minu==None:
minu=r[0]
maxu=r[2]
minv=r[1]
maxv=r[3]
sumw=r[2]-r[0]
sumh=r[3]-r[1]
minwu=maxwu=r[2]-r[0]
minwv=maxwv=r[3]-r[1]
else:
if minu>r[0]:minu=r[0]
if maxu<r[2]:maxu=r[2]
if minv>r[1]:minv=r[1]
if maxv<r[3]:maxv=r[3]
wu=r[2]-r[0]
wv=r[3]-r[1]
if minwu>wu:minwu=wu
if minwv>wv:minwv=wv
if maxwu<wu:maxwu=wu
if maxwv<wv:maxwv=wv
sumw=sumw+r[2]-r[0]
sumh=sumh+r[3]-r[1]
cu=cu+(r[0]+r[2])/2
cv=cv+(r[1]+r[3])/2
cu=cu/n
cv=cv/n
if n>1:
spw=((maxu-minu)-sumw)/(n-1)
sph=((maxv-minv)-sumh)/(n-1)
ptu=(maxu+minu)/2-(spc*(n-1)+sumw)/2
ptv=(maxv+minv)/2-(spc*(n-1)+sumh)/2
for ptr,b in enumerate(block):
r=b[0]
lx.eval("select.drop polygon")
for p in b[1]:
lx.command("select.element",layer=main,type="polygon",mode="add",index=int(p))
if arg=="U Center":
uvtrans(cu-(r[0]+r[2])/2,0,0)
elif arg=="V Center":
uvtrans(0,cv-(r[1]+r[3])/2,0)
elif arg=="Left":
uvtrans(minu-r[0],0,0)
elif arg=="Right":
uvtrans(maxu-r[2],0,0)
elif arg=="Bottom":
uvtrans(0,minv-r[1],0)
elif arg=="Top":
uvtrans(0,maxv-r[3],0)
elif arg=="Min Width":
lx.eval("tool.set actr.auto on 0")
lx.eval("tool.setAttr center.auto cenU %s" % ((r[0]+r[2])/2))
lx.eval("tool.setAttr center.auto cenV %s" % ((r[1]+r[3])/2))
uvtrans(minwu/(r[2]-r[0])*100,100,1)
lx.eval("tool.set actr.auto off 0")
elif arg=="Max Width":
lx.eval("tool.set actr.auto on 0")
lx.eval("tool.setAttr center.auto cenU %s" % ((r[0]+r[2])/2))
lx.eval("tool.setAttr center.auto cenV %s" % ((r[1]+r[3])/2))
uvtrans(maxwu/(r[2]-r[0])*100,100,1)
lx.eval("tool.set actr.auto off 0")
elif arg=="Min Height":
lx.eval("tool.set actr.auto on 0")
lx.eval("tool.setAttr center.auto cenU %s" % ((r[0]+r[2])/2))
lx.eval("tool.setAttr center.auto cenV %s" % ((r[1]+r[3])/2))
uvtrans(100,minwv/(r[3]-r[1])*100,1)
lx.eval("tool.set actr.auto off 0")
elif arg=="Max Height":
lx.eval("tool.set actr.auto on 0")
lx.eval("tool.setAttr center.auto cenU %s" % ((r[0]+r[2])/2))
lx.eval("tool.setAttr center.auto cenV %s" % ((r[1]+r[3])/2))
uvtrans(100,maxwv/(r[3]-r[1])*100,1)
lx.eval("tool.set actr.auto off 0")
elif arg=="Horizontal Distribution":
if ptr==0:
pu=r[2]
continue
elif ptr==n-1:break
pu=pu+spw
uvtrans(pu-r[0],0,0)
pu=pu+(r[2]-r[0])
elif arg=="Vertical Distribution":
if ptr==0:
pv=r[3]
continue
elif ptr==n-1:break
pv=pv+sph
uvtrans(0,pv-r[1],0)
pv=pv+(r[3]-r[1])
elif arg=="Horizontal Space":
uvtrans(ptu-r[0],0,0)
ptu=ptu+spc+r[2]-r[0]
elif arg=="Vertical Space":
uvtrans(0,ptv-r[1],0)
ptv=ptv+spc+r[3]-r[1]
lx.eval("select.drop polygon")
if not all:
for p in backup:
lx.command("select.element",layer=main,type="polygon",mode="add",index=int(p))
lx.eval("query layerservice layers ? fg")
try:
poly_index_list = set(lx.eval("query layerservice polys ? selected"))
except:
try:
poly_index_list = set(lx.eval("query layerservice polys ? all"))
except:
error("Bad selection", "No geometry in selected layer")
sys.exit("LXe_ABORT")
for poly in poly_index_list:
parts_list = parts_list | set(
[lx.eval("query layerservice poly.part ? " + str(poly))])
parts_list = parts_list - set([None, "Default", ""])
for part in parts_list:
lx.command("select.layer", number=fg, mode=set)
lx.eval("select.drop polygon")
lx.eval("select.polygon add part face " + str(part))
lx.eval("cut")
if part not in layers_list:
lx.out(part)
lx.command("item.create", type="mesh", name=str(part))
new_layer_index = lx.eval("query layerservice layer.index ? fg")
new_layer_id = lx.eval("query layerservice layer.id ? " +
str(new_layer_index))
lx.eval("item.parent " + new_layer_id + " " + str(parent) +
" inPlace:1")
num_layers += 1
layers_list = []
for i in range(1, num_layers):
layers_list.append(
distance = distance + v[3]
t = distance / uvsum
posu = vecu * t + vchain[0][0][0]
posv = vecv * t + vchain[0][0][1]
else:
distance = distance + v[2]
t = distance / sum
posu = vecu * t + vchain[0][0][0]
posv = vecv * t + vchain[0][0][1]
vmid=v[1][0][0].strip("()").split(",")
if not isDisco(vmid[1]) :
setValue(main,vmid[1],posu,posv)
else:
for vid in v[1][0] :
vmid=vid.strip("()").split(",")
lx.command("select.element",layer=main,type="vertex",mode="set",index=int(vmid[1]),index3=int(vmid[0]))
strpos = str(posu) + " " + str(posv)
lx.command("vertMap.setPValue",value = strpos)
vmid=v[1][1][0].strip("()").split(",")
if not isDisco(vmid[1]) :
setValue(main,vmid[1],posu,posv)
else:
for vid in v[1][1] :
vmid=vid.strip("()").split(",")
lx.command("select.element",layer=main,type="vertex",mode="set",index=int(vmid[1]),index3=int(vmid[0]))
lx.command("vertMap.setPValue",value = strpos)
lx.eval("select.type %(mode)s" % vars())
if mode == "vertex" :
if verts != None :
for v in verts :
vmid=v.strip("()").split(",")
