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(",")