def act_project_create(self):
        '''
        Create a Modo project at the destination specified by the user via File Dialog.
        '''
        # create the project with the standard template
        try:
            lx.eval('?projdir.instantiate')
            folderPicked = True
        except:
            folderPicked = False

        if folderPicked:
            # get the path we just set
            platform = lx.service.Platform()
            for idx in range(platform.PathCount()):
                if platform.PathNameByIndex(idx) == "project":
                    folder = platform.PathByIndex(idx)

            # update the project list file
            self.write_projectListFile(folder)

            # update the project list in the UI
            self.projects_getExisting()

            # log and inform
            lx.out('PROJECT MANAGER: A new project was created: %s' %folder)
            self.dialog_info('Project Manager', "Project '%s' was created!" %os.path.basename(folder))
    def commander_execute(self, msg, flags):
        for hotkey in HOTKEYS:
            key = hotkey["key"]

            for context_list in hotkey["contexts"]:
                mapping = context_list[0]
                state = context_list[1]
                region = context_list[2]
                context = context_list[3]
                default = context_list[4]

                if default is None:
                    try:
                        lx.eval('!cmds.clearKey {%s} {%s} {%s} {%s} {%s}' %
                                (key, mapping, state, region, context))
                    except:
                        lx.out("Could not clear mapping for '%s'." % key)
                else:
                    try:
                        lx.eval(
                            '!cmds.mapKey {%s} {%s} {%s} {%s} {%s} {%s}' %
                            (key, default, mapping, state, region, context))
                    except:
                        lx.out("Could not set '%s' to '%s'." % (default, key))

        modo.dialogs.alert(
            "Reverted TabbyCat Hotkeys",
            "Reverted %s TabbyCat hotkeys to defaults." % len(HOTKEYS))
    def mesh_edit(self, read_only=False):
        """Adapted from James O'Hare's excellent code: https://gist.github.com/Farfarer/31148a78f392a831239d9b018b90330c"""

        if read_only:
            scan_allocate = lx.symbol.f_LAYERSCAN_ACTIVE | lx.symbol.f_LAYERSCAN_MARKPOLYS
        if not read_only:
            scan_allocate = lx.symbol.f_LAYERSCAN_EDIT

        layer_svc = lx.service.Layer()
        layer_scan = lx.object.LayerScan(layer_svc.ScanAllocate(scan_allocate))

        self.mesh_svc = lx.service.Mesh()

        if not layer_scan.test():
            return

        for n in xrange(layer_scan.Count()):
            if read_only:
                self.mesh = lx.object.Mesh(layer_scan.MeshBase(n))
            if not read_only:
                self.mesh = lx.object.Mesh(layer_scan.MeshEdit(n))

            if not self.mesh.test():
                continue

            polygon_count = self.mesh.PolygonCount()
            if polygon_count == 0:
                continue

            self.polygon_accessor = lx.object.Polygon(
                self.mesh.PolygonAccessor())
            if not self.polygon_accessor.test():
                continue

            self.edge_accessor = lx.object.Edge(self.mesh.EdgeAccessor())
            if not self.edge_accessor.test():
                continue

            self.point_accessor = lx.object.Point(self.mesh.PointAccessor())
            if not self.point_accessor.test():
                continue

            self.meshmap_accessor = lx.object.MeshMap(
                self.mesh.MeshMapAccessor())
            if not self.meshmap_accessor.test():
                continue

            try:
                if read_only:
                    self.mesh_read_action()
                if not read_only:
                    self.mesh_edit_action()
            except:
                lx.out(traceback.print_exc())
                break

            if self.mesh_edit_flags and not read_only:
                layer_scan.SetMeshChange(n, reduce(ior, self.mesh_edit_flags))

        layer_scan.Apply()
示例#4
0
def getPlanarPolys(poly_indices,threshold):
    poly_areas = []
    poly_normals = []
    for poly in poly_indices:
        poly_verts_pos = []
        poly_normal = lx.eval("query layerservice poly.normal ? " + str(poly))
        poly_normals.append(poly_normal)
        poly_verts = lx.eval("query layerservice poly.vertList ? " + str(poly))
        for vert in poly_verts:
            poly_verts_pos.append(lx.eval("query layerservice vert.pos ? " + str(vert)))
        try:
            poly_areas.append(modomath.area3D_Polygon(poly_verts_pos, poly_normal))
        except:
            lx.out("Bad polygon detected")
            lx.out("Polygon index: " + poly)
            poly_areas.append(0)
    planar_normals_set = [poly_normals[0]]
    planar_poly_set = [[poly_indices[0]]]
    planar_area_set = [poly_areas[0]]
    for x in (range(1,len(poly_indices))):
        new_poly = True
        for y in (range(len(planar_normals_set))):
            # lx.out(str(planar_normals_set[y]) + " " + str(poly_indices[x]) + " " + str(math.degrees(vecAngle(poly_normals[x],planar_normals_set[y]))))
            if modomath.vecAngle(poly_normals[x],planar_normals_set[y]) < threshold:
                planar_poly_set[y].append(poly_indices[x])
                planar_area_set[y] = planar_area_set[y] + poly_areas[x]
                new_poly = False
                break
        if new_poly:
            planar_poly_set.append   ([poly_indices[x]])
            planar_normals_set.append(poly_normals[x])
            planar_area_set.append   (poly_areas[x])     
    return planar_poly_set, planar_normals_set, planar_area_set
示例#5
0
def animationExtract(startLine, endLine, keyarray, valuearray):
	global content
	''' Expecting a structure in content list like :
		Channel 0
		{ Envelope
		  2
		  Key -2 0 0 0 0 0 0 0 0
		  Key -4 0.033333333333333332871 0 0 0 0 -1.9834710743801653443 0 0
		  Behaviors 1 1
		}

		startLine should be { Envelope
		endLine should be }
	'''
	if (content[startLine] != '{ Envelope'):
		reportError('Start line not matched')
	if (content[endLine] != '}'):
		reportError('End line not matched')
	numberOfKeys = int(content[startLine + 1])
	lx.out('Found %d keys' % numberOfKeys)
	lineCounter = startLine + 2
	for i in range(numberOfKeys):
		tempLine = content[lineCounter]
		if(tempLine.startswith('  Key')):
			lineArray = content[lineCounter].split(' ')
			keyarray.append(lineArray[4])
			valuearray.append(lineArray[3])
			lx.out('Key %d : %s at time %s' % (i, lineArray[3], lineArray[4]))
		else:
			reportError('Key line not found')
		lineCounter += 1
    def ui_buildFileTypeFilterMenu(self):
        '''
        Build and display the filetype filters menu.
        This menu will stay open until you click off of it.
        '''
        # create a new menu
        self.ui.filtersMenu = QMenu()

        # inherit the stylesheet from main ui
        self.ui.filtersMenu.setStyleSheet(self.styleSheet())

        # set up the menu's event filter and action
        self.ui.evFilter = StickyMenu()
        self.ui.filtersMenu.installEventFilter(self.ui.evFilter)
        self.ui.filtersMenu.aboutToHide.connect(self.ui_closeFileTypeFilterMenu)

        # load prevous selection if possible
        data = False
        if os.path.exists(FILTERSPATH):
            try:
                data = pickle.load(open(FILTERSPATH, 'r'))
            except IOError:
                lx.out('PROJECT MANAGER: Unable to apply previous filters. Data incorrectly serialized.')

        # populate the list of filetype options
        fileTypes = self.ui_getFileTypes()
        for i in sorted(fileTypes):
            action = self.ui.filtersMenu.addAction(i)
            action.setCheckable(True)
            if data:
                if i in data:
                    action.setChecked(True)

        # apply the menu to the button
        self.ui.filtersBtn.setMenu(self.ui.filtersMenu)
def getItemTags(item_type='all', selection=None):
    '''Find item tags in scene created from the MARI Tool Kit. Default: all items are searched. A selection can also be given
    Returns {item.id{tagType:tag,}}'''
    # {item.id:{ENTITY:name,UDIM:1001,CHANNEL:diffuse}}
    data = {}
    if selection:
        lx.out('selection: ',selection)
        if isinstance(selection, str) == True:
            selection = [selection]
        for i in selection:            
            sceneservice.select('item.id', str(i))
            itemID = sceneservice.query('item.id')
            try:
                itemTagTypes = sceneservice.queryN('item.tagTypes')
                itemTags = sceneservice.queryN('item.tags')
                if '$MTK' in itemTagTypes:
                    data[itemID] = dict(zip(itemTagTypes, itemTags))
            except:
                pass

    else:
        sceneservice.select('item.N', 'all')
        item_num = sceneservice.query('item.N')
        for item in xrange(item_num):
            sceneservice.select('item.id', str(item))
            itemID = sceneservice.query('item.id')
            if sceneservice.query('item.type') == item_type or item_type == 'all':
                try:
                    itemTagTypes = sceneservice.queryN('item.tagTypes')
                    itemTags = sceneservice.queryN('item.tags')
                    if '$MTK' in itemTagTypes:
                        data[itemID] = dict(zip(itemTagTypes, itemTags))
                except:
                    pass
    return data
def restoreSelection(listSelections):
    """
    Used together with:

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

    to save and later restore a selection in modo with

    bd_utils.restoreSelection(save_selection)

    """

    try:
        # lx.out(listSelections)
        first = True
        for x in listSelections:
            lx.out("Restoring Selection: " + x)
            if first:
                lx.eval("select.item {%s} set" % x)
            else:
                lx.eval("select.item {%s} add" % x)
            first = False

    except:
        lx.eval('layout.createOrClose EventLog "Event Log_layout" '
                'title:@macros.layouts@EventLog@ width:600 height:600 persistent:true '
                'open:true')
        lx.out("ERROR restoreSelection failed with ", sys.exc_info())
        return None
def restoreSelection(listSelections):
    """
    Used together with:

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

    to save and later restore a selection in modo with

    bd_helpers.restoreSelection(save_selection)

    """

    try:
        # lx.out(listSelections)
        first = True
        for x in listSelections:
            if first:
                lx.eval("select.item {%s} set" % x)
            else:
                lx.eval("select.item {%s} add" % x)
            first = False
        print('Restored selection!')

    except:
        lx.eval(
            'layout.createOrClose EventLog "Event Log_layout" '
            'title:@macros.layouts@EventLog@ width:600 height:600 persistent:true '
            'open:true')
        lx.out("ERROR restoreSelection failed with ", sys.exc_info())
        return None
    def basic_Execute(self, msg, flags):
        try:
            scn = modo.Scene()
            currScn = modo.scene.current()

            userSelection = scn.selected
            userSelectionCount = len(userSelection)

            currPath = currScn.filename

            if currPath is None:
                currPath = ""

            fbxExportType = lx.eval1('user.value sceneio.fbx.save.exportType ?')
            fbxTriangulate = False

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

            upAxis = lx.eval('pref.value units.upAxis ?')
            iUpAxis = upAxis

            userValues = self.query_User_Values()

            tbe = TilaBacthExport

            tbe.process_items(tbe(userSelection, userSelectionCount, scn, currScn, currPath, scnIndex, upAxis, iUpAxis, fbxExportType, fbxTriangulate, self.dyna_Bool(0), self.dyna_Bool(1), bool(userValues[2]), bool(userValues[3]), bool(userValues[4]), bool(userValues[5]), bool(userValues[6]), bool(userValues[7]), bool(userValues[8]), bool(userValues[9]), bool(userValues[10]), bool(userValues[11]), bool(userValues[12]), bool(userValues[13]), bool(userValues[14]), userValues[15], userValues[16], userValues[17], userValues[18], userValues[19], userValues[20], userValues[21], userValues[22], userValues[23], bool(userValues[24]), userValues[25], bool(userValues[26]), userValues[27], bool(userValues[28]), bool(userValues[29]), bool(userValues[30]), bool(userValues[31]), bool(userValues[32]), bool(userValues[33]), bool(userValues[34]), bool(userValues[35]), bool(userValues[36]), bool(userValues[37]), bool(userValues[38]), userValues[39], bool(userValues[40]), bool(userValues[41]), userValues[42]))
        except:
            lx.out(traceback.format_exc())
示例#11
0
def register_plugins():
    # Register accompanying plugins
    package_path = os.path.dirname(pyblish_modo.__file__)
    plugin_path = os.path.join(package_path, 'plugins')

    pyblish.api.register_plugin_path(plugin_path)
    lx.out("Registered %s" % plugin_path)
	def basic_Execute(self, msg, flags):
		try:
			if self.scn != modo.Scene():
				self.scn = modo.Scene()

			if self.dyna_IsSet(0):
				self.morphTarget = self.dyna_String(0)
			
			if self.dyna_IsSet(1):
				self.morphAmount = self.dyna_Float(1)

			self.initialSelection = self.scn.selectedByType('mesh')

			if len(self.initialSelection)<1:
				result = self.init_message('yesNo','No mesh selected', 'No mesh selected. \n Do you want to proceed to all mesh items in the scene ?')
				if result:
					self.initialSelection = self.scn.items('mesh')
				else:
					self.init_message('info', 'Aborded', 'Operation aborded by the user')
					return

			self.morphMapName = self.getSelectedMorphMap()

			if self.morphMapName is None:
				self.printLog('No morphMap selected')
				self.init_message('info', 'No Morph Map selected', 'Select one morph map')
				return

			self.applyMorphMap(self.morphMapName)
		except:
			lx.out(traceback.format_exc())
    def basic_Execute(self, msg, flags):
        reload(t)
        reload(batch_export)
        try:
            scn = modo.Scene()
            currScn = modo.scene.current()

            userSelection = scn.selected
            userSelectionCount = len(userSelection)

            currPath = currScn.filename

            if currPath is None:
                currPath = ""

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

            userValues = user_value.query_User_Values(self, t.kit_prefix)

            tbe = batch_export.TilaBacthExport

            userValues[1] = True

            if userValues[3]:
                tbe.batch_folder(
                    tbe(userSelection, userSelectionCount, scn, currScn,
                        currPath, scnIndex, userValues))
            elif userValues[2]:
                tbe.batch_files(
                    tbe(userSelection, userSelectionCount, scn, currScn,
                        currPath, scnIndex, userValues))
        except:
            lx.out(traceback.format_exc())
	def basic_Execute(self, msg, flags):
		try:

			compatible_selection = self.get_compatible_type(self.scn.selected)

			if not len(compatible_selection):  # Is any RenderPassGroup selected
				message = 'please select at least one item of type :'
				for c in compatible_type.itervalues():
					message += '\n{}'.format(c)
				modo.dialogs.alert('No compatible item selected', message)
				sys.exit()

			else:
				# Loop over all selected RenderPassGroup
				for grp in compatible_selection:
					if grp.type == compatible_type['RENDER']:
						self.duplicateRenderPassGroup(grp)

					elif grp.type == compatible_type['PRESET']:
						self.duplicatePresetGroup(grp)

					elif grp.type == compatible_type['CHANSET']:
						self.duplicateChannelGroup(grp)

					else:
						self.duplicateGroup(grp)

					self.deselectAllGroups()

		except:
			lx.out(traceback.format_exc())
示例#15
0
    def cmd_Execute(self,flags):
        # in the execute method we're going to store the current value of our
        # attribute so that it can be retrieved by the query method later. There's
        # no way to permanently store this information inside the command class
        # itself as the command is created & destroyed between each use. Normally
        # we'd want to be using persistent storage but for simplicity in this
        # example we'll use a UserValue.
        if self.dyna_IsSet(0):
            if self.dyna_String(0) == NEW:
                lx.eval('@modder.newSnippet.py')
            elif self.dyna_String(0) == DIV:
                pass
            elif self.dyna_IsSet(1) and self.dyna_String(1) == 'scripteditor':

                if modder.scripteditor.exists():
                    modder.scripteditor.clear_output()

                    path = join(modder.path.expand_alias('kit_MODDER:'),'assets','snippets',self.dyna_String(0))
                    modder.scripteditor.append_output('loading %s' % path)

                    try:

                        with open(path, 'r') as script_file:
                            modder.scripteditor.insert_script(re.sub('^#.*python\n*','',script_file.read()))

                    except:
                        modder.scripteditor.append_output('File could not be opened.')

                else:
                    lx.out('No script editor available.')

            else:
                lx.eval('file.open {kit_MODDER:assets/snippets/%s}' % self.dyna_String(0))
def update_render_output(renderoutput):
    """
        Updates the Render Output path to work on Azure or OS X depending on
        the OS we are on.
    """
    try:
        lx.eval(r"select.Item %s" % renderoutput)
        oldpath = lx.eval("item.channel renderOutput$filename ?")

        if oldpath is not None:
            lx.out(renderoutput + " has a set output path: " + oldpath)
            newpath = format_filename(oldpath)
            lx.out("Turned output path it into " + osType + " Path: " + newpath)
            if oldpath is not newpath:
                lx.eval(r'item.channel renderOutput$filename "%s"' % newpath)

                # MakePath
                bd_utils.makes_path(newpath)

            else:
                lx.out("Old and new path are identical. No change necessary.")

        elif oldpath is None:
            lx.out(str(renderoutput) + " has no active filename. Not touching anything.")

    except:
        bd_utils.restoreSelection(save_selection)
        lx.eval('layout.createOrClose EventLog "Event Log_layout" '
                'title:@macros.layouts@EventLog@ width:600 height:600 persistent:true')
        lx.out("ERROR Command updateRenderOutput failed with ", sys.exc_info())
        return None
def prepareLocatorList():
    global fslocator_IDList
    global fslocator_NameList
    locatorNames = []
    locatorIDs = []
    lx.out('Prepping locator list')
    numberOfSceneItems = lx.eval('query sceneservice item.N ?')
    monitor = lx.Monitor(numberOfSceneItems)
    for i in range(numberOfSceneItems):
        type = lx.eval('query sceneservice item.type ? %s' % i)
        if (type == "locator"):
            locatorIDs.append(lx.eval('query sceneservice item.id ? %s' % i))
            locatorNames.append(
                lx.eval('query sceneservice item.name ? %s' % i))
        monitor.step()
    monitor = lx.Monitor(len(locatorIDs))
    for index in range(len(locatorIDs)):
        myParentID = lx.eval('query sceneservice item.parent ? {%s}' %
                             locatorIDs[index])
        if (myParentID != None):
            myParentName = lx.eval('query sceneservice item.name ? {%s}' %
                                   myParentID)
            if (myParentName == "Blendshapes"):
                fslocator_IDList.append(
                    lx.eval('query sceneservice item.id ? {%s}' %
                            locatorIDs[index]))
                fslocator_NameList.append(
                    lx.eval('query sceneservice item.name ? {%s}' %
                            locatorNames[index]))
        monitor.step()
def parseTarget(targetFile):
	global fsMorphs
	global assetMorphs
	with open(targetFile) as f:
		content = f.read().splitlines()
	# Let's find the beginning of our relationship definition section.
	line = 0
	while (not content[line].startswith('bs')):
		if (line == len(content)):
			# Didn't find anything, we'll exit
			lx.out('Could not find data in file!')
			sys.exit()
		line += 1
	# OK, we found something.
	# Each line now should be of the form : bs = EyeSquint_R = Victoria4_unwelded_blendShape.head.PHMEyeSquintR = 2
	monitor = lx.Monitor( len(content) )
	monitor.step()
	while (line < len(content)):
		tempArray = content[line].split(' = ')
		faceShiftMorph = tempArray[1]
		myAssetMorph = tempArray[2]
		# take our *_blendShape. off the front.
		myAssetMorph = myAssetMorph[(myAssetMorph.index('.') + 1):]
		# OK. We can't use dictionaries here because each morph can appear more than once. So we use a pair of matched arrays
		fsMorphs.append(faceShiftMorph)
		assetMorphs.append(myAssetMorph)
		line += 1
		monitor.step()

	for item in range(len(fsMorphs)):
		lx.out("fsmorph {%s} matched to assetmorph {%s}" % (fsMorphs[item], assetMorphs[item]))
示例#19
0
 def basic_Execute(self, msg, flags):
     command = self.dyna_String(0)
     try:
         exec command in SHOTGUN_LOCALS, SHOTGUN_LOCALS
     except:
         lx.out('SHOTGUN ERROR : {0} {1} {2}'.format(command, msg,flags))
         raise
def get_ids(itemtype):
    """
    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
    type or if there's an error. Error printed is to Event log.
    type - the type of item to be returned (mesh, camera etc)
    """
    try:
        itemlist = []
        numitems = lx.eval('!!query sceneservice ' + itemtype + '.N ?')
        if numitems == 0:
            return None
        else:
            for x in xrange(numitems):
                itemlist.append(
                    lx.eval('query sceneservice ' + itemtype + '.ID ? %s' % x))
            lx.out("Found " + str(numitems) + " " + itemtype + "s: " + ", ".join(
                itemlist))
            return itemlist
    except:
        lx.eval('layout.createOrClose EventLog "Event Log_layout" '
                'title:@macros.layouts@EventLog@ width:600 height:600 persistent:true '
                'open:true')
        lx.out("ERROR get_ids(" + itemtype + ") failed with ", sys.exc_info())
        return None
示例#21
0
 def selevent_Add(self, type, subtType):
     SceneService = lx.service.Scene()
     type_id = SceneService.ItemTypeSuper(subtType)
     if modo.constants.LIGHT_TYPE == type_id:
         scene = modo.Scene()
         selected = scene.selectedByType(subtType)[0]
         lx.out('Selected Light: %s' % selected.id)
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)
def makes_path(pathFile, createFolder):
    if (createFolder == 1):
        lx.out("CREATE FOLDER: " + pathFile)
        try:
            os.makedirs(pathFile)
        except:
            lx.out("Alredy exist :" + pathFile)
示例#24
0
    def onFrame(self, values):
        #called on each frame

        try:
            if self.frameMode == "AdaptToBVH" or self.frameMode == "UseSceneFrameRate":
                lx.eval("select.time [%s f] [0] [0]" % self.currentframe)
            else:
                lx.eval("select.time %s" % self.currentTime)

            #lx.out("Frame: %s, Time: %s" % (self.currentframe,self.currentTime))

            self.applyMotion(self.root, values)
            self.currentframe += 1
            self.currentTime += self.dt

            monitor.step()

        except:
            lx.out("User Aborted")
            if self.frameMode == "AdaptToBVH" or self.frameMode == "UseSceneFrameRate":
                lx.eval("time.range current out:[%s f] [0] [0]" %
                        self.currentframe)
            else:
                lx.eval("time.range current out:%s" %
                        (self.dt * self.currentframe))
            sys.exit()
示例#25
0
def layerserviceRef():

    text = '<html>\n<body>\n'
    text += '<head><link rel="stylesheet" type="text/css" href="reset.css"><link rel="stylesheet" type="text/css" href="style.css"></head>'

    attributesArray = lx.eval('query layerservice "" ?')

    text += '<h1>layerservice (**depricated**):</h1>\n\n'
    text += '<p><em>query layerservice "" ?</em></p>'

    text += '<ul>\n'
    for attribute in attributesArray:
        text += '<li>'+attribute+'</li>\n'
    text += '</ul>\n'

    text += '</body>\n</html>'
            
    kit_path  = lx.eval("query platformservice alias ? {kit_KOMODO:}")
    f = open(os.path.join(kit_path,'html','layerservice.html'),'w')
    fpath = os.path.abspath(f.name)
    
    try:
        f.write(text)
        lx.out('saved to %s' % fpath)
    except:
        lx.out('could not save to %s' % fpath)
示例#26
0
    def basic_Execute(self, msg, flags):
        try:
            scene = modo.Scene()
            clipboard = QtGui.QClipboard()                                  # The QtGui.QClipboard gives you access
                                                                            # to your operating system's Copy/Paste Clipboard

            text = None

            if len(scene.selected) == 0:                                    # If you have nothing selected, don't do anything
                pass

            elif len(scene.selected) == 1:                                  # If you have a single item selected
                text = scene.selected[0].name                               # set text to that item's name

            elif len(scene.selected) > 1:                                   # If you have more than one item selected
                selItemsAsNames = [item.name for item in scene.selected]    # Create a list and grab just the names

                                                                            # This join command allows you to take a list
                text = ', '.join(selItemsAsNames)                           # and turn it in to a single long string.
                                                                            # Very useful for displaying lists in a non-python way


            if text is not None:                                            # Only the above elifs were accessed, will this be true
                clipboard.setText(text)
                lx.out('Text copied to clipboard: %s' %(text))

        except Exception as e:
            lx.out(e)
def parseTarget(targetFile):
    global fsMorphs
    global assetMorphs
    with open(targetFile) as f:
        content = f.read().splitlines()
    # Let's find the beginning of our relationship definition section.
    line = 0
    while (not content[line].startswith('bs')):
        if (line == len(content)):
            # Didn't find anything, we'll exit
            lx.out('Could not find data in file!')
            sys.exit()
        line += 1
    # OK, we found something.
    # Each line now should be of the form : bs = EyeSquint_R = Victoria4_unwelded_blendShape.head.PHMEyeSquintR = 2
    monitor = lx.Monitor(len(content))
    monitor.step()
    while (line < len(content)):
        tempArray = content[line].split(' = ')
        faceShiftMorph = tempArray[1]
        myAssetMorph = tempArray[2]
        # take our *_blendShape. off the front.
        myAssetMorph = myAssetMorph[(myAssetMorph.index('.') + 1):]
        # OK. We can't use dictionaries here because each morph can appear more than once. So we use a pair of matched arrays
        fsMorphs.append(faceShiftMorph)
        assetMorphs.append(myAssetMorph)
        line += 1
        monitor.step()

    for item in range(len(fsMorphs)):
        lx.out("fsmorph {%s} matched to assetmorph {%s}" %
               (fsMorphs[item], assetMorphs[item]))
def makes_path(pathFile,createFolder):
    if (createFolder ==1):
        lx.out("CREATE FOLDER: "+pathFile)
        try:
            os.makedirs(pathFile)                   
        except:
            lx.out("Alredy exist :"+pathFile)
    def basic_Execute(self, msg, flags):
        jobId = lx.eval('deadlineDBR.jobID ?')

        servers = CallDeadlineCommand(
            ["GetMachinesRenderingJob", jobId, "false"])
        servers = servers.splitlines()

        lx.out("Completing ModoDBR job: %s" % jobId)
        CallDeadlineCommand(["CompleteJob", jobId])

        if not lx.eval('user.value deadlineDBRrenderVRay ?'):
            # Disables slaves we used as there is no way to go through the list to disable all
            try:
                for server in servers:
                    lx.eval('hostlist.enable false {%s}' % server)
            except:
                pass

        lx.eval('deadlineDBR.jobID {}')
        lx.eval('deadlineDBR.jobStatus {}')
        lx.eval('deadlineDBR.activeServers {}')
        lx.eval('user.value deadlineDBRAreServersReserved false')

        notifier = DeadlineDBRUINotifier()
        notifier.Notify(lx.symbol.fCMDNOTIFY_VALUE
                        | lx.symbol.fCMDNOTIFY_DISABLE)
示例#30
0
 def basic_Execute(self, msg, flags):
     command = self.dyna_String(0)
     #print 1/0
     try:
         lx.out('SHOTGUN Startup '+ command)
     except:
         lx.out('SHOTGUN ERROR : {0} {1} {2}'.format(command, msg,flags))
         raise
def filterClips(clipID, clip_size= 'w:8'):
    '''Delete a clip which has a given pixel size'''
    layerservice.select('clip.N', 'all')
    for num in xrange(layerservice.query('clip.N')):
        layerservice.select('clip.id', str(num))
        if clipID == layerservice.query('clip.id') and clip_size in layerservice.query('clip.info').split(' '):
            lx.eval('clip.delete')
            lx.out('8x8 clip deleted:', clipID)
示例#32
0
def set_range_from_clip(renderItem):
    clip = get_backdrop(scene.renderCamera)
    if clip:
        scene.sceneRange = clip['range']
        scene.currentRange = clip['range']
        lx.out('frame range: %s - %s' % clip['range'])
        renderItem.channel(lx.symbol.sICHAN_POLYRENDER_FIRST).set(clip['range'][0])
        renderItem.channel(lx.symbol.sICHAN_POLYRENDER_LAST).set(clip['range'][1])
示例#33
0
    def basic_Execute(self, msg, flags):
        for n, argument in enumerate(self.commander_arguments()):
            self._commander_default_values[n] = self.commander_arg_value(n)

        try:
            self.commander_execute(msg, flags)
        except:
            lx.out(traceback.format_exc())
示例#34
0
 def basic_Execute(self, msg, flags):
     command = self.dyna_String(0)
     try:
         exec command in SHOTGUN_LOCALS, SHOTGUN_LOCALS
     except:
         lx.out('SHOTGUN ERROR : {0} {1} {2}'.format(
             command, msg, flags))
         raise
示例#35
0
def runUnitTest():
    moc_stdout = StringIO()
    runner = unittest.TextTestRunner(moc_stdout)
    suite = loader.loadTestsFromTestCase(TestMacroCommand)
    runner.run(suite)
    suite = loader.loadTestsFromTestCase(ParserTest)
    runner.run(suite)
    lx.out(moc_stdout.getvalue())
示例#36
0
def validatePath(path):
	global originalPathList
	global replacementPathList
	global contentDir_LW

	lx.out(path)
	validPath = os.path.isfile(contentDir_LW + os.sep + path)
	if (validPath == True):
		return(contentDir_LW + os.sep + path)
	else:
		# Mac LW can be very annoying. Let's see if we have such a case here.
		colonIndex = path.index(':')
		if (colonIndex > 2): # Mac does VolumeName:myDir/myFile.lwo, so the corresponding file would be /Volumes/VolumeName/myDir/myFile.lwo
			testPath = '/Volumes/' + string.replace(path,':','/',1)
			validPath = os.path.isfile(testPath)
		if (validPath == True):
			return testPath

		lastPathSep = path.rfind('\\')
		if (lastPathSep == -1): # Not found
			lastPathSep = path.rfind('/')

		separator = path[lastPathSep]
		workingReplacement = False

		# Let's check whether we have encountered this path before and have a potential replacement.
		try:
			# We can have more than one replacement path for a given original path. We'll need to check all cases as appropriate.
			# We look for each matching instance for the original path and then populate a replacement path temporary array for use later.
			rpTempArray = []
			for entry in range(len(originalPathList)):
				if (originalPathList[entry] == path[:lastPathSep]):
					rpTempArray.append(replacementPathList[entry])

			# Walk our replacement path temporary array to see if any instance delivers a valid path to our asset
			for entry in range(len(rpTempArray)):
				newPath = rpTempArray[entry] + os.sep + path[lastPathSep+1:]
				# Let's see if this is actually a valid file
				workingReplacement = os.path.isfile(newPath)
				if(workingReplacement == True):
					break
		except:
			pass

		if (workingReplacement == False):
			brokenObject = path[lastPathSep + 1:]
			replacementFileString = "Locate " + brokenObject
			newPath = customfile('fileOpen', replacementFileString, 'lwo', 'LWO', '*.lwo', contentDir_LW)
			if (newPath == None):
				reportError("Aborting since replacement path not defined")
				sys.exit()

			# First time encountering this path. Let's store it and the replacement in case we hit this again and can handle it cleanly.
			originalPathList.append(path[:lastPathSep])
			lastPathSep = newPath.rfind(os.sep)
			replacementPathList.append(newPath[:lastPathSep]) 

		return newPath
    def noti_RemoveClient(self, event):
        serversReserved = lx.eval('user.value deadlineDBRAreServersReserved ?')
        jobId = CheckEmptyString('deadlineDBRJobID')
        if serversReserved and jobId != "":
            lx.out('Submit To Deadline window closed, completing job: %s' %
                   jobId)
            CallDeadlineCommand(["CompleteJob", jobId])

        del self.masterList[event.__peekobj__()]
def set_gamma(value):
    """Set gamma with given value for selected images."""
    sceneservice.select('selection', 'imageMap')
    selection = sceneservice.queryN('selection')
    if selection:
        for i in selection:
            lx.eval("item.channel imageMap$gamma %s" %value)
    else:
        lx.out("MARI ToolKit: nothing selected")
示例#39
0
 def write(self, content_to_write):
     '''
     '''
     if content_to_write and content_to_write != '\n':
         if (content_to_write.startswith('Moopy Log') or
             content_to_write.startswith('Moopy Script Log')):
             lx.out(content_to_write)
         else:
             lx.out('Moopy Print: %s' % content_to_write)
示例#40
0
def get_backdrop(camera):
    for clip in scene.items(itype = lx.symbol.sITYPE_VIDEOSEQUENCE):
        for cam in clip.itemGraph('shadeLoc').reverse():
            if cam == camera:
                lx.out('Camera: %s' % cam.name)
                file_path = clip.channel('pattern').get()
                first_fame = clip.channel(lx.symbol.sICHAN_VIDEOSEQUENCE_FIRSTFRAME).get()
                last_frame = clip.channel(lx.symbol.sICHAN_VIDEOSEQUENCE_LASTFRAME).get()        
                return {'range':(first_fame, last_frame), 'filePath':file_path, 'clipObj':clip}
示例#41
0
 def sil_ItemRemove(self, item):
     
     # Bail out if there is no undo context. Must be checked
     if not LightListener.undoService.State() == lx.symbol.iUNDO_ACTIVE:
         return        
     
     item = lx.object.Item(item)
     if item.TestType(modo.constants.LIGHT_TYPE):
         lx.out('Deleted Light: ', item.Ident())        
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))
示例#43
0
 def basic_Execute(self, msg, flags):
     command = self.dyna_String(0)
     #print 1/0
     try:
         lx.out('SHOTGUN Startup ' + command)
     except:
         lx.out('SHOTGUN ERROR : {0} {1} {2}'.format(
             command, msg, flags))
         raise
示例#44
0
def debug(string):
    if not lx.eval('user.value mecco_tagger.debugMode ?'):
        return

    frame = _getframe(1)
    caller = frame.f_globals['__name__']
    line = frame.f_lineno

    lx.out('Tagger Debug: %s (%s, line %s)' % (string, caller, line))
示例#45
0
    def basic_Execute(self, msg, flags):
        reload(t)
        reload(batch_export)
        try:
            scn = modo.Scene()
            currScn = modo.scene.current()

            userSelection = scn.selected
            userSelectionCount = len(userSelection)
            olderSelection = []

            currPath = currScn.filename

            if currPath is None:
                currPath = ''

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

            userValues = user_value.query_User_Values(self, t.kit_prefix)

            tbe = batch_export.TilaBacthExport

            userValues[1] = True
            userValues[2] = False

            tbe.export_at_least_one_format(tbe(userSelection,
                                               userSelectionCount,
                                               scn,
                                               currScn,
                                               currPath,
                                               scnIndex,
                                               userValues))

            if bool(userValues[0]):
                olderSelection = userSelection
                userSelection = tbe.select_visible_items(tbe(userSelection,
                                                         userSelectionCount,
                                                         scn,
                                                         currScn,
                                                         currPath,
                                                         scnIndex,
                                                         userValues))
                userSelectionCount = len(userSelection)

            tbe.batch_export(tbe(userSelection,
                                 userSelectionCount,
                                 scn,
                                 currScn,
                                 currPath,
                                 scnIndex,
                                 userValues))

            if bool(userValues[0]):
                scn.select(olderSelection)

        except:
            lx.out(traceback.format_exc())
def linkMorphs(meshID):
    global assetMorphs
    global fsMorphs
    global morphInfluenceIDs
    global fslocator_IDList
    global fslocator_NameList

    # We need a list of locators that match our expectations for the faceShift imported dataset.
    # This populates our fslocator_IDList and fslocator_NameList lists
    prepareLocatorList()

    # Now we need the morph influences against our selected mesh item
    # This populates our morphInfluenceIDs list
    findMorphInfluences(meshID)

    # OK so we need by morph deformers and check that the associated  morph map property matches our faceShift-associated morph.
    monitor = lx.Monitor(len(morphInfluenceIDs))
    lx.out('Processing morph influences')
    for index in range(len(morphInfluenceIDs)):
        lx.out("Number of influences in total {%s}" % len(morphInfluenceIDs))
        morphID = morphInfluenceIDs[index]

        # We need to extract our map name from this deformer.
        lx.eval('select.deformer {%s} set' % morphID)
        morphMapName = lx.eval('item.channel mapName ? {%s}' % morphID)

        # So we have a valid deformer and the associated map.
        # Let's see if the morph map was used in faceShift
        # morphIndices will hold the position(s) of the map in the assetMorphs array.
        morphIndices = indices(assetMorphs, morphMapName)

        if (len(morphIndices) > 0):
            lx.out('morphs to process : {%d}' % len(morphIndices))
            for index in range(len(morphIndices)):
                # Retrieve the corresponding faceshift morph name
                fsMorphName = fsMorphs[morphIndices[index]]

                # Retrieve the locator ID from the matched array based on the name
                fsLink_Locator_ID = fslocator_IDList[fslocator_NameList.index(
                    fsMorphName)]
                # We need the xfrmScl locator for this locator.
                scl_xfrm_item = lx.eval(
                    'query sceneservice item.xfrmScl ? {%s}' %
                    fsLink_Locator_ID)

                # Select our driver channel first
                lx.out('Selecting locator {%s} channel scl.Z' % scl_xfrm_item)
                lx.eval('select.channel {%s:%s} set' %
                        (scl_xfrm_item, "scl.Z"))

                # Select our morph influence strength channel next.
                lx.out('Selecting morph {%s} channel strength' % morphID)
                lx.eval('select.channel {%s:%s} add' % (morphID, "strength"))

                # Link them together
                lx.eval('channel.link toggle')
        monitor.step()
示例#47
0
def start_meshlabserver_with_flags(app_path, flags):
    """Start Polygon Cruncher with a set of flags waits until it exits and report any failures"""
    try:
        process = subprocess.Popen(app_path + ' ' + flags)
        process.wait()
    except Exception, e:
        lx.out(
            "meshlabserver application launch failed check app path and try again!"
        )
        print e
示例#48
0
def main():
	global contentDir_LW
	lx.out("{%s %s} started" % (script_name, script_ver))
	contentDir_LW = lx.eval('pref.value lwio.lwoContentDir ?')
	lwsFile = customfile('fileOpen', 'Load LWS file', 'lws', 'LWS', '*.lws', contentDir_LW)
	if (lwsFile != None):
		preflightChecks()
		parser_main(lwsFile)
	else:
		sys.exit()
示例#49
0
def importLWO(path):
	lx.out(path)
	path = validatePath(path)
	# Load referenced LWO from scene file.
	try:
		lx.eval('scene.open {%s} import' % path)
	except:
		# File import failed. Add an empty mesh and move on.
		lx.eval('item.create mesh')
		lx.eval('item.name {%s}' % path)
 def cmd_Execute (self, flags):
     '''
         This function is called when the user executes the command. Either
         manually from the command line or from selecting an option in the list.
         You could do anything you want here, but for now, we'll simply read
         the value they selected and print it out to the event log.
     '''
     
     if self.dyna_IsSet (1):
         lx.out('Filename: %s' % self.dyna_String (1))
示例#51
0
def set_range_from_clip(renderItem):
    clip = get_backdrop(scene.renderCamera)
    if clip:
        scene.sceneRange = clip['range']
        scene.currentRange = clip['range']
        lx.out('frame range: %s - %s' % clip['range'])
        renderItem.channel(lx.symbol.sICHAN_POLYRENDER_FIRST).set(
            clip['range'][0])
        renderItem.channel(lx.symbol.sICHAN_POLYRENDER_LAST).set(
            clip['range'][1])
    def basic_Execute(self, msg, flags):

        cmd_string = self.dyna_String(0, "")
        log_path = self.dyna_String(1, "")

        lx.out(cmd_string)
        if log_path != "":
            with open(log_path, "a+") as log:
                log.write("{} - {}\r\n".format(
                    time.strftime("%Y-%m-%d %H:%M:%S"), cmd_string))
                log.close
    def vis_Evaluate(self):
        try:
            p1, p2 = self.edge.Endpoints()

            self.point.Select(p1)
            self.points.append(self.point.Pos())

            self.point.Select(p2)
            self.points.append(self.point.Pos())
        except:
            lx.out(traceback.format_exc())
示例#54
0
文件: baker.py 项目: vongoethe/baker
 def startBake(self):
     '''This kicks off the xNormal worker thread'''
     self.set_user_values()
     config_file = self.writeXML()
     # Try To Kick off the xNormal worker fail silently
     try:
         subprocess.Popen(
             str(self.xpath + ' ' + self.settings_file + '_bake'))
         return config_file
     except:
         lx.out("Bake Failed Please Check Settings and try again")
示例#55
0
def markJobAsFinished(renderJobId,success):
    #get job assigned to this node, there can only be one
    conn = sqlite3.connect(pathToDB)
    cur = conn.cursor()
    lx.out("Finishing assigned job: id %d" % renderJobId)
    if success:
        cur.execute('UPDATE renderJobs SET status="----finished----" WHERE id=%d' % renderJobId)
    else:
        cur.execute('UPDATE renderJobs SET status="****ERROR****" WHERE id=%d' % renderJobId)
    conn.commit()
    conn.close()
def setVisibilityItem(listItem, visibilty=0):
    """ rend visible ou invilible la liste des elements
    """
    try:
        for x in listItem:
            lx.eval("shader.setVisible %s %s" % (x, visibilty))

    except:
        #exc_log()
        lx.out("ERROR VISIBILITY")
        return None
示例#57
0
 def __init__(self, verts=None, polys=None):
     lx.out(verts)
     lx.out(polys)
     if not verts and polys:
         verts = getVertsFromPolys(polys)
     if not polys and verts:
         polys = getPolysFromVerts(verts)
         
     self.render_vert_indices = list(verts)
     self.render_poly_indices = list(polys)
     
     self.updateVecPos()