def buildHierarchy_itemTags(item_name):
	item_tags = []
	temp = lx.evalN('query sceneservice item.tagTypes ? {%s} ' % item_name)
	for i in temp:
		item_tags.append(i)
	item_tagValues = []
	temp = []
	temp = lx.evalN('query sceneservice item.tags ? {%s} ' % item_name)
	for i in temp:
		item_tagValues.append(i)
	return (item_tags, item_tagValues)
    def retrieve_args(self):
        '''
        Retrieves a list of arguments and datatypes from modo's commandservice.
        See http://sdk.luxology.com/wiki/Commandservice#command.argNames

        Args:
            None

        Returns:
            None
        '''
        if not self.command:
            raise Exception("Command string not set.")

        # Names of the arguments for the current command.
        argNames = lx.evalN("query commandservice command.argNames ? {%s}" %
                            self.command)

        # No arguments to add
        if not argNames:
            return

        # Populate the list.
        for n in range(len(argNames)):
            self.args.append(
                MacroCommandArg(parent=self,
                                arg_index=n,
                                controller=self._controller))
def vmunselect():
    vmaps=lx.evalN("query layerservice vmaps ? selected")
    ctd={"weight":"wght","texture":"txuv","subvweight":"subd","morph":"morf","absmorpf":"spot","rgb":"rgb","rgba":"rgba","pick":"pick"}
    for vm in vmaps:
        name=lx.eval("query layerservice vmap.name ? %s" % vm)
        type=ctd[lx.eval("query layerservice vmap.type ? %s" % vm)]
        lx.eval("select.vertexMap \"%s\" %s remove" % (name,type))
def main():
    global osType
    global unix_path
    global win_path
    global save_selection

    lx.trace(False)

    osType = platform.system()
    lx.out("TYPE OS: " + osType)

    unix_path = "/Volumes/ProjectsRaid/WorkingProjects"
    win_path = "Z:\AzureSync\CloudComputing\WorkingProjects"

    save_selection = lx.evalN("query sceneservice selection ? all")

    renderoutputs = bd_utils.get_ids("renderOutput")

    if renderoutputs:
        for x in renderoutputs:
            update_render_output(x)

        bd_utils.restoreSelection(save_selection)
    else:
        bd_utils.restoreSelection(save_selection)
Exemple #5
0
def checkMaskInRom(maskID):
    romMaskExists = None
    romChildrenAll = lx.evalN("query sceneservice mask.children ? {ROM}")
    romChildren = []
    for child in romChildrenAll:
        if lx.eval("query sceneservice item.type ? {%s}" % child) == "mask":
            romChildren.append(child)
    lx.eval("select.item %s set" % maskID)
    maskItemSel = lx.eval("mask.setMesh ?")
    if maskItemSel == "(all)":
        for romChild in romChildren:
            lx.out("---")
            lx.eval("select.item %s" % romChild)
            romChildSel = lx.eval("mask.setMesh ?")
            if romChildSel == "(all)":
                romChildName = lx.eval("item.name ?")
                lx.out(romChildName.split(" ")[0])
                lx.eval("select.item %s" % maskID)
                maskName = lx.eval("item.name ?")
                lx.out(maskName.split(" ")[0])
                if romChildName.split(" ")[0] == maskName.split(" ")[0]:
                    romMaskExists = romChild
    else:
        for romChild in romChildren:
            lx.out("---")
            lx.eval("select.item %s" % romChild)
            romChildSel = lx.eval("mask.setMesh ?")
            if romChildSel == maskItemSel:
                lx.out(romChildSel)
                lx.out(maskItemSel)
                romMaskExists = romChild
    return romMaskExists
def writeCamera(name, plist):
    camera_entry = [name]
    camera_entry.append(lx.eval("query sceneservice item.pos ? " + name))
    camera_entry.append([
        math.degrees(x)
        for x in lx.eval("query sceneservice item.rot ? " + name)
    ])

    fov = "35"
    near_p = "500"
    far_p = "10000"

    for i in range(lx.eval("query sceneservice channel.N ?")):
        channel_name = lx.eval("query sceneservice channel.name ? " + str(i))
        channel_value = lx.eval("query sceneservice channel.value ? " + str(i))
        spline_name = ""

        if channel_name == 'spline':
            spline_name = channel_value
        elif channel_name == 'FOV':
            fov = channel_value
        elif channel_name == 'NearP':
            near_p = channel_value
        elif channel_name == 'FarP':
            far_p = channel_value

    if spline_name:
        for i in lx.evalN("query layerservice layers ? all"):
            if spline_name == lx.eval("query layerservice layer.name ? " +
                                      str(i)):
                spline_entry = [spline_name]
                for poly in lx.evalN("query layerservice polys ? all"):
                    if lx.eval("query layerservice poly.type ? " +
                               str(poly)) == 'curve':
                        for vert in lx.evalN(
                                "query layerservice poly.vertList ? " +
                                str(poly)):
                            spline_entry.append(
                                lx.eval("query layerservice vert.pos ? " +
                                        str(vert)))
        if spline_entry:
            plist['Splines'].append(spline_entry)

    camera_entry.append([fov, near_p, far_p])
    camera_entry.append(spline_name)
    plist['Cameras'].append(camera_entry)
Exemple #7
0
def checkRoInGroup(maskID, roType):
    roExists = None
    grpChildrenAll = lx.evalN("query sceneservice mask.children ? %s" % maskID)
    grpChildren = []
    for grpChild in grpChildrenAll:
        if lx.eval("query sceneservice item.type ? {%s}" % grpChild) == "renderOutput":
            lx.eval("select.item %s set" % grpChild)
            roEffect = lx.eval("shader.setEffect ?")
            if roEffect == roType:
                roExists = grpChild
    return roExists
def main():
	meshIDs = lx.evalN('query sceneservice selection ? mesh')
	if (len(meshIDs) == 0):
		lx.out('At least one mesh must be selected to create links')
		sys.exit()
	targetFile = customfile('fileOpen', 'Load Target file', 'fst', 'FST', '*.fst', None)
	if (targetFile != None):
		parseTarget(targetFile)
	else:
		sys.exit()
	for meshID in meshIDs:
		linkMorphs(meshID)
def main():
    global outputs

    outputs = []
    allnames = []
    selection = lx.evalN('query sceneservice selection ? mask')
    try:
        if len(selection) == 0:
            lx.out('No Groups selected!')
        else:
            for id in selection:
                name = lx.eval('query sceneservice mask.name ? %s' % id)
                children = lx.evalN('query sceneservice mask.children ? %s' % id)
                childrenstring = ''.join(children)
                if "renderOutput" in childrenstring:
                    lx.eval('layout.createOrClose EventLog "Event Log_layout" '
                            'title:@macros.layouts@EventLog@ width:600 height:600 '
                            'persistent:true '
                            'open:true')
                    lx.out('"%s" already has one or more RenderOutputs!' % name)
                    allnames.append(name)
                else:
                    lx.out('Adding Alpha output to "%s"' % name)
                    addmask(id, name, "shade.alpha")
                    lx.out('Adding Diffuse Color output to "%s"' % name)
                    addmask(id, name, "mat.diffCol")

            # select new render outputs at the end
            selectnew()
            lx.out('Success!')

            if len(allnames) is not 0:
                lx.out('Some layers already had one or more RenderOutputs:')
                lx.out(allnames)
    except:
        lx.eval('layout.createOrClose EventLog "Event Log_layout" '
                'title:@macros.layouts@EventLog@ width:600 height:600 persistent:true '
                'open:true')
        lx.out("ERROR failed with ", sys.exc_info())
def main():
    meshIDs = lx.evalN('query sceneservice selection ? mesh')
    if (len(meshIDs) == 0):
        lx.out('At least one mesh must be selected to create links')
        sys.exit()
    targetFile = customfile('fileOpen', 'Load Target file', 'fst', 'FST',
                            '*.fst', None)
    if (targetFile != None):
        parseTarget(targetFile)
    else:
        sys.exit()
    for meshID in meshIDs:
        linkMorphs(meshID)
def nextedge(v, plist, loopedge):
    find = False
    for e in list(loopedge):
        vid = e.strip("()").split(",")
        if str(v) in vid:
            find = True
            break
    if not find: return None
    loopedge.remove(e)
    p = set(lx.evalN("query layerservice edge.polyList ? %s" % e))
    if len(p.intersection(plist)) != 0:
        return None
    else:
        return e
def load_files():
    """
    Load in files and save complete paths in a list
    """
    try:
        lx.eval("dialog.setup fileOpenMulti")
        lx.eval("dialog.title {Import MARI textures}")
        lx.eval("dialog.result ok")
        lx.eval("dialog.open")
        
        return lx.evalN("dialog.result ?")
    
    except RuntimeError:
        return False
Exemple #13
0
def peeler(edge_list):
    mainlayer = lx.eval("query layerservice layers ? main")
    for edges in edge_list:
        polys = lx.evalN("query layerservice edge.polyList ? " + str(edges[0][0]) + "," + str(edges[0][1]))
        lx.eval("select.type polygon")
        lx.eval("select.element " + str(mainlayer) + " polygon set " + str(polys[0]))
        lx.eval("select.connect")
        lx.eval("uv.delete")
        lx.eval("select.drop edge")
    for edge in edges:
        lx.eval("select.element " + str(mainlayer) + " edge add " + str(edge[0]) + " " + str(edge[1]))
    lx.eval("tool.set uv.peeler on")
    lx.eval("tool.reset")
    lx.eval("tool.doApply")
    lx.eval("tool.set uv.peeler off")
Exemple #14
0
def vmunselect():
    vmaps = lx.evalN("query layerservice vmaps ? selected")
    ctd = {
        "weight": "wght",
        "texture": "txuv",
        "subvweight": "subd",
        "morph": "morf",
        "absmorpf": "spot",
        "rgb": "rgb",
        "rgba": "rgba",
        "pick": "pick"
    }
    for vm in vmaps:
        name = lx.eval("query layerservice vmap.name ? %s" % vm)
        type = ctd[lx.eval("query layerservice vmap.type ? %s" % vm)]
        lx.eval("select.vertexMap \"%s\" %s remove" % (name, type))
Exemple #15
0
def edgelist(edges, verts):
    edlist = []
    for e in edges:
        length = lx.eval("query layerservice edge.length ? %(e)s" % vars())
        vmid = e.strip("()").split(",")
        polys = lx.evalN("query layerservice edge.polylist ? %(e)s" % vars())
        vid1 = "(%s,%s)" % (polys[0], vmid[0])
        cvid1 = "(-1,%s)" % vmid[0]
        vid2 = "(%s,%s)" % (polys[0], vmid[1])
        cvid2 = "(-1,%s)" % vmid[1]
        pos1 = None
        if (vid1 in verts or cvid1 in verts) and (vid2 in verts
                                                  or cvid2 in verts):
            pos1 = lx.eval("query layerservice uv.pos ? %(vid1)s" % vars())
            pos2 = lx.eval("query layerservice uv.pos ? %(vid2)s" % vars())
        if len(polys) == 2:
            vid3 = "(%s,%s)" % (polys[1], vmid[0])
            cvid3 = "(-1,%s)" % vmid[0]
            vid4 = "(%s,%s)" % (polys[1], vmid[1])
            cvid4 = "(-1,%s)" % vmid[1]
            if (vid3 in verts or cvid3 in verts) and (vid4 in verts
                                                      or cvid4 in verts):
                pos3 = lx.eval("query layerservice uv.pos ? %(vid3)s" % vars())
                pos4 = lx.eval("query layerservice uv.pos ? %(vid4)s" % vars())
                if pos1 == None:
                    edlist.append([[[vid3], [vid4]], [pos3, pos4], length,
                                   uvlength(pos3, pos4)])
                else:
                    if issame(pos1, pos3) and issame(pos2, pos4):
                        edlist.append([[[vid1, vid3], [vid2, vid4]],
                                       [pos1, pos2], length,
                                       uvlength(pos1, pos2)])
                    else:
                        edlist.append([[[vid1], [vid2]], [pos1, pos2], length,
                                       uvlength(pos1, pos2)])
                        edlist.append([[[vid3], [vid4]], [pos3, pos4], length,
                                       uvlength(pos3, pos4)])
            else:
                if pos1 != None:
                    edlist.append([[[vid1], [vid2]], [pos1, pos2], length,
                                   uvlength(pos1, pos2)])
        else:
            if pos1 != None:
                edlist.append([[[vid1], [vid2]], [pos1, pos2], length,
                               uvlength(pos1, pos2)])
    return edlist
def main():
    save_selection = lx.evalN("query sceneservice selection ? all")

    filename = lx.eval("item.channel renderOutput$filename ?")

    path = filename.rsplit(os.sep, 1)

    lx.out("Opening path: " + path[0])

    try:
        subprocess.Popen(['open', path[0]])
    except:
        lx.eval('layout.createOrClose EventLog "Event Log_layout" '
                'title:@macros.layouts@EventLog@ width:600 height:600 persistent:true '
                'open:true')
        lx.out("ERROR Opening Render Output path failed with ", sys.exc_info())

    bd_utils.restoreSelection(save_selection)
def main():
    save_selection = lx.evalN("query sceneservice selection ? all")

    groups = pyModo.Group_Name_All()
    passes = False

    pyModo.Render_Count_All()

    for group in groups:

        if group == "passes":
            passes = True

    if passes:
        lx.out("Setting up proper Output Pattern: '[<pass>]_[<output>][<LR>].<FFFF>'")
        lx.eval("select.Item Render")
        lx.eval('item.channel outPat "[<pass>]_[<output>][<LR>].<FFFF>"')
    else:
        lx.out("Setting up proper Output Pattern: '[<pass>][<output>][<LR>].<FFFF>'")
        lx.eval("select.Item Render")
        lx.eval('item.channel outPat "[<pass>][<output>][<LR>].<FFFF>"')

    bd_utils.restoreSelection(save_selection)
def main():

    save_selection = lx.evalN("query sceneservice selection ? all")

    filepath = bd_utils.filePath()
    filename = os.path.splitext(bd_utils.fileName())
    fileextension = filename[1]

    filename = filename[0]
    filename = filename.rsplit("_", 1)
    version = filename[1]
    filename = filename[0]
    lx.out('Current file "' + filename + '" is at Version ' + version + '.')

    version = version.lstrip("_v")

    created = False

    while created is False:
        version = str(int(version) + 1).zfill(2)
        newfile = filepath + os.sep + filename + "_v" + version + fileextension
        if os.path.isfile(newfile):
            lx.out("Version " + version + " already exists. Increasing version count.")
            pass
        else:
            lx.out("Saving as Version " + version)
            try:
                lx.eval('scene.saveAs {%s}' % newfile)
            except:
                lx.eval('layout.createOrClose EventLog "Event Log_layout" '
                        'title:@macros.layouts@EventLog@ width:600 height:600 persistent:true '
                        'open:true')
                lx.out("ERROR Scene save failed with ", sys.exc_info())

            created = True

    bd_utils.restoreSelection(save_selection)
def edgelist(edges,verts) :
	edlist = []
	for e in edges :
		length = lx.eval("query layerservice edge.length ? %(e)s" % vars())
		vmid=e.strip("()").split(",")
		polys = lx.evalN("query layerservice edge.polylist ? %(e)s" % vars())
		vid1 = "(%s,%s)" %(polys[0],vmid[0])
		cvid1 = "(-1,%s)" % vmid[0]
		vid2 = "(%s,%s)" %(polys[0],vmid[1])
		cvid2 = "(-1,%s)" % vmid[1]
		pos1 = None
		if (vid1 in verts or cvid1 in verts) and (vid2 in verts or cvid2 in verts):
			pos1 = lx.eval("query layerservice uv.pos ? %(vid1)s" % vars())
			pos2 = lx.eval("query layerservice uv.pos ? %(vid2)s" % vars())
		if len(polys)==2 :
			vid3 = "(%s,%s)" %(polys[1],vmid[0])
			cvid3 = "(-1,%s)" % vmid[0]
			vid4 = "(%s,%s)" %(polys[1],vmid[1])
			cvid4 = "(-1,%s)" % vmid[1]
			if (vid3 in verts or cvid3 in verts) and (vid4 in verts or cvid4 in verts):
				pos3 = lx.eval("query layerservice uv.pos ? %(vid3)s" % vars())
				pos4 = lx.eval("query layerservice uv.pos ? %(vid4)s" % vars())
				if pos1 == None :
					edlist.append([[[vid3],[vid4]],[pos3,pos4],length,uvlength(pos3,pos4)])
				else :
					if issame(pos1,pos3) and issame(pos2,pos4) :
						edlist.append([[[vid1,vid3],[vid2,vid4]],[pos1,pos2],length,uvlength(pos1,pos2)])
					else:
						edlist.append([[[vid1],[vid2]],[pos1,pos2],length,uvlength(pos1,pos2)])
						edlist.append([[[vid3],[vid4]],[pos3,pos4],length,uvlength(pos3,pos4)])
			else:
				if pos1 != None :
					edlist.append([[[vid1],[vid2]],[pos1,pos2],length,uvlength(pos1,pos2)])
		else :
			if pos1 != None :
				edlist.append([[[vid1],[vid2]],[pos1,pos2],length,uvlength(pos1,pos2)])
	return edlist
def panel(var,val,type,mes,lst):
	if lx.eval("query scriptsysservice userValue.isDefined ? %(var)s" % vars()) == 0 :
		lx.eval("user.defNew %(var)s %(type)s temporary" % vars())
	if val!=None :
		lx.eval("user.value %(var)s %(val)s" % vars())
	if mes != None :
		lx.eval("user.def %(var)s username \"%(mes)s\"" % vars())
	if lst!=None :
		lx.eval("user.def %(var)s list %(lst)s" % vars())
	if mes != None :
		lx.eval("user.value %(var)s" % vars())
	return lx.eval("user.value %(var)s ?" % vars())

mon=lx.Monitor()
main=lx.eval("query layerservice layers ? main")
vmaps = lx.evalN("query layerservice vmaps ? weight")
wmapnameset=set()
for w in vmaps :
	wname = lx.eval("query layerservice vmap.name ? %(w)s" % vars())
	wmapnameset.add(wname)
lx.eval("select.type vertex")
selverts=lx.evalN("query layerservice verts ? selected")
nonselection=False
if len(selverts)==0:
	nonselection=True
	selverts=lx.evalN("query layerservice verts ? all")
mon.init(len(selverts))
weightmap=panel("uv2weight.weight",None,"string","WeightMap",None)
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)
Exemple #21
0
               vars()) == 0:
        lx.eval("user.defNew %(var)s %(type)s temporary" % vars())
    if val != None:
        lx.eval("user.value %(var)s %(val)s" % vars())
    if mes != None:
        lx.eval("user.def %(var)s username \"%(mes)s\"" % vars())
    if lst != None:
        lx.eval("user.def %(var)s list %(lst)s" % vars())
    if mes != None:
        lx.eval("user.value %(var)s" % vars())
    return lx.eval("user.value %(var)s ?" % vars())


mon = lx.Monitor()
main = lx.eval("query layerservice layers ? main")
vmaps = lx.evalN("query layerservice vmaps ? weight")
wmapnameset = set()
for w in vmaps:
    wname = lx.eval("query layerservice vmap.name ? %(w)s" % vars())
    wmapnameset.add(wname)
lx.eval("select.type vertex")
selverts = lx.evalN("query layerservice verts ? selected")
nonselection = False
if len(selverts) == 0:
    nonselection = True
    selverts = lx.evalN("query layerservice verts ? all")
mon.init(len(selverts))
weightmap = panel("uv2weight.weight", None, "string", "WeightMap", None)
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)
Exemple #22
0
    def retreive_arg_meta(self):
        '''
        Retrieve a list of arguments and datatypes from modo's commandservice.
        See http://sdk.luxology.com/wiki/Commandservice#command.argNames

        Args:
            None

        Returns:
            None

        Example:
            [
                {
                    'argName': 'argname',
                    'argUsername': '******',
                    'argType': 0, # 0 for generic objects, 1 for integers, 2 for floats an 3 for strings
                    'argTypeName': 'boolean',
                    'argDesc': 'What the argument does.',
                    'argExample': 'Example if available.'
                    'argValue': 'Value of the argument.'
                }
            ]
        '''
        base_command = self.parent.command
        arg_index = self._arg_index

        if not base_command:
            raise Exception("Invalid parent command.")
            return

        # Names of the arguments for the current command.
        if not lx.evalN(
                "query commandservice command.argNames ? {%s}" % base_command):
            raise Exception(
                "Parent command has no args. Why do I exist? (Big Questions In Life)"
            )
            return

        # Unlike other metadata, we store these two directly inside the value objects for the columns.
        values_list = lx.evalN("query commandservice command.argNames ? {%s}" %
                               base_command)
        self.argName = values_list[arg_index]

        values_list = lx.evalN(
            "query commandservice command.argUsernames ? {%s}" % base_command)
        self.argUsername = "******" % (values_list[arg_index],
                                                    self.argName)

        # These are the ones I care about for now. If there are others later, we can add them.
        query_terms = ['argTypes', 'argTypeNames', 'argDescs', 'argExamples']

        # The list of query_terms is arbitrary. I'm just grabbing everything I think is important.
        for term in query_terms:
            # Remove the last character from the term to make it singular (argNames becomes argName)
            property_name = term[:-1]
            # Get the full list of values (for all args)
            # Note the use of `lx.evalN` as opposed to the normal `lx.eval`. We need to be certain
            # that we always receive a list in response, even if the list length is 1.
            values_list = lx.evalN('query commandservice command.%s ? {%s}' %
                                   (term, base_command))
            # Run the query.
            setattr(self, property_name, values_list[arg_index])
		cnt = cnt + 1
	return vchain

def vmunselect():
    vmaps=lx.evalN("query layerservice vmaps ? selected")
    ctd={"weight":"wght","texture":"txuv","subvweight":"subd","morph":"morf","absmorpf":"spot","rgb":"rgb","rgba":"rgba","pick":"pick"}
    for vm in vmaps:
        name=lx.eval("query layerservice vmap.name ? %s" % vm)
        type=ctd[lx.eval("query layerservice vmap.type ? %s" % vm)]
        lx.eval("select.vertexMap \"%s\" %s remove" % (name,type))

mode = whichmode()
edges = verts = None
main = lx.eval("query layerservice layers ? main")
if mode == "edge" :
	edges = lx.evalN("query layerservice edges ? selected")
	lx.eval("select.convert vertex")
	verts = lx.evalN("query layerservice uvs ? selected")
elif mode == "vertex" :
	verts = lx.evalN("query layerservice uvs ? selected")
	lx.eval("select.convert edge")
	edges = lx.evalN("query layerservice edges ? selected")
if edges != None :
	if lx.eval("query scriptsysservice userValue.isDefined ? uvaligner.divide") == 0 :
		lx.eval("user.defNew uvaligner.divide integer temporary")
	lx.eval("user.def uvaligner.divide username \"divide method\"")
	lx.eval("user.def uvaligner.divide list Uniform;Proportional;UVProportional")
	lx.eval("user.value uvaligner.divide")
	divide = lx.eval("user.value uvaligner.divide ?")
	selverts = optimize(verts)
	elist = edgelist(edges,selverts)
def getRenderOuptut():
    """ Get a list of item IDs of type 'type'
        Returns a list of item IDs or None if there are no items of the specified
        tyep or if there's an error. Error printed is to Event log.
        type - the type of item to be returned (mesh, camera etc)
    """
    global updateOnly
    global groupSelected
    global updateExistingOnly
    updateOnly = False
    try:
        """
        #Si on fait seulement la mise a jour on recuoere tous les render existant ou ceux que lon a selectionner
        if (updateExistingOnly):
            RenderOutputsSelected = lx.evalN('query sceneservice selection ? renderOutput')
            RenderOutputs = []

            if RenderOutputsSelected:
                for layer in RenderOutputsSelected:
                    lx.out("UPDADE ONLY ",layer)
                    RenderOutputs.append(lx.eval('query sceneservice item.ID ? %s' % layer))
                return RenderOutputs
            # si on a rien selectionner on met a jour tous les éléments
            else:
            
                itemlist = []
                numitems = lx.eval('!!query sceneservice renderOutput.N ?')
                if numitems == 0:
                    return None
                else:
                    for x in xrange(numitems):
                    #typeLayer = lx.eval( "query sceneservice item.type ? %s" %(x) )
                    #if( typeLayer == "renderOutput" ) :
                        idRender = lx.eval('query sceneservice renderOutput.ID ? %s' % (x))
                        itemlist.append(idRender)
                    return itemlist
"""

        #Est ce qu'on a selectionner des render Ouput
        RenderOutputsSelected = lx.evalN(
            'query sceneservice selection ? renderOutput')
        RenderOutputs = []

        if RenderOutputsSelected:
            for layer in RenderOutputsSelected:
                lx.out(layer)
                lx.out("le parent:" +
                       lx.eval('query sceneservice item.parent ? %s' % layer))
                RenderOutputs.append(
                    lx.eval('query sceneservice item.ID ? %s' % layer))
            updateOnly = True
            return RenderOutputs

        #Est ce qu'une selection de group exist ?
        selectionMask = lx.evalN('query sceneservice selection ? mask')
        masks = []

        if selectionMask:
            layer = selectionMask[0]
            lx.out(layer)
            groupSelected = layer  #lx.eval('query sceneservice item.name ? %s' % layer)
            nameGroup = lx.eval(
                'query sceneservice item.name ? %s' % layer) + "_"
            nameGroup = nameGroup.replace(" (Material)", "")
            nameGroup = nameGroup.replace(" (Item)", "")

            lx.eval('user.value rom_prefixName %s' % (nameGroup))
            #Has child output
            childRender = lx.evalN('query sceneservice item.children ? %s' %
                                   layer)
            lx.out(childRender)
            return childRender

        #Est ce qu'une selection de Render principal ?
        selectionMask = lx.evalN('query sceneservice selection ? polyRender')
        masks = []

        if selectionMask:
            layer = selectionMask[0]
            lx.out(layer)
            groupSelected = layer  #lx.eval('query sceneservice item.name ? %s' % layer)
            #Has child output
            childRender = lx.evalN('query sceneservice item.children ? %s' %
                                   layer)
            lx.out(childRender)
            return childRender

        # On peut cree seulement en selectionnant le poly render, un render output ou un mask
        itemlist = []
        numitems = lx.eval('!!query sceneservice renderOutput.N ?')
        if numitems == 0:
            return None
        else:
            for x in xrange(numitems):
                #typeLayer = lx.eval( "query sceneservice item.type ? %s" %(x) )
                #if( typeLayer == "renderOutput" ) :
                itemlist.append(
                    lx.eval('query sceneservice renderOutput.ID ? %s' % (x)))

            return itemlist
    except:
        #exc_log()
        lx.out("ERROR getRenderOuptut")
        return None
Exemple #25
0
    edge_bounds = getBoundingBox((vec1,vec2),threshold)
    sample_points = [vec1] + lineSamples (vec1, vec2, SECTORS) + [vec2]
    for point in sample_points:
        edge_sectors.append(tuple(int(math.ceil(x/y)-1) for x,y in izip(vecSub(layer_bounds[1],point), sector_range)))
    edge_sectors = set(edge_sectors)
    for sectors in edge_sectors:
        sector_vertices.extend(sector_space[sectors[0]][sectors[1]][sectors[2]])
    for vertex in sector_vertices:
        vec3 = lx.eval("query layerservice vert.pos ? " + str(vertex))

        #Check the vertex against the bounds of the edge
        if (vec3 != vec1 and vec3 != vec2) and \
           (vec3[0] > edge_bounds[0][0] and vec3[0] < edge_bounds[1][0]) and \
           (vec3[1] > edge_bounds[0][1] and vec3[1] < edge_bounds[1][1]) and \
           (vec3[2] > edge_bounds[0][2] and vec3[2] < edge_bounds[1][2]):
            vert_polys = set(lx.evalN("query layerservice vert.polyList ? " + str(vertex)))
            if not vert_polys:
                vert_polys = set([lx.eval1("query layerservice vert.polyList ? " + str(vertex))])
            edge_polys = set(lx.evalN("query layerservice edge.polyList ? " + str(edge)))
            if not edge_polys:
                edge_polys = set([lx.eval1("query layerservice edge.polyList ? " + str(edge))])
            
            if not edge_polys.intersection(vert_polys):         
                timer2 = time.clock()
                distance = vecDistanceAxis((vec1,vec2),vec3)
                try:
                    angle1 = vecAngle(vec1,vec2,vec1,vec3)
                except:
                    angle1 = 0
                try:
                    angle2 = vecAngle(vec2,vec1,vec2,vec3)
    if lx.eval("query scriptsysservice userValue.isDefined ? %(var)s" %
               vars()) == 0:
        lx.eval("user.defNew %(var)s %(type)s temporary" % vars())
    if val != None:
        lx.eval("user.value %(var)s %(val)s" % vars())
    if mes != None:
        lx.eval("user.def %(var)s username \"%(mes)s\"" % vars())
    if lst != None:
        lx.eval("user.def %(var)s list %(lst)s" % vars())
    if mes != None:
        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
def main(batchsize=None):
    lx.out("Headless Rendering Triggered")

    headless_path = lx.eval("query platformservice path.path ? headless") + "_cl"
    lx.eval("select.Item Render")
    first_frame = str(lx.eval("item.channel first ?"))
    last_frame = str(lx.eval("item.channel last ?"))
    frame_step = str(lx.eval("item.channel step ?"))

    save_selection = lx.evalN("query sceneservice selection ? all")

    filepath = bd_utils.filePath()
    filename = bd_utils.fileName().split(".")
    filename = filename[0]
    fullpath = lx.eval('query sceneservice scene.file ? current')

    groups = pyModo.Group_Name_All()
    passes = False

    pyModo.Render_Count_All()

    try:
        # set up the dialog
        lx.eval('dialog.setup yesNo')
        lx.eval('dialog.title {Confirm Operation}')
        lx.eval('dialog.msg {Try to query newer PathAliases?}')
        lx.eval('dialog.result ok')

        # Open the dialog and see which button was pressed
        lx.eval('dialog.open')
        lx.eval("dialog.result ?")
        pathaliases = bd_utils.pathAliases(ask=False)

    except:

        pathaliases = ""


    bd_utils.renderRegionCheck()

    for group in groups:

        if group == "passes":
            passes = True

    if passes:
        rendercmd = "render.animation {*} group:passes"
    else:
        rendercmd = "render.animation {*}"

    if filepath is False:
        lx.eval('layout.createOrClose EventLog "Event Log_layout" '
                'title:@macros.layouts@EventLog@ width:600 height:600 persistent:true '
                'open:true')
        lx.out("ERROR Please save scene first.")
    else:
        wd_regex = re.compile("/Volumes/ProjectsRaid/WorkingProjects/[^/]*/[^/]*/")
        workingdirectory = wd_regex.match(filepath).group()

        batchdir = workingdirectory + "work/modo/05_render/_batch/"
        bd_utils.makes_path(batchdir)

        shellfile = batchdir + filename + "_batchrender.sh"
        s = open(shellfile, 'w')
        s.write("""#!/usr/bin/env bash

source """ + mail_config_path + """
SUBJECT="modo render completed"
MACHINE=$(hostname -s)


START=$(date +%s)
STARTDATE=$(date -j -f "%s" "`date +%s`" "+%A, %d.%m.%Y %T")
FRAMES=$((""" + last_frame + """-""" + first_frame + """+1))

""")

        filesdir = workingdirectory + "work/modo/05_render/_batch/" + filename + "/"
        bd_utils.makes_path(filesdir)

        if batchsize:

            framelist = range(int(first_frame), int(last_frame) + 1, int(frame_step))
            framelist = chunker(framelist, batchsize)

            for framegroup in framelist:
                first_frame = str(min(int(minframe) for minframe in framegroup))
                last_frame = str(max(int(maxframe) for maxframe in framegroup))

                batchfile = filesdir + filename + \
                            "_batchrender_frames_" + first_frame + "-" + last_frame \
                            + ".txt"
                lx.out("Saving renderbatch at: " + batchfile)

                template = """log.toConsole true
log.toConsoleRolling true"""

                for alias, path in pathaliases.iteritems():
                    template = template + """
pathalias.create """ + alias + " \"" + path + "\""

                template = template + """
scene.open """ + fullpath + """
pref.value render.threads auto
select.Item Render
item.channel step """ + frame_step + """
item.channel first """ + first_frame + """
item.channel last """ + last_frame + """
""" + rendercmd + """
scene.close
app.quit
"""
                f = open(batchfile, 'w')
                f.write(template)
                f.close()

                s.write(headless_path + " < " + batchfile + "\n")

        else:

            batchfile = filesdir + filename + \
                        "_batchrender_frames_" + first_frame + "-" + last_frame \
                        + ".txt"
            lx.out("Saving renderbatch at: " + batchfile)

            template = """log.toConsole true
log.toConsoleRolling true"""

            if pathaliases is not "":
                for alias, path in pathaliases.iteritems():
                    template = template + """
pathalias.create """ + alias + " \"" + path + "\""

            template = template + """
scene.open """ + fullpath + """
pref.value render.threads auto
select.Item Render
item.channel step """ + frame_step + """
item.channel first """ + first_frame + """
item.channel last """ + last_frame + """
""" + rendercmd + """
scene.close
app.quit
"""
            f = open(batchfile, 'w')
            f.write(template)
            f.close()

            s.write(headless_path + " < " + batchfile + "\n")

        s.write("""
END=$(date +%s)
ENDDATE=$(date -j -f "%s" "`date +%s`" "+%A, %d.%m.%Y %T")
secs=$((END-START))
perframe=$(($secs/$FRAMES))
DURATION=$(printf '%dh:%02dm:%02ds' $(($secs/3600)) $(($secs%3600/60)) $(($secs%60)))
DURATIONPERFRAME=$(printf '%dh:%02dm:%02ds' $(($perframe/3600)) $(($perframe%3600/60)) $(($perframe%60)))

BODY="${MACHINE} just finished rendering """ + filename + """.
It started at ${STARTDATE}"""
                + """ and ended at ${ENDDATE} taking ${DURATION} overall for ${FRAMES} frames.
That's ${DURATIONPERFRAME} per frame on average."

echo "
#####
"

echo $BODY

echo "
#####
"

sendemail -f ${FROM_ADDRESS} -t ${TO_ADDRESS} -m ${BODY} -u ${SUBJECT} -s ${SERVER} -xu ${USER} -xp ${PASS}""")
        s.close()
        os.chmod(shellfile, 0755)

        pyperclip.copy(shellfile)
        subprocess.Popen(['open', '-a', '/Applications/Utilities/Terminal.app', '-n'])

    bd_utils.restoreSelection(save_selection)
            break
    if not find: return None
    loopedge.remove(e)
    p = set(lx.evalN("query layerservice edge.polyList ? %s" % e))
    if len(p.intersection(plist)) != 0:
        return None
    else:
        return e


mode = whichmode()
if mode == "edge":
    result = []
    main = lx.eval("query layerservice layers ? main")
    edges = [(v.strip("()").split(","))
             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",
Exemple #29
0
#python 

import lx
import sys

def SetValue(args):
    if "value" not in args:
        args["value"] = ""
    lx.eval("channel.value " + args["value"] + " channel:{" + item + ":" + args["name"] +"}")


args = lx.args()

args = dict(map(str.strip, arg.split(':', 1)) for arg in args)

items = lx.evalN("query sceneservice selection ? " + args["itemtype"])

if items == None:
    sys.exit("LXe_SUCCESS")
for item in items:
    lx.eval("query sceneservice item.name ? " + item)

    # check if the channel already exists
    for i in range(lx.eval("query sceneservice channel.N ?")):
        if lx.eval("query sceneservice channel.name ? " + str(i)) == args["name"]:
            if "action" in args and args["action"] == "delete":
                lx.eval("channel.delete")
            else:
                SetValue(args)
            sys.exit("LXe_SUCCESS")
    def process_items(self):
        self.begining_log()

        if not self.exportFile_sw:  # Transform Selected
            if self.userSelectionCount == 0:  # No file Selected
                self.init_message('error', 'No item selected', 'Select at least one item')
                sys.exit()

            self.transform_loop()
            self.scn.select(self.userSelection)

        elif not self.scanFiles_sw:  # export selected mesh
            if self.userSelectionCount == 0:  # No file Selected
                self.init_message('error', 'No item selected', 'Select at least one item')
                sys.exit()

            if self.exportEach_sw:
                self.init_dialog("output")
            else:
                self.init_dialog("file_save")

            try:  # output folder dialog
                lx.eval('dialog.open')
            except:
                self.init_dialog('cancel')
            else:
                output_dir = lx.eval1('dialog.result ?')
                self.batch_export(output_dir)

        else:  # browse file to process
            self.init_dialog("input")
            try:  # mesh to process dialog
                lx.eval('dialog.open')
            except:
                self.init_dialog('cancel')
            else:
                files = lx.evalN('dialog.result ?')
                self.init_dialog("output")
                try:  # output folder dialog
                    lx.eval('dialog.open')
                except:
                    self.init_dialog('cancel')
                else:
                    output_dir = lx.eval1('dialog.result ?')

                    for f in files:
                        self.processing_log('.....................................   ' + os.path.basename(f) + '   .....................................')

                        lx.eval('!scene.open "%s" normal' % f)

                        # if ext == 'fbx'
                        lx.eval('select.itemType mesh')

                        scnIndex = lx.eval('query sceneservice scene.index ? current')
                        self.userSelection = self.scn.selected
                        self.userSelectionCount = len(self.userSelection)

                        self.print_log('.....................................   ' + str(self.userSelectionCount) + ' mesh item founded   .....................................')

                        self.batch_export(output_dir)
                        lx.eval('!scene.close')

                self.init_message('info', 'Done', 'Operation completed successfully !')

        if self.exportFile_sw:
            if self.openDestFolder_sw:
                if self.scanFiles_sw:
                    self.open_folder(output_dir)
                if self.exportEach_sw:
                    self.open_folder(output_dir)
                else:
                    self.open_folder(os.path.split(output_dir)[0])

        self.ending_log()
Exemple #31
0
        "absmorpf": "spot",
        "rgb": "rgb",
        "rgba": "rgba",
        "pick": "pick"
    }
    for vm in vmaps:
        name = lx.eval("query layerservice vmap.name ? %s" % vm)
        type = ctd[lx.eval("query layerservice vmap.type ? %s" % vm)]
        lx.eval("select.vertexMap \"%s\" %s remove" % (name, type))


mode = whichmode()
edges = verts = None
main = lx.eval("query layerservice layers ? main")
if mode == "edge":
    edges = lx.evalN("query layerservice edges ? selected")
    lx.eval("select.convert vertex")
    verts = lx.evalN("query layerservice uvs ? selected")
elif mode == "vertex":
    verts = lx.evalN("query layerservice uvs ? selected")
    lx.eval("select.convert edge")
    edges = lx.evalN("query layerservice edges ? selected")
if edges != None:
    if lx.eval("query scriptsysservice userValue.isDefined ? uvaligner.divide"
               ) == 0:
        lx.eval("user.defNew uvaligner.divide integer temporary")
    lx.eval("user.def uvaligner.divide username \"divide method\"")
    lx.eval(
        "user.def uvaligner.divide list Uniform;Proportional;UVProportional")
    lx.eval("user.value uvaligner.divide")
    divide = lx.eval("user.value uvaligner.divide ?")
Exemple #32
0
    lx.eval("dialog.setup error")
    lx.eval("dialog.title \"%s\"" % titleString)
    lx.eval("dialog.msg \"%s\"" % errorString)
    lx.eval("dialog.open")


selmode = lx.eval("query layerservice selmode ?")
mainlayer = lx.eval("query layerservice layers ? main")

if selmode != "edge":
    lx.eval("poly.spinQuads")
    sys.exit("LXe_SUCCESS")

else:
    polys = []
    selected_polys = lx.evalN("query layerservice polys ? selected")
    edges = lx.evalN("query layerservice edges ? selected")
    for edge in edges:
        if lx.eval("query layerservice edge.numPolys ? " + str(edge)) == 2:
            polys.append(
                lx.evalN("query layerservice edge.polyList ? " + str(edge)))
    if not polys:
        sys.exit("LXe_SUCCESS")
    for poly in polys:
        lx.eval("select.drop polygon")
        lx.eval("select.element " + str(mainlayer) + " polygon add " +
                str(poly[0]))
        lx.eval("select.element " + str(mainlayer) + " polygon add " +
                str(poly[1]))
        lx.eval("poly.spinQuads")
    lx.eval("select.drop polygon")
Exemple #33
0
def partTwoMain(mesh, camera):
	lx.eval('view3d.projection psp')
	lx.eval('select.item %s add' % mesh)
	lx.eval('center.bbox center')
	lx.eval('select.less')
	lx.eval('item.parent %s %s inPlace:1' % (mesh, camera))
	lx.eval('select.item %s add' % camera)
	lx.eval('transform.channel rot.X 0.0')
	lx.eval('transform.channel rot.Y 0.0')
	lx.eval('transform.channel rot.Z 0.0')
	lx.eval('select.item %s add' % mesh)
	lx.eval('transform.channel pos.X 0.0')
	lx.eval('transform.channel pos.Y 0.0')
	lx.eval('transform.channel pos.Z 0.0')

	lx.eval('select.convert vertex')
	lx.eval('select.vertex add 0 0')
	vert_index = lx.evalN('query layerservice verts ? selected')
	vert_posX = []
	vert_posY = []
	vert_posZ = []

	for element in vert_index:
		vert_pos_single = lx.eval('query layerservice vert.wpos ? ' + str(element))

		if not vert_pos_single[0] in vert_posX:
			vert_posX.append(vert_pos_single[0])
		if not vert_pos_single[1] in vert_posY:
			vert_posY.append(vert_pos_single[1])
		if not vert_pos_single[2] in vert_posZ:
			vert_posZ.append(vert_pos_single[2])

	vert_posX.sort()
	vert_posY.sort()
	vert_posZ.sort()

	if vert_posX[-1] > abs(vert_posX[0]):
		vert_posX = vert_posX[-1]
	else:
		vert_posX = abs(vert_posX[0])
	if vert_posY[-1] > abs(vert_posY[0]):
		vert_posY = vert_posY[-1]
	else:
		vert_posY = abs(vert_posY[0])
	if vert_posZ[-1] > abs(vert_posZ[0]):
		vert_posZ = vert_posZ[-1]
	else:
		vert_posZ = abs(vert_posZ[0])


	if vert_posX > vert_posY and vert_posX > vert_posZ:
		axisBig = vert_posX
	elif vert_posY > vert_posZ:
		axisBig = vert_posY
	else:
		axisBig = vert_posZ

	print axisBig

	lx.eval('select.typeFrom item;pivot;center;edge;polygon;vertex;ptag true')
	lx.eval('transform.channel scl.X %s' % (10/axisBig))
	lx.eval('transform.channel scl.Y %s' % (10/axisBig))
	lx.eval('transform.channel scl.Z %s' % (10/axisBig))
Exemple #34
0
# To give a custom size to all channels in a selected Locators,
# no matter the kind of Locators and if there are some channels greyed
#
# www.etereaestudios.com

import lx

try:

    scene_svc = lx.Service("sceneservice")

    # Define my argument:
    mysize = float(lx.args()[0])

    # get selected layers
    selected_layers = lx.evalN("query sceneservice selection ? all")

    # drop selection so that we can work on one item at a time
    lx.eval("select.drop item")

    # create empty list to put locators in
    locators = []

    for item in selected_layers:

        # select layer
        scene_svc.select("item", str(item))
        lx.eval('select.item {%s} set' % item)

        # get item type
        itemType = scene_svc.query("item.type")
	group_locator_dict = construct_item_dict(group_locator)
	mesh_item_dict = construct_item_dict(mesh_item)

	path = r'C:\Users\lboucher\Documents\3dsMax\export\NewBodyPose'

	if len(group_locator): # at least one group locator or mesh item item selected
		
		init_dialog("input", path, 'fbx')

		try:  # mesh to process dialog
			lx.eval('dialog.open')
		except: # if cancel button pressed
			init_dialog('cancel', path)
		else: # process selected mesh
			files = lx.evalN('dialog.result ?')

			for f in files:
				filename = os.path.splitext(os.path.basename(f))[0]
				if filename in group_locator_name: # the filename have a groupLocator selected with the same name
					lx.eval('!!scene.open "{}" import'.format(f))
					print_log('Importing {}'.format(filename))

					imported_scene_root = modo.Item(filename + '_2')
					imported_items = get_child_of_type(imported_scene_root, 'mesh')
					source_items = get_child_of_type(group_locator_dict[filename], 'mesh')

					for imported_item in imported_items:
						matching_source_item = get_matching_item(source_items, imported_item, skipped_item_dict)
						if matching_source_item is not None:
							
Exemple #36
0
                    loopedge.remove(e)
                    break
        if not term:
            which.append(seqv)
    if len(which) == 2:
        if len(which[0]) < len(which[1]):
            return which[0]
        else:
            return which[1]
    else:
        return which[0]


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))
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))
#python

import lx

def selectConectedUV():
	lx.eval('!!select.3DElementUnderMouse set')
	lx.eval('ffr.selectconnecteduv')

selType = lx.eval1('query layerservice selmode ?')

if selType == 'polygon':
	p_hover = lx.eval1('query view3dservice element.over ? poly')
	p_sel = lx.evalN('query layerservice uv ? selected')
	if isinstance(p_hover, str):
		selectConectedUV()
	else:
		if len(p_sel)>0:
			lx.eval('ffr.selectconnecteduv')
		else:
			lx.eval('select.all')

elif selType == 'edge':
	lx.eval('select.type polygon')
	e_hover = lx.eval1('query view3dservice element.over ? poly')
	if isinstance(e_hover, str):
		selectConectedUV()
	else:
		lx.eval('select.all')

elif selType == 'vertex':
	lx.eval('select.type polygon')
    def basic_Execute(self, msg, flags):

        #The command will be enabled if at least 1 vert is selected.
        vertcount = lx.eval('select.count vertex ?')
        lx.out('vertcount', vertcount)

        #If no verts are selected display this dialog and exit command
        if vertcount <= 0:
            lx.eval('dialog.setup info')
            lx.eval('dialog.title {PP Locator Drop:}')
            lx.eval(
                'dialog.msg {You must have at least one vertex selected to run this script.}'
            )
            lx.eval('+dialog.open')
            return

        #reads the user values from the arguments
        locator = self.dyna_String(0)
        shape = self.dyna_String(1)
        label = self.dyna_String(2)
        solid = self.dyna_String(3)
        align = self.dyna_String(4)
        axis = self.dyna_String(5)
        sizeX = self.dyna_Float(6)
        sizeY = self.dyna_Float(7)
        sizeZ = self.dyna_Float(8)
        radius = self.dyna_Float(9)
        wcolor = self.dyna_String(10)
        fcolor = self.dyna_String(11)

        lx.out('locator name', locator)
        lx.out('shape', shape)
        lx.out('label', label)
        lx.out('solid', solid)
        lx.out('align', align)
        lx.out('axis', axis)
        lx.out('x', sizeX)
        lx.out('y', sizeX)
        lx.out('z', sizeX)
        lx.out('radius', radius)
        lx.out('wireframe color', wcolor)
        lx.out('fill color', fcolor)

        try:
            #All my regular code
            #pass
            layer = lx.eval('query layerservice layer.index ? main')
            verts = lx.evalN(
                'query layerservice verts ? selected')  # index of verts
            vertsN = lx.eval(
                'query layerservice vert.N ? selected')  #vert count
            lx.out('verts', verts)
            lx.out('vertsN', vertsN)

            #Now that the user set the values, we can just query it
            lx.out('text', locator)
            lx.out('type', shape)

            num = 1

            #for each vert create a locator and move the locator to the vert position
            for v in verts:
                #store vert position
                vertpos = lx.eval('query layerservice vert.pos ? %s' % v)
                vertPOS_X, vertPOS_Y, vertPOS_Z = vertpos

                #create locator and rename it to user input
                layer = lx.eval('item.create locator')
                layer = lx.eval('!!item.name %s_%s locator' % (locator, num))

                num += +1

                #move locator
                layer = lx.eval('transform.channel pos.Z %f' % vertPOS_Z)
                layer = lx.eval('transform.channel pos.Y %f' % vertPOS_Y)
                layer = lx.eval('transform.channel pos.X %f' % vertPOS_X)

                if shape == "standard":
                    lx.eval('item.channel locator$size %f' % sizeX)

                    #switch back to vert mode for next vert in list
                    lx.eval('select.typeFrom vertex')

                elif shape == "box":

                    #customize locator
                    lx.eval('item.channel locator$drawShape custom')
                    lx.eval('item.channel locator$isStyle replace')
                    lx.eval('item.channel locator$isShape %s' % shape)
                    lx.eval('item.help add label "%s"' % label)
                    lx.eval('item.channel locator$isSolid %s' % solid)
                    lx.eval('item.channel locator$isAlign %s' % align)
                    lx.eval('item.channel locator$isAxis %s' % axis)
                    lx.eval('item.channel locator$isSize.X %f' % sizeX)
                    lx.eval('item.channel locator$isSize.Y %f' % sizeY)
                    lx.eval('item.channel locator$isSize.Z %f' % sizeZ)
                    #lx.eval('item.channel locator$isRadius %f' %radius)

                    lx.eval('item.draw add locator')
                    lx.eval('item.channel locator$wireOptions user')
                    lx.eval('item.channel locator$wireColor {%s}' % wcolor)

                    lx.eval('item.channel locator$fillOptions user')
                    lx.eval('item.channel locator$fillColor {%s}' % fcolor)

                    #switch back to vert mode for next vert in list
                    lx.eval('select.typeFrom vertex')

                elif shape == "pyramid":

                    #customize locator
                    lx.eval('item.channel locator$drawShape custom')
                    lx.eval('item.channel locator$isStyle replace')
                    lx.eval('item.channel locator$isShape %s' % shape)
                    lx.eval('item.help add label "%s"' % label)
                    lx.eval('item.channel locator$isSolid %s' % solid)
                    lx.eval('item.channel locator$isAlign %s' % align)
                    lx.eval('item.channel locator$isAxis %s' % axis)
                    lx.eval('item.channel locator$isSize.X %f' % sizeX)
                    lx.eval('item.channel locator$isSize.Y %f' % sizeY)
                    lx.eval('item.channel locator$isSize.Z %f' % sizeZ)
                    #lx.eval('item.channel locator$isRadius %f' %radius)

                    lx.eval('item.draw add locator')
                    lx.eval('item.channel locator$wireOptions user')
                    lx.eval('item.channel locator$wireColor {%s}' % wcolor)

                    lx.eval('item.channel locator$fillOptions user')
                    lx.eval('item.channel locator$fillColor {%s}' % fcolor)

                    #switch back to vert mode for next vert in list
                    lx.eval('select.typeFrom vertex')

                elif shape == "rhombus":

                    #customize locator
                    lx.eval('item.channel locator$drawShape custom')
                    lx.eval('item.channel locator$isStyle replace')
                    lx.eval('item.channel locator$isShape %s' % shape)
                    lx.eval('item.help add label "%s"' % label)
                    lx.eval('item.channel locator$isSolid %s' % solid)
                    lx.eval('item.channel locator$isAlign %s' % align)
                    lx.eval('item.channel locator$isAxis %s' % axis)
                    lx.eval('item.channel locator$isSize.X %f' % sizeX)
                    lx.eval('item.channel locator$isSize.Y %f' % sizeY)
                    lx.eval('item.channel locator$isSize.Z %f' % sizeZ)
                    #lx.eval('item.channel locator$isRadius %f' %radius)

                    lx.eval('item.draw add locator')
                    lx.eval('item.channel locator$wireOptions user')
                    lx.eval('item.channel locator$wireColor {%s}' % wcolor)

                    lx.eval('item.channel locator$fillOptions user')
                    lx.eval('item.channel locator$fillColor {%s}' % fcolor)

                    #switch back to vert mode for next vert in list
                    lx.eval('select.typeFrom vertex')

                elif shape == "cylinder":

                    #customize locator
                    lx.eval('item.channel locator$drawShape custom')
                    lx.eval('item.channel locator$isStyle replace')
                    lx.eval('item.channel locator$isShape %s' % shape)
                    lx.eval('item.help add label "%s"' % label)
                    lx.eval('item.channel locator$isSolid %s' % solid)
                    lx.eval('item.channel locator$isAlign %s' % align)
                    lx.eval('item.channel locator$isAxis %s' % axis)

                    if axis == 'x':
                        lx.eval('item.channel locator$isSize.X %f' % sizeX)
                    elif axis == 'y':
                        lx.eval('item.channel locator$isSize.Y %f' % sizeY)
                    else:
                        lx.eval('item.channel locator$isSize.Z %f' % sizeZ)

                    lx.eval('item.channel locator$isRadius %f' % radius)

                    lx.eval('item.draw add locator')
                    lx.eval('item.channel locator$wireOptions user')
                    lx.eval('item.channel locator$wireColor {%s}' % wcolor)

                    lx.eval('item.channel locator$fillOptions user')
                    lx.eval('item.channel locator$fillColor {%s}' % fcolor)

                    #switch back to vert mode for next vert in list
                    lx.eval('select.typeFrom vertex')

                elif shape == "cone":

                    #customize locator
                    lx.eval('item.channel locator$drawShape custom')
                    lx.eval('item.channel locator$isStyle replace')
                    lx.eval('item.channel locator$isShape %s' % shape)
                    lx.eval('item.help add label "%s"' % label)
                    lx.eval('item.channel locator$isSolid %s' % solid)
                    lx.eval('item.channel locator$isAlign %s' % align)
                    lx.eval('item.channel locator$isAxis %s' % axis)

                    if axis == 'x':
                        lx.eval('item.channel locator$isSize.X %f' % sizeX)
                    elif axis == 'y':
                        lx.eval('item.channel locator$isSize.Y %f' % sizeY)
                    else:
                        lx.eval('item.channel locator$isSize.Z %f' % sizeZ)

                    lx.eval('item.channel locator$isRadius %f' % radius)

                    lx.eval('item.draw add locator')
                    lx.eval('item.channel locator$wireOptions user')
                    lx.eval('item.channel locator$wireColor {%s}' % wcolor)

                    lx.eval('item.channel locator$fillOptions user')
                    lx.eval('item.channel locator$fillColor {%s}' % fcolor)

                    #switch back to vert mode for next vert in list
                    lx.eval('select.typeFrom vertex')

                elif shape == "sphere":

                    #customize locator
                    lx.eval('item.channel locator$drawShape custom')
                    lx.eval('item.channel locator$isStyle replace')
                    lx.eval('item.channel locator$isShape %s' % shape)
                    lx.eval('item.help add label "%s"' % label)
                    lx.eval('item.channel locator$isSolid %s' % solid)
                    lx.eval('item.channel locator$isAlign %s' % align)
                    lx.eval('item.channel locator$isAxis %s' % axis)

                    lx.eval('item.channel locator$isRadius %f' % radius)

                    lx.eval('item.draw add locator')
                    lx.eval('item.channel locator$wireOptions user')
                    lx.eval('item.channel locator$wireColor {%s}' % wcolor)

                    lx.eval('item.channel locator$fillOptions user')
                    lx.eval('item.channel locator$fillColor {%s}' % fcolor)

                    #switch back to vert mode for next vert in list
                    lx.eval('select.typeFrom vertex')

                elif shape == "plane":

                    #customize locator
                    lx.eval('item.channel locator$drawShape custom')
                    lx.eval('item.channel locator$isStyle replace')
                    lx.eval('item.channel locator$isShape %s' % shape)
                    lx.eval('item.help add label "%s"' % label)
                    lx.eval('item.channel locator$isSolid %s' % solid)
                    lx.eval('item.channel locator$isAlign %s' % align)
                    lx.eval('item.channel locator$isAxis %s' % axis)

                    if axis == 'x':
                        lx.eval('item.channel locator$isSize.Y %f' % sizeY)
                        lx.eval('item.channel locator$isSize.Z %f' % sizeZ)
                    elif axis == 'y':
                        lx.eval('item.channel locator$isSize.X %f' % sizeX)
                        lx.eval('item.channel locator$isSize.Z %f' % sizeZ)
                    else:
                        lx.eval('item.channel locator$isSize.X %f' % sizeX)
                        lx.eval('item.channel locator$isSize.Y %f' % sizeY)

                    #lx.eval('item.channel locator$isRadius %f' %radius)

                    lx.eval('item.draw add locator')
                    lx.eval('item.channel locator$wireOptions user')
                    lx.eval('item.channel locator$wireColor {%s}' % wcolor)

                    lx.eval('item.channel locator$fillOptions user')
                    lx.eval('item.channel locator$fillColor {%s}' % fcolor)

                    #switch back to vert mode for next vert in list
                    lx.eval('select.typeFrom vertex')

                elif shape == "circle":

                    #customize locator
                    lx.eval('item.channel locator$drawShape custom')
                    lx.eval('item.channel locator$isStyle replace')
                    lx.eval('item.channel locator$isShape %s' % shape)
                    lx.eval('item.help add label "%s"' % label)
                    lx.eval('item.channel locator$isSolid %s' % solid)
                    lx.eval('item.channel locator$isAlign %s' % align)
                    lx.eval('item.channel locator$isAxis %s' % axis)

                    lx.eval('item.channel locator$isRadius %f' % radius)

                    lx.eval('item.draw add locator')
                    lx.eval('item.channel locator$wireOptions user')
                    lx.eval('item.channel locator$wireColor {%s}' % wcolor)

                    lx.eval('item.channel locator$fillOptions user')
                    lx.eval('item.channel locator$fillColor {%s}' % fcolor)

                    #switch back to vert mode for next vert in list
                    lx.eval('select.typeFrom vertex')

        except:
            lx.out(traceback.format_exc())
# To give a custom size to all channels in a selected Locators,
# no matter the kind of Locators and if there are some channels greyed
#
# www.etereaestudios.com

import lx

try:

    scene_svc = lx.Service("sceneservice")

    # Define my argument:
    mysize = float(lx.args()[0])

    # get selected layers
    selected_layers = lx.evalN("query sceneservice selection ? all")

    # drop selection so that we can work on one item at a time
    lx.eval("select.drop item")

    # create empty list to put locators in
    locators = []

    for item in selected_layers:

        # select layer
        scene_svc.select("item",str(item))
        lx.eval('select.item {%s} set' % item)

        # get item type
        itemType = scene_svc.query("item.type")
Exemple #41
0
# -------------------------------------------------------------------------------
# IF COMPONENTS ARE SELECTED (verts, edges or polys)
# -------------------------------------------------------------------------------

if mySelMode in components:

    # Force to select your Mesh in the Item List, for when components are selected
    # although some other Item is highlighted on ItemList (a very common issue)
    myMeshID = lx.eval('query layerservice layer.id ? %s' % myCurrentLayerID)
    lx.eval('select.subItem %s set  mesh;locator' % myMeshID)
    myMeshName = lx.eval('query sceneservice selection ? mesh')

    # Query Bounding Box of selected components using external script 'calculate_bbox.py' by James O'Hare aka Farfarer
    # http://community.thefoundry.co.uk/discussion/post.aspx?f=119&t=93824&p=839842
    boundBox = lx.evalN(
        'ffr.getbbox ? world'
    )  # Get world space boundBox as (+X, +Y, +Z, -X, -Y, -Z)

    # Calculate average (arithmetic mean) of resulting coords to get the Center for that Bounding Box
    # http://stackoverflow.com/questions/7716331/calculating-arithmetic-mean-average-in-python
    def average(numbers):
        return float(sum(numbers)) / max(len(numbers), 1)

    avgX = average([boundBox[0], boundBox[3]])
    avgY = average([boundBox[1], boundBox[4]])
    avgZ = average([boundBox[2], boundBox[5]])

    averagePos = (
        avgX, avgY, avgZ
    )  # This is the average/center position for selected components
    lx.out("INIT RENDER OUTPUT MANAGER")

if arg == 'loadPreset':
    lx.out("LOADING PRESET")
    loadPreset()

if arg == 'savePreset':
    lx.out("SAVING PRESET")
    savePreset()

#recupere la liste des layer actif "renderOutput"
if arg == 'getRender':

    #On sauve la selection
    active_scene = lx.eval("query sceneservice scene.name ? current")
    OSF_saveSelection = lx.evalN("query sceneservice selection ? all")

    #on eteint tous les flag
    numList = len(listName)
    i = 0
    while (i < numList):
        nameFlag = "rom_" + listName[i] + "Flag"
        lx.eval('user.value %s {}' % nameFlag)
        i = i + 1

        #on recupere la liste de tous les layer actif
    existingRenderOutput = getRenderOuptut()
    #on regarde chaque layer si il existe on active le boutton correspondant
    num = len(existingRenderOutput)
    first = True
    if (num):
Exemple #43
0
#python

import lx


def selectConectedUV():
    lx.eval('!!select.3DElementUnderMouse set')
    lx.eval('select.polygonConnect m3d false')


selType = lx.eval1('query layerservice selmode ?')

if selType == 'polygon':
    p_hover = lx.eval1('query view3dservice element.over ? poly')
    p_sel = lx.evalN('query layerservice polys ? selected')
    if isinstance(p_hover, str):
        selectConectedUV()
    else:
        if len(p_sel) > 0:
            lx.eval('select.polygonConnect m3d false')
        else:
            lx.eval('select.all')

elif selType == 'edge':
    lx.eval('select.type polygon')
    e_hover = lx.eval1('query view3dservice element.over ? poly')
    if isinstance(e_hover, str):
        selectConectedUV()
    else:
        lx.eval('select.all')
def main():
    lx.eval("user.defNew gl_viewport_size integer momentary")
    lx.eval('user.def gl_viewport_size username "Open New GL View"')
    lx.eval('user.def gl_viewport_size dialogname "Which resolution do you need to open?"')
    lx.eval("user.def gl_viewport_size list Full;Half;Quarter;Tenth")
    lx.eval('user.def gl_viewport_size listnames "100%;50%;25%;10%"')
    lx.eval("user.value gl_viewport_size")

    mode = lx.eval("user.value gl_viewport_size ?")

    if mode == "Full":
        percent = 1.0
    elif mode == "Half":
        percent = 0.5
    elif mode == "Quarter":
        percent = 0.25
    elif mode == "Tenth":
        percent = 0.1
    else:
        percent = 1

    lx.eval("user.defNew gl_type integer momentary")
    lx.eval('user.def gl_type username "GL Recording Type"')
    lx.eval('user.def gl_type dialogname "Do you want to capture a movie or an image sequence?"')
    lx.eval("user.def gl_type list movie;image")
    lx.eval('user.def gl_type listnames "Movie;Image Sequence"')
    lx.eval("user.value gl_type")

    gl_type = lx.eval("user.value gl_type ?")

    all_cameras = get_ids("camera")
    render_camera = lx.eval("render.camera ?")

    list=str(render_camera) + ";"
    listnames="Render Camera;"


    for x in all_cameras:

        list += x + ";"
        listnames += lx.eval('query sceneservice item.name ? %s' % x) + ";"

    lx.out(list)
    lx.out(listnames)


    lx.eval("user.defNew viewport_cam integer momentary")
    lx.eval('user.def viewport_cam username "Pick Viewport Camera"')
    lx.eval('user.def viewport_cam dialogname "Which camera do you want to capture?"')
    lx.eval("user.def viewport_cam list " + list)
    lx.eval('user.def viewport_cam listnames "' + listnames + '"')
    lx.eval("user.value viewport_cam")

    capture_camera = lx.eval("user.value viewport_cam ?")
    capture_camera_name = lx.eval('query sceneservice item.name ? %s' % capture_camera)
    lx.out(capture_camera)
    lx.out(capture_camera_name)

    lx.eval("user.defNew shading_style integer momentary")
    lx.eval('user.def shading_style username "Pick Viewport Shading"')
    lx.eval('user.def shading_style dialogname "Which Shading Style do you want?"')
    lx.eval("user.def shading_style list gnzgl;advgl;texmod;tex;shade;vmap;sket;wire;shd1;shd2;shd3")
    lx.eval('user.def shading_style listnames "Advanced;Default;Texture Shaded;Texture;Shaded;Vertex Map;Solid;Wireframe;Gooch Toon Shading;Cel Shading;Reflection"')
    lx.eval("user.value shading_style")

    shading_style = lx.eval("user.value shading_style ?")

    # Get selection
    save_selection = lx.evalN("query sceneservice selection ? all")

    # Get Render Resolution
    lx.eval("select.item Render")
    resX = float(lx.eval("item.channel resX ?"))
    resY = float(lx.eval("item.channel resY ?"))

    newResX = int(resX * percent)
    newResY = int(resY * percent)

    # Restore selection
    restoreSelection(save_selection)

    lx.eval('layout.create %s width:%s height:%s style:palette' % (capture_camera_name, newResX, newResY))
    lx.eval('viewport.restore base.3DSceneView false 3Dmodel')
    lx.eval('view3d.bgEnvironment background solid')
    lx.eval('view3d.showGrid false')
    lx.eval('view3d.projection cam')
    lx.eval('view3d.controls false')
    lx.eval('view3d.showLights false')
    lx.eval('view3d.showCameras false')
    lx.eval('view3d.showLocators false')
    lx.eval('view3d.showTextureLocators false')
    lx.eval('view3d.showBackdrop false')
    lx.eval('view3d.showSelections false')
    lx.eval('view3d.fillSelected false')
    lx.eval('view3d.outlineSelected false')
    lx.eval('view3d.showSelectionRollover false')
    lx.eval('view3d.shadingStyle ' + shading_style + ' active')
    lx.eval('view3d.wireframeOverlay none active')
    lx.eval('view3d.cameraItem ' + capture_camera)
    lx.eval('view3d.shadingStyle ' + shading_style)
    lx.eval('view3d.sameAsActive true')

    if shading_style == "gnzgl":
        lx.eval("view3d.showGnzFSAA x9")
        lx.eval("view3d.setGnzTransparency correct")
        lx.eval("view3d.setGnzSSReflections blurry")
        lx.eval("view3d.setGnzDitherMode ordered")
        lx.eval("view3d.showGnzSSAO true")
        lx.eval("view3d.GnzVisOverride all")
        lx.eval("view3d.showGnzShadows true")
        lx.eval("view3d.useGnzNormalMaps true")
        lx.eval("view3d.useGnzBumpMaps true")
        lx.eval("view3d.setGnzVisibility render")
        lx.eval("view3d.setGnzLighting sceneIBLLights")
        lx.eval("view3d.setGnzBackground environment")

    if gl_type == "movie":
        lx.eval("gl.capture")
    if gl_type == "image":
        lx.eval("gl.capture seq:true")

    lx.eval("layout.closeWindow")
def main():
    lx.eval("user.defNew overscan_mode integer momentary")
    lx.eval('user.def overscan_mode username "Overscan Mode"')
    lx.eval('user.def overscan_mode dialogname "Which overscan mode do you want to use?"')
    lx.eval("user.def overscan_mode list resolution;scaling")
    lx.eval("user.value overscan_mode")

    mode = lx.eval("user.value overscan_mode ?")
    lx.out(mode)

    # Get selection
    save_selection = lx.evalN("query sceneservice selection ? all")

    # Get Render Camera
    render_camera = lx.eval("render.camera ?")
    lx.eval("select.item {%s} set" % render_camera)

    # Get Film Back
    apertureX = lx.eval("item.channel apertureX ?")
    apertureY = lx.eval("item.channel apertureY ?")

    # Get Render Resolution
    lx.eval("select.item Render")
    resX = float(lx.eval("item.channel resX ?"))
    resY = float(lx.eval("item.channel resY ?"))

    if mode == "resolution":

        # Ask for new resolution
        lx.eval("user.defNew newRes.X integer momentary")
        lx.eval("user.value newRes.X")
        newResX = lx.eval("user.value newRes.X ?")

        lx.eval("user.defNew newRes.Y integer momentary")
        lx.eval("user.value newRes.Y")
        newResY = lx.eval("user.value newRes.Y ?")

    elif mode == "scaling":

        # Ask for scaling factor
        lx.eval("user.defNew newRes.scaling float momentary")
        lx.eval("user.value newRes.scaling")
        newResScaling = lx.eval("user.value newRes.scaling ?")
        newResX = resX * newResScaling
        newResY = resY * newResScaling

    # Apply Overscan formula to width and height
    newApertureX = apertureX * (newResX / resX)
    newApertureY = apertureY * (newResY / resY)

    # Fill in new render resolution
    lx.eval("render.res 0 %s" % newResX)
    lx.eval("render.res 1 %s" % newResY)

    # Fill in new film back
    lx.eval("select.item {%s} set" % render_camera)
    lx.eval("item.channel apertureX %s" % newApertureX)
    lx.eval("item.channel apertureY %s" % newApertureY)

    # Restore selection
    restoreSelection(save_selection)
Exemple #46
0
            a[6] * b[1] + a[7] * b[4] + a[8] * b[7],
            a[6] * b[2] + a[7] * b[5] + a[8] * b[8]
        ]


if lx.eval(
        "query scriptsysservice userValue.isDefined ? circle3p.divide") == 0:
    lx.eval("user.defNew circle3p.divide integer temporary")
    lx.eval("user.def circle3p.divide username \"side\"")
    lx.eval("user.value circle3p.divide 36")
lx.eval("user.value circle3p.divide")
divide = lx.eval("user.value circle3p.divide ?")
redundancy = 0.00001
lx.eval("select.type vertex")
main = lx.eval("query layerservice layers ? main")
verts = [int(v) for v in lx.evalN("query layerservice verts ? selected")]
spos = set()
for v in verts:
    spos.add(lx.eval("query layerservice vert.pos ? %s" % v))
pos = list(spos)
if len(pos) >= 3:
    pos1 = pos[0]
    pos2 = pos[1]
    pos3 = pos[2]
    normal = outer(vector(pos2, pos1), vector(pos3, pos1))
    v1 = crossplanes(normal,
                     [pos2[0] - pos1[0], pos2[1] - pos1[1], pos2[2] - pos1[2]])
    p1 = [(pos1[0] + pos2[0]) / 2.0, (pos1[1] + pos2[1]) / 2.0,
          (pos1[2] + pos2[2]) / 2.0]
    v2 = crossplanes(normal,
                     [pos3[0] - pos1[0], pos3[1] - pos1[1], pos3[2] - pos1[2]])
#python

import lx

def selectConectedUV():
	lx.eval('!!select.3DElementUnderMouse set')
	lx.eval('select.polygonConnect m3d false')

selType = lx.eval1('query layerservice selmode ?')

if selType == 'polygon':
	p_hover = lx.eval1('query view3dservice element.over ? poly')
	p_sel = lx.evalN('query layerservice polys ? selected')
	if isinstance(p_hover, str):
		selectConectedUV()
	else:
		if len(p_sel)>0:
			lx.eval('select.polygonConnect m3d false')
		else:
			lx.eval('select.all')

elif selType == 'edge':
	lx.eval('select.type polygon')
	e_hover = lx.eval1('query view3dservice element.over ? poly')
	if isinstance(e_hover, str):
		selectConectedUV()
	else:
		lx.eval('select.all')

elif selType == 'vertex':
	lx.eval('select.type polygon')
# -------------------------------------------------------------------------------
# IF COMPONENTS ARE SELECTED (verts, edges or polys)
# -------------------------------------------------------------------------------

if mySelMode in components:

	# Force to select your Mesh in the Item List, for when components are selected
	# although some other Item is highlighted on ItemList (a very common issue)
	myMeshID = lx.eval('query layerservice layer.id ? %s' % myCurrentLayerID)
	lx.eval('select.subItem %s set  mesh;locator' % myMeshID)
	myMeshName = lx.eval('query sceneservice selection ? mesh')


	# Query Bounding Box of selected components using external script 'calculate_bbox.py' by James O'Hare aka Farfarer
	# http://community.thefoundry.co.uk/discussion/post.aspx?f=119&t=93824&p=839842
	boundBox = lx.evalN('ffr.getbbox ? world')  # Get world space boundBox as (+X, +Y, +Z, -X, -Y, -Z)


	# Calculate average (arithmetic mean) of resulting coords to get the Center for that Bounding Box
	# http://stackoverflow.com/questions/7716331/calculating-arithmetic-mean-average-in-python
	def average(numbers):
		return float(sum(numbers)) / max(len(numbers), 1)

	avgX = average([boundBox[0], boundBox[3]])
	avgY = average([boundBox[1], boundBox[4]])
	avgZ = average([boundBox[2], boundBox[5]])

	averagePos = (avgX, avgY, avgZ)  # This is the average/center position for selected components

	# Create a locator, size 0
	lx.eval('item.create locator')
#python

import lx

selectedGroups = lx.evalN('query sceneservice selection ? groupLocator')


def scalePos(axis):

	try:
		getPos=lx.eval("item.channel pos.%s ?" %(axis))
		lx.out(getPos)
		scaledPos=getPos/100
		lx.eval("transform.channel pos.%s %s" %( axis, scaledPos))
	except:
		lx.eval("transform.channel pos.%s 0" %(axis))


for i in selectedGroups:
	lx.eval('select.item {%s} set' % i)
	axis=str("X")
	scalePos(axis)
	axis=str("Y")
	scalePos(axis)
	axis=str("Z")
	scalePos(axis)



Exemple #50
0
import lx
import copy

itemNum = lx.eval("query sceneservice item.N ? ")
itemNumList = range(0, itemNum)

itemList = {}

for item in itemNumList:
    itemID = lx.eval("query sceneservice item.id ? %s" % item)
    itemName = lx.eval("query sceneservice item.name ? %s" % item)
    itemList[item] = itemID + ' ' + itemName
#itemList.append(itemID);
lx.out(itemList)

selItems = lx.evalN("query sceneservice selection ? all")

lis = list(selItems)  #tuple to list conversion
lx.out(selItems)  #tuple
lx.out(lis)  #list

cha = []

for item in lis:
    lx.eval("select.subitem %s add mesh 1 1" % item)
    newSel = lx.eval("query sceneservice selection ? all")
    for element in newSel:
        if element not in cha:
            cha.append(element)

chaName = []
    def batch_files(self):
        self.currPath = file.getLatestPath(t.config_browse_src_path)
        dialog.init_dialog("input", self.currPath)

        try:  # mesh to process dialog
            lx.eval('dialog.open')
        except:
            dialog.init_dialog('cancel', self.currPath)
        else:
            files = lx.evalN('dialog.result ?')
            file.updateExportPath('', os.path.split(files[0])[0], '')
            self.currPath = file.getLatestPath(t.config_browse_dest_path)
            dialog.init_dialog("output", self.currPath)
            try:  # output folder dialog
                lx.eval('dialog.open')
            except:
                dialog.init_dialog('cancel', self.currPath)
            else:
                output_dir = lx.eval1('dialog.result ?')
                file.updateExportPath('', '', output_dir)

                file_count = len(files)

                self.progress = dialog.init_progress_bar(
                    file_count, 'Exporting files...')

                self.progression[1] = file_count
                self.progression[0] = 0

                t.set_import_setting()

                for f in files:
                    dialog.processing_log(
                        '.....................................   ' +
                        os.path.basename(f) +
                        '   .....................................')

                    lx.eval('!scene.open "%s" normal' % f)

                    self.scnIndex = lx.eval(
                        'query sceneservice scene.index ? current')

                    helper.select_compatible_item_type()

                    self.userSelection = self.scn.selected
                    self.userSelectionCount = len(self.userSelection)

                    dialog.print_log(
                        '.....................................   ' +
                        str(self.userSelectionCount) +
                        ' mesh item founded   .....................................'
                    )

                    if self.at_least_one_item_selected(exit=False):
                        lx.eval('!scene.close')
                        continue

                    self.filename = os.path.splitext(os.path.basename(f))[0]

                    self.batch_process(output_dir, self.filename)

                    dialog.increment_progress_bar(self, self.progress[0],
                                                  self.progression)

                    helper.revert_initial_parameter(self)

                    lx.eval('!scene.close')

                helper.reset_import_settings(self)

        dialog.init_message(
            'info', 'Done',
            'Operation completed successfully ! %s file(s) exported' %
            self.exportedFileCount)

        helper.open_destination_folder(self, output_dir)

        dialog.ending_log(self)
        # ---------------------------------

        lx.eval("item.matchWorkplanePos")

    scene_svc = lx.Service("sceneservice")
    layer_svc = lx.Service("layerservice")

    allowed_modes = ('polygon', 'edge', 'vertex')

    # Query Mode (For the IF item)
    FirstCheckModoMode = lx.eval('query layerservice selmode ?')

    itemtypes = ("locator", "light", "sunLight", "camera", "mesh")

    # Selected layers
    selMesh = lx.evalN("query sceneservice selection ? all")

    lx.out(FirstCheckModoMode)

    # If no layer and no component selected
    if len(selMesh) == 0 and not FirstCheckModoMode == 'item':
        lx.out("no component")
        locator_at_zero()

    # Check if current selection mode is a component mode
    if FirstCheckModoMode in allowed_modes:

        lx.out("component mode")

        for item in selMesh:
    lx.out("INIT RENDER OUTPUT MANAGER")

if arg == 'loadPreset':
    lx.out("LOADING PRESET")
    loadPreset()

if arg == 'savePreset':
    lx.out("SAVING PRESET")
    savePreset()

#recupere la liste des layer actif "renderOutput"
if arg == 'getRender':

    #On sauve la selection 
    active_scene = lx.eval("query sceneservice scene.name ? current")
    OSF_saveSelection = lx.evalN("query sceneservice selection ? all")

    #on eteint tous les flag
    numList = len(listName)
    i=0
    while ( i < numList):
        nameFlag = "rom_"+listName[i]+"Flag";
        lx.eval('user.value %s {}' % nameFlag)
        i = i+ 1

        #on recupere la liste de tous les layer actif
    existingRenderOutput = getRenderOuptut()
    #on regarde chaque layer si il existe on active le boutton correspondant
    num = len(existingRenderOutput)
    first = True
    if (num):
#python

import lx


def selectConectedUV():
    lx.eval('!!select.3DElementUnderMouse set')
    lx.eval('ffr.selectconnecteduv')


selType = lx.eval1('query layerservice selmode ?')

if selType == 'polygon':
    p_hover = lx.eval1('query view3dservice element.over ? poly')
    p_sel = lx.evalN('query layerservice uv ? selected')
    if isinstance(p_hover, str):
        selectConectedUV()
    else:
        if len(p_sel) > 0:
            lx.eval('ffr.selectconnecteduv')
        else:
            lx.eval('select.all')

elif selType == 'edge':
    lx.eval('select.type polygon')
    e_hover = lx.eval1('query view3dservice element.over ? poly')
    if isinstance(e_hover, str):
        selectConectedUV()
    else:
        lx.eval('select.all')
def getRenderOuptut():
    """ Get a list of item IDs of type 'type'
        Returns a list of item IDs or None if there are no items of the specified
        tyep or if there's an error. Error printed is to Event log.
        type - the type of item to be returned (mesh, camera etc)
    """
    global updateOnly 
    global groupSelected
    global updateExistingOnly
    updateOnly = False
    try:
        """
        #Si on fait seulement la mise a jour on recuoere tous les render existant ou ceux que lon a selectionner
        if (updateExistingOnly):
            RenderOutputsSelected = lx.evalN('query sceneservice selection ? renderOutput')
            RenderOutputs = []

            if RenderOutputsSelected:
                for layer in RenderOutputsSelected:
                    lx.out("UPDADE ONLY ",layer)
                    RenderOutputs.append(lx.eval('query sceneservice item.ID ? %s' % layer))
                return RenderOutputs
            # si on a rien selectionner on met a jour tous les éléments
            else:
            
                itemlist = []
                numitems = lx.eval('!!query sceneservice renderOutput.N ?')
                if numitems == 0:
                    return None
                else:
                    for x in xrange(numitems):
                    #typeLayer = lx.eval( "query sceneservice item.type ? %s" %(x) )
                    #if( typeLayer == "renderOutput" ) :
                        idRender = lx.eval('query sceneservice renderOutput.ID ? %s' % (x))
                        itemlist.append(idRender)
                    return itemlist
"""


        #Est ce qu'on a selectionner des render Ouput
        RenderOutputsSelected = lx.evalN('query sceneservice selection ? renderOutput')
        RenderOutputs = []

        if RenderOutputsSelected:
            for layer in RenderOutputsSelected:
                lx.out(layer)
                lx.out("le parent:"+lx.eval('query sceneservice item.parent ? %s' % layer))
                RenderOutputs.append(lx.eval('query sceneservice item.ID ? %s' % layer))
            updateOnly = True;
            return RenderOutputs

        #Est ce qu'une selection de group exist ?
        selectionMask = lx.evalN('query sceneservice selection ? mask')
        masks = []

        if selectionMask:
            layer = selectionMask[0]
            lx.out(layer)
            groupSelected = layer #lx.eval('query sceneservice item.name ? %s' % layer)
            nameGroup = lx.eval('query sceneservice item.name ? %s' % layer) +"_"
            nameGroup = nameGroup.replace(" (Material)","")
            nameGroup = nameGroup.replace(" (Item)","")

            lx.eval('user.value rom_prefixName %s' %(nameGroup))
            #Has child output           
            childRender = lx.evalN('query sceneservice item.children ? %s' % layer)
            lx.out(childRender)
            return childRender


        #Est ce qu'une selection de Render principal ?
        selectionMask = lx.evalN('query sceneservice selection ? polyRender')
        masks = []

        if selectionMask:
            layer = selectionMask[0]
            lx.out(layer)
            groupSelected = layer #lx.eval('query sceneservice item.name ? %s' % layer)
            #Has child output           
            childRender = lx.evalN('query sceneservice item.children ? %s' % layer)
            lx.out(childRender)
            return childRender


        # On peut cree seulement en selectionnant le poly render, un render output ou un mask
        itemlist = []
        numitems = lx.eval('!!query sceneservice renderOutput.N ?')
        if numitems == 0:
            return None
        else:
            for x in xrange(numitems):
        #typeLayer = lx.eval( "query sceneservice item.type ? %s" %(x) )
        #if( typeLayer == "renderOutput" ) :
                    itemlist.append(lx.eval('query sceneservice renderOutput.ID ? %s' % (x)))

            return itemlist
    except:
        #exc_log()
        lx.out("ERROR getRenderOuptut")
        return None
# File: mc_lxRename_removeX.py
# Author: Matt Cox
# Description: Bulk renames a selection of items, removing X amount of characters from the start or the end. Based upon the user variable removeX.

import lx
import re

lxRRemoveXString = lx.eval( "user.value mcRename.removeX ?" )
lxRRemoveXArgs = lx.args()
lxRRemoveXArg = lxRRemoveXArgs[0]

if lxRRemoveXString < 0:
    lxRRemoveXString = 0
try:
    lxRSelectedItems = lx.evalN('query sceneservice selection ? all')
    
    for x in lxRSelectedItems:
        lx.eval('select.Item %s' %str(x))
        lxRMeshNameM = lx.eval('query sceneservice item.name ? %s' %str(x))
        try:
            if lxRRemoveXArg == "start":
                lxRNewNameM = lxRMeshNameM[lxRRemoveXString:]
            else:
                lxRNewNameM = lxRMeshNameM[:-lxRRemoveXString]
            lx.eval('item.name "%s"'%(lxRNewNameM))
        except:
            lx.eval('dialog.setup error')
            lx.eval('dialog.title {Error}')
            lx.eval('dialog.msg {Unable to rename items.}')
            lx.eval('dialog.open')   
		# ---------------------------------    

		lx.eval("item.matchWorkplanePos")

	scene_svc = lx.Service("sceneservice")
	layer_svc = lx.Service("layerservice")
	
	allowed_modes = ('polygon', 'edge', 'vertex')

	# Query Mode (For the IF item)
	FirstCheckModoMode = lx.eval('query layerservice selmode ?')
	
	itemtypes = ("locator","light","sunLight","camera","mesh")

	# Selected layers
	selMesh = lx.evalN("query sceneservice selection ? all")

	lx.out(FirstCheckModoMode)
	
	# If no layer and no component selected
	if len(selMesh) == 0 and not FirstCheckModoMode == 'item':
		lx.out("no component")
		locator_at_zero()
	
	# Check if current selection mode is a component mode
	if FirstCheckModoMode in allowed_modes:
	
		lx.out("component mode")
		
		for item in selMesh:
			
Exemple #58
0
def getBoundarySideFromPolys(polygon_index_set):
    mainlayer = lx.eval("query layerservice layers ? main")
    edge_list = []

    while polygon_index_set:
        lx.eval("!!select.drop polygon")
        lx.eval("!!select.element " + str(mainlayer) + " polygon set " + str(polygon_index_set.pop()))
        lx.eval("!!select.connect")
        current_polys = lx.eval("query layerservice polys ? selected")
        lx.eval("!!select.drop edge")
        lx.eval("!!select.type polygon")
        lx.eval("!!select.boundary")
        boundary_edges = set(eval(x) for x in lx.eval("query layerservice edges ? selected"))
        
        loop_edges = []
        while boundary_edges:
            boundary_edge = boundary_edges.pop()
            lx.eval("select.element " + str(mainlayer) + " edge set " + str(boundary_edge[0]) + " " + str(boundary_edge[1]))
            lx.eval("select.loop")
            loop_edges.append([eval(x) for x in lx.eval("query layerservice edges ? selected")])
            boundary_edges -= set(loop_edges[len(loop_edges) - 1])
            
        lx.out(len(loop_edges))
        lx.out(loop_edges)
        if len(loop_edges) > 2:
            error ("Bad Selection", "Polygon selection has holes")
            sys.exit( "LXe_FAILED:Script failed" )
        if len(loop_edges) == 2:
            error ("Bad Selection", "You selection is a polygon loop")
            sys.exit( "LXe_FAILED:Script failed" )
            
        edge_verts = set()
        for poly in current_polys:
            edge_verts = edge_verts.symmetric_difference(set(lx.eval("query layerservice poly.vertList ? " + str(poly))))
        if len(edge_verts) != 4:
            error ("Bad Selection", "Selection contains broken polygons loops or has polygons with more or less than four vertices. Quads only")
            sys.exit( "LXe_FAILED:Script failed" )

        edge_vert = edge_verts.pop()
        shortest_edge_vert = 0
        steps = 0
        lx.eval("select.type vertex")
        while edge_verts:
            lx.eval("select.element " + str(mainlayer) + " vert set " + str(edge_vert))
            test_vert = edge_verts.pop()
            lx.eval("select.element " + str(mainlayer) + " vert add " + str(test_vert))
            lx.eval("select.between")
            current_steps = lx.eval("query layerservice vert.N ? selected")
            if current_steps < steps or steps == 0:
                steps = current_steps
                shortest_edge_vert = test_vert

        lx.eval("select.element " + str(mainlayer) + " vert set " + str(edge_vert))
        lx.eval("select.element " + str(mainlayer) + " vert add " + str(shortest_edge_vert))
        lx.eval("select.between")
        lx.eval("select.convert edge")
        
        edge_list.append([eval(x) for x in lx.evalN("query layerservice edges ? selected")])
        
        polygon_index_set -= set(current_polys)

    lx.eval("!!select.drop edge")
    for edges in edge_list:
        for edge in edges: 
            lx.eval("select.element " + str(mainlayer) + " edge add " + str(edge[0]) + " " + str(edge[1]))
    return edge_list
#python

import lx

selection = lx.evalN('query sceneservice selection ? mesh')
for mesh in selection:
    meshName = lx.eval('query sceneservice item.name ? {%s}' % mesh)
    lx.eval('select.item {%s} set' % mesh)
    numMat = lx.eval1('query layerservice material.N ?')
    for i in range(0, numMat):
        matID = lx.eval('query layerservice material.id ? {%s}' % i)
        matParent = lx.eval('query sceneservice item.parent ? {%s}' % matID)
        if i == 0:
            lx.eval('select.item {%s} set' % matParent)
        else:
            lx.eval('select.item {%s} add' % matParent)
    lx.eval('shader.group')
    lx.eval('item.name {%s (Materials)} mask' % meshName)
    lx.eval('select.drop item')