def commander_execute(self, msg, flags):
if not self.commander_arg_value(1):
return
tagType = self.commander_arg_value(0, tagger.MATERIAL)
tag = self.commander_arg_value(1)
connected = self.commander_arg_value(2)
if tag == tagger.NEW_TAG:
args = tagger.build_arg_string({
tagger.TAGTYPE: tagType,
tagger.SCOPE: connected
})
elif tag != tagger.NEW_TAG:
args = tagger.build_arg_string({
tagger.TAGTYPE: tagType,
tagger.TAG: tag,
tagger.SCOPE: connected
})
lx.eval(tagger.CMD_PTAG_SET + args)
notifier = tagger.Notifier()
notifier.Notify(lx.symbol.fCMDNOTIFY_DATATYPE)
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 paste(tagType=tagger.MATERIAL, connected=tagger.SCOPE_SELECTED):
global _clipboard
if not tagType:
tagType = tagger.MATERIAL
if not connected:
connected = tagger.SCOPE_SELECTED
args = {}
args[tagger.TAG] = _clipboard[tagType]
args[tagger.TAGTYPE] = tagType
args[tagger.SCOPE] = connected
if not args[tagger.TAG]:
try:
modo.dialogs.alert(
tagger.DIALOGS_NOTHING_TO_PASTE[0],
tagger.DIALOGS_NOTHING_TO_PASTE[1]
)
except:
pass
return
lx.eval("!" + tagger.CMD_PTAG_SET + tagger.build_arg_string(args))
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 commander_execute(self, msg, flags):
tagType = self.commander_arg_value(0)
replaceTag = self.commander_arg_value(1)
withTag = self.commander_arg_value(2)
ignoreCase = self.commander_arg_value(3)
regexp = self.commander_arg_value(4)
if not withTag:
withTag = None
hitcount = tagger.scene.replace_tag(tagType, replaceTag, withTag,
ignoreCase, regexp)
if hitcount == 0:
try:
modo.dialogs.alert(
tagger.DIALOGS_TAG_NOT_FOUND[0],
tagger.DIALOGS_TAG_NOT_FOUND[1] % (tagType, replaceTag))
except:
pass
elif hitcount >= 1:
try:
modo.dialogs.alert(
tagger.DIALOGS_TAG_REPLACED[0],
tagger.DIALOGS_TAG_REPLACED[1] %
(hitcount, tagType, replaceTag))
except:
pass
notifier = tagger.Notifier()
notifier.Notify(lx.symbol.fCMDNOTIFY_DATATYPE)
def commander_execute(self, msg, flags):
preset = self.commander_arg_value(0)
withExisting = self.commander_arg_value(1)
if preset == tagger.RANDOM:
preset = None
if not withExisting:
withExisting = tagger.KEEP
items = tagger.items.get_selected_and_maskable()
for item in items:
existing_masks = tagger.shadertree.get_masks(item)
if existing_masks and withExisting == 'use':
return
elif existing_masks and withExisting == 'remove':
tagger.shadertree.seek_and_destroy(item)
elif existing_masks and withExisting == 'consolidate':
tagger.shadertree.consolidate(item)
mask = tagger.shadertree.build_material(item, preset=preset)
tagger.shadertree.move_to_base_shader(mask)
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 commander_execute(self, msg, flags):
global _island_enumerator
args = self.commander_args()
_island_enumerator = 0
island_counter = IslandCounterClass(args, [lx.symbol.f_MESHEDIT_POL_TAGS])
island_counter.do_mesh_read()
if _island_enumerator > tagger.MAX_PTAG_ISLANDS:
try:
modo.dialogs.alert(
tagger.DIALOGS_TOO_MANY_ISLANDS[0],
tagger.DIALOGS_TOO_MANY_ISLANDS[1] % (tagger.MAX_PTAG_ISLANDS, _island_enumerator)
)
except:
pass
else:
_island_enumerator = 0
mesh_editor = MeshEditorClass(args, [lx.symbol.f_MESHEDIT_POL_TAGS])
mesh_editor.do_mesh_edit()
try:
modo.dialogs.alert(
tagger.DIALOGS_TAGGED_POLY_ISLANDS_COUNT[0],
tagger.DIALOGS_TAGGED_POLY_ISLANDS_COUNT[1] % (mesh_editor.poly_count, _island_enumerator)
)
except:
pass
notifier = tagger.Notifier()
notifier.Notify(lx.symbol.fCMDNOTIFY_DATATYPE)
def commander_execute(self, msg, flags):
connected = self.commander_arg_value(0, tagger.SCOPE_SELECTED)
masks = set()
for i in modo.Scene().selected:
if i.type == 'mask':
masks.add(i)
if len(masks) < 1:
try:
modo.dialogs.alert(tagger.DIALOGS_NO_MASK_SELECTED[0],
tagger.DIALOGS_NO_MASK_SELECTED[1])
except:
pass
return
if len(masks) > 1:
try:
modo.dialogs.alert(tagger.DIALOGS_TOO_MANY_MASKS[0],
tagger.DIALOGS_TOO_MANY_MASKS[1])
except:
pass
return
mask = list(masks)[0]
if not mask.channel(lx.symbol.sICHAN_MASK_PTAG).get():
try:
modo.dialogs.alert(tagger.DIALOGS_NO_PTAG_FILTER)
except:
pass
return
if mask.channel(lx.symbol.sICHAN_MASK_PTAG).get() == "(none)":
try:
modo.dialogs.alert(tagger.DIALOGS_NONE_PTAG_FILTER)
except:
pass
return
tagLabel = mask.channel(lx.symbol.sICHAN_MASK_PTYP).get()
tag = mask.channel(lx.symbol.sICHAN_MASK_PTAG).get()
args = tagger.build_arg_string({
tagger.TAGTYPE:
tagger.convert_to_tagType_string(tagLabel),
tagger.TAG:
tag,
tagger.SCOPE:
connected
})
lx.eval("!" + tagger.CMD_PTAG_SET + args)
notifier = tagger.Notifier()
notifier.Notify(lx.symbol.fCMDNOTIFY_DATATYPE)
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):
group_name = self.commander_arg_value(0)
preset = self.commander_arg_value(1, tagger.RANDOM)
preset = None if preset == tagger.RANDOM else preset
selmode = tagger.selection.get_mode()
group = tagger.items.group_selected_and_maskable(group_name)
mask = tagger.shadertree.build_material(group, preset=preset)
tagger.shadertree.move_to_base_shader(mask)
notifier = tagger.Notifier()
notifier.Notify(lx.symbol.fCMDNOTIFY_DATATYPE)
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 commander_execute(self, msg, flags):
if not self.commander_arg_value(1):
return
tagType = self.commander_arg_value(0, tagger.MATERIAL)
tag = self.commander_arg_value(1)
args = tagger.build_arg_string({
tagger.TAGTYPE: tagType,
tagger.TAG: tag
})
lx.eval(tagger.CMD_SELECT_ALL_BY_DIALOG + args)
notifier = tagger.Notifier()
notifier.Notify(lx.symbol.fCMDNOTIFY_DATATYPE)
def commander_execute(self, msg, flags):
if not self.commander_arg_value(0):
return
tag = self.commander_arg_value(0).split(tagger.TAGTYPE_SEP)
connected = self.commander_arg_value(1)
args = tagger.build_arg_string({
tagger.TAGTYPE: tag[0],
tagger.TAG: tag[1],
tagger.SCOPE: connected
})
lx.eval(tagger.CMD_PTAG_SET + args)
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)
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 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)
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):
items = tagger.items.get_selected_and_maskable()
tagger.shadertree.seek_and_destroy(items)
notifier = tagger.Notifier()
notifier.Notify(lx.symbol.fCMDNOTIFY_DATATYPE)
