def commander_execute(self, msg, flags):
fromTagType = self.commander_arg_value(0)
toTagType = self.commander_arg_value(1)
fromTagType = tagger.convert_to_iPOLYTAG(fromTagType)
toTagType = tagger.convert_to_iPOLYTAG(toTagType)
mesh_editor = MeshEditorClass([fromTagType, toTagType],
[lx.symbol.f_MESHEDIT_POL_TAGS])
mesh_editor.do_mesh_edit()
notifier = tagger.Notifier()
notifier.Notify(lx.symbol.fCMDNOTIFY_DATATYPE)
def commander_execute(self, msg, flags):
tagType = self.commander_arg_value(0)
i_POLYTAG = tagger.convert_to_iPOLYTAG(tagType)
hitcount = 0
tagCounter = 0
for pTag in tagger.scene.all_tags_by_type(i_POLYTAG):
if not tagger.shadertree.get_masks(pTags={pTag: i_POLYTAG}):
mesh_editor = MeshEditorClass([tagType, pTag],
[lx.symbol.f_MESHEDIT_POL_TAGS])
mesh_editor.do_mesh_edit()
hitcount += mesh_editor.hitcount
tagCounter += 1
try:
modo.dialogs.alert(
tagger.DIALOGS_UNTAGGED_POLYS_COUNT[0],
tagger.DIALOGS_UNTAGGED_POLYS_COUNT[1] %
(tagCounter, hitcount))
except:
pass
notifier = tagger.Notifier()
notifier.Notify(lx.symbol.fCMDNOTIFY_DATATYPE)
def list_tags(self):
tagType = self.commander_arg_value(0, tagger.MATERIAL)
i_POLYTAG = tagger.convert_to_iPOLYTAG(tagType)
tags = tagger.scene.all_tags_by_type(i_POLYTAG)
return tags
def commander_execute(self, msg, flags):
del_empty = self.commander_arg_value(0)
del_unused = self.commander_arg_value(1)
hitlist = set()
for m in modo.Scene().iterItems(lx.symbol.sITYPE_MASK):
if not m.children() and del_empty:
hitlist.add(m)
if del_unused:
i_POLYTAG = tagger.convert_to_iPOLYTAG(
m.channel(lx.symbol.sICHAN_MASK_PTYP).get())
sICHAN_MASK_PTAG = m.channel(lx.symbol.sICHAN_MASK_PTAG).get()
if (sICHAN_MASK_PTAG and not tagger.items.get_layers_by_pTag(
sICHAN_MASK_PTAG, i_POLYTAG)):
hitlist.add(m)
tagger.safe_removeItems(hitlist, True)
try:
modo.dialogs.alert(
tagger.DIALOGS_CLEANED_UP_SHADERTREE[0],
tagger.DIALOGS_CLEANED_UP_SHADERTREE[1] % len(hitlist))
except:
pass
notifier = tagger.Notifier()
notifier.Notify(lx.symbol.fCMDNOTIFY_DATATYPE)
def commander_execute(self, msg, flags):
tagType = self.commander_arg_value(0, tagger.MATERIAL)
scope = self.commander_arg_value(1, tagger.SCOPE_SELECTED)
delete_unused = self.commander_arg_value(2, True)
i_POLYTAG = tagger.convert_to_iPOLYTAG(tagType)
pTags_to_remove = tagger.selection.get_ptags(i_POLYTAG)
# if we're just nixing tags in a selection, easy.
if scope in [tagger.SCOPE_SELECTED, tagger.SCOPE_CONNECTED, tagger.SCOPE_FLOOD]:
args = tagger.build_arg_string({
tagger.TAGTYPE: tagType,
tagger.TAG: "",
tagger.SCOPE: scope
})
lx.eval("!" + tagger.CMD_PTAG_SET + args)
# if we want to nix tags for the whole scene, do some work.
if scope == tagger.SCOPE_SCENE:
for pTag in pTags_to_remove:
lx.eval("%s %s %s {}" % (tagger.CMD_PTAG_REPLACE, tagType, pTag))
# see if we need to delete any masks in the shader tree
if not delete_unused:
return
mask_tags_to_destroy = set()
for pTag in pTags_to_remove:
if not tagger.scene.meshes_with_pTag(pTag, i_POLYTAG):
tagger.shadertree.seek_and_destroy(pTags={pTag:i_POLYTAG})
notifier = tagger.Notifier()
notifier.Notify(lx.symbol.fCMDNOTIFY_DATATYPE)
def list_tags(self):
tagType = self.commander_arg_value(0, tagger.MATERIAL)
i_POLYTAG = tagger.convert_to_iPOLYTAG(tagType)
tags = tagger.scene.all_tags_by_type(i_POLYTAG)
tags = [(tag, tag) for tag in tags]
tags = [(tagger.NEW_TAG, tagger.LABEL_NEW_TAG)] + tags
return tags
def commander_execute(self, msg, flags):
tagType = self.commander_arg_value(0)
tag = self.commander_arg_value(1)
connected = self.commander_arg_value(2, tagger.SCOPE_SELECTED)
i_POLYTAG = tagger.convert_to_iPOLYTAG(tagType)
mesh_editor = MeshEditorClass([i_POLYTAG, tag, connected],
[lx.symbol.f_MESHEDIT_POL_TAGS])
mesh_editor.do_mesh_edit()
tagger.scene.add_pTag_to_recent(tag, tagType)
notifier = tagger.Notifier()
notifier.Notify(lx.symbol.fCMDNOTIFY_DATATYPE)
def select_all_by_tag(tagType, tag):
i_POLYTAG = tagger.convert_to_iPOLYTAG(tagType)
tags = []
if tag:
tags = tag.split(";")
elif not tag:
tagStrings = tagger.selection.get_ptags(i_POLYTAG)
for tagString in tagStrings:
tags.extend(tagString.split(";"))
for tag in tags:
if tagType in ['material', 'part']:
lx.eval("select.polygon add %s face {%s}" % (tagType, tag))
elif tagType == 'pick':
lx.eval("select.useSet {%s} select" % tag)
def commander_execute(self, msg, flags):
tagType = self.commander_arg_value(0)
i_POLYTAG = tagger.convert_to_iPOLYTAG(tagType)
counter = 0
for pTag in tagger.scene.all_tags_by_type(i_POLYTAG):
if not tagger.shadertree.get_masks(pTags={pTag: i_POLYTAG}):
new_mask = tagger.shadertree.build_material(
i_POLYTAG=i_POLYTAG, pTag=pTag)
counter += 1
try:
modo.dialogs.alert(tagger.DIALOGS_MASKED_TAGS_COUNT[0],
tagger.DIALOGS_MASKED_TAGS_COUNT[1] % counter)
except:
pass
notifier = tagger.Notifier()
notifier.Notify(lx.symbol.fCMDNOTIFY_DATATYPE)
def mesh_edit_action(self):
global _island_enumerator
i_POLYTAG = tagger.convert_to_iPOLYTAG(self.args[tagger.TAGTYPE])
stringTag = lx.object.StringTag()
stringTag.set(self.polygon_accessor)
islands = self.get_selected_polys_by_island()
for i, island in enumerate(islands):
self.island_count += 1
_island_enumerator += 1
pTag = "_".join((self.args[tagger.TAG], str(_island_enumerator)))
new_mask = tagger.shadertree.build_material(i_POLYTAG = i_POLYTAG, pTag = pTag)
for poly in island:
self.polygon_accessor.Select(poly)
stringTag.Set(i_POLYTAG, pTag)
self.poly_count += 1
def mesh_edit_action(self):
tagType = self.args[0]
replaceTag = self.args[1]
i_POLYTAG = tagger.convert_to_iPOLYTAG(tagType)
hitlist = set()
stringTag = lx.object.StringTag()
stringTag.set(self.polygon_accessor)
nPolys = self.mesh.PolygonCount()
for eachPoly in xrange(nPolys):
self.polygon_accessor.SelectByIndex(eachPoly)
if tagType in [MATERIAL, PART]:
if stringTag.Get(i_POLYTAG) == replaceTag:
hitlist.add(eachPoly)
self.hitcount += 1
elif tagType == PICK:
if not stringTag.Get(i_POLYTAG):
continue
pickTags = set(stringTag.Get(i_POLYTAG).split(";"))
if replaceTag in pickTags:
hitlist.add(eachPoly)
self.hitcount += 1
for eachPoly in hitlist:
self.polygon_accessor.SelectByIndex(eachPoly)
if tagType in [MATERIAL, PART]:
stringTag.Set(i_POLYTAG, replaceTag)
elif tagType == PICK:
pickTags = set(stringTag.Get(i_POLYTAG).split(";"))
pickTags.discard(replaceTag)
stringTag.Set(i_POLYTAG, ";".join(pickTags))
def commander_execute(self, msg, flags):
tagType = self.commander_arg_value(0)
scope = self.commander_arg_value(1)
i_POLYTAG = tagger.convert_to_iPOLYTAG(tagType)
scope_label = tagger.LABEL_SCOPE_SELECTED_ITEMS if scope == tagger.SCOPE_SELECTED_ITEMS else tagger.LABEL_SCOPE_SCENE
try:
safety = modo.dialogs.yesNo(
tagger.DIALOGS_REMOVE_ALL_TAGS[0],
tagger.DIALOGS_REMOVE_ALL_TAGS[1] %
(tagType.title(), scope_label.lower()))
except:
safety = 'yes'
if safety == 'no':
return
poly_count = 0
tag_count = 0
if scope == tagger.SCOPE_SCENE:
lx.eval("select.drop item")
lx.eval("select.itemType mesh")
layer_svc = lx.service.Layer()
layer_scan = lx.object.LayerScan(
layer_svc.ScanAllocate(lx.symbol.f_LAYERSCAN_EDIT))
if not layer_scan.test():
return
mesh_svc = lx.service.Mesh()
mark_mode_valid = mesh_svc.ModeCompose(None, 'hide lock')
for n in xrange(layer_scan.Count()):
mesh = lx.object.Mesh(layer_scan.MeshEdit(n))
if not mesh.test():
continue
polygon_count = mesh.PolygonCount()
if polygon_count == 0:
continue
polygon_accessor = lx.object.Polygon(mesh.PolygonAccessor())
if not polygon_accessor.test():
continue
visitor = PolyTaggerClass(polygon_accessor, mark_mode_valid,
i_POLYTAG)
polygon_accessor.Enumerate(mark_mode_valid, visitor, 0)
layer_scan.SetMeshChange(n, lx.symbol.f_MESHEDIT_POL_TAGS)
if scope == tagger.SCOPE_SCENE:
lx.eval("select.drop item")
modo.Scene().meshes[0].select()
layer_scan.Apply()
notifier = tagger.Notifier()
notifier.Notify(lx.symbol.fCMDNOTIFY_DATATYPE)
def commander_execute(self, msg, flags):
pTag = self.commander_arg_value(0)
preset = self.commander_arg_value(1, tagger.RANDOM)
connected = self.commander_arg_value(2, tagger.SCOPE_FLOOD)
tagType = self.commander_arg_value(3, tagger.MATERIAL)
withExisting = self.commander_arg_value(4)
if preset == tagger.RANDOM:
preset = None
i_POLYTAG = tagger.convert_to_iPOLYTAG(tagType)
if not pTag:
if not preset:
pTag = tagger.DEFAULT_MATERIAL_NAME
elif not preset.endswith(".lxp"):
pTag = tagger.DEFAULT_MATERIAL_NAME
elif preset.endswith(".lxp"):
pTag = splitext(basename(preset))[0]
# find any existing masks for this pTag
existing_masks = tagger.shadertree.get_masks(pTags={pTag: i_POLYTAG})
# tag the polys
args = tagger.build_arg_string({
tagger.TAGTYPE: tagType,
tagger.TAG: pTag,
tagger.SCOPE: connected
})
lx.eval("!" + tagger.CMD_PTAG_SET + args)
# build a new mask if we need one
if not existing_masks:
new_mask = tagger.shadertree.build_material(i_POLYTAG=i_POLYTAG,
pTag=pTag,
preset=preset)
tagger.shadertree.move_to_base_shader(new_mask)
elif existing_masks and withExisting == tagger.USE:
pass
elif existing_masks and withExisting == tagger.KEEP:
new_mask = tagger.shadertree.build_material(i_POLYTAG=i_POLYTAG,
pTag=pTag,
preset=preset)
tagger.shadertree.move_to_base_shader(new_mask)
elif existing_masks and withExisting == tagger.REMOVE:
new_mask = tagger.shadertree.build_material(i_POLYTAG=i_POLYTAG,
pTag=pTag,
preset=preset)
tagger.shadertree.move_to_base_shader(new_mask)
tagger.safe_removeItems(existing_masks, True)
elif existing_masks and withExisting == tagger.CONSOLIDATE:
new_mask = tagger.shadertree.build_material(i_POLYTAG=i_POLYTAG,
pTag=pTag,
preset=preset)
tagger.shadertree.move_to_base_shader(new_mask)
consolidation_masks = tagger.shadertree.consolidate(
pTags={pTag: i_POLYTAG})
new_mask.setParent(consolidation_masks[pTag])
tagger.shadertree.move_to_top(new_mask)
notifier = tagger.Notifier()
notifier.Notify(lx.symbol.fCMDNOTIFY_DATATYPE)
