def DelectNameSet(self):
setName = self.select_set_list_qcombobox.currentText()
deselectNodes = rt.getCurrentSelection()
rt.select(rt.selectionSets[setName])
rt.deselect(deselectNodes)
rt.selectionSets[setName] = rt.getCurrentSelection()
self.UpdateNameSet()
def animate_transform(thing):
'''Records an animation on the provided object'''
# select the object to animate so we will see the keyframes in the timeslider
rt.select(thing)
# animate
with mx.animate(True):
with mx.redraw(True):
with mx.attime(30):
thing.pos = rt.Point3(50, 0, 0)
with mx.attime(60):
thing.Pos = rt.Point3(100, 50, 0)
with mx.attime(90):
thing.Pos = rt.Point3(50, 100, 0)
with mx.attime(120):
thing.Pos = rt.Point3(0, 100, 0)
with mx.attime(150):
thing.Pos = rt.Point3(-50, 50, 0)
with mx.attime(180):
thing.Pos = rt.Point3(0, 0, 0)
def SelectNameSet(self):
name = self.select_set_list_qcombobox.currentText()
#print(name)
rt.clearSelection()
if not self.IsSelectSetNewName(name):
set_tiem = rt.selectionSets[name]
rt.select(set_tiem)
rt.redrawViews()
def splitLayersToFiles():
if (not qtUtils.popup_Yes_No(
"This operation could take some time....Are you sure?",
"Confirm")):
return
rootLayer = layer.getAllRootLayer()
for l in rootLayer:
nodes = layer.getAllNodeInLayerTree(l)
rt.select(nodes)
newFilePath = rt.maxFilePath + l.name
rt.saveNodes(nodes, newFilePath, quiet=True)
def selectMode(self, target_node):
if not rt.IsValidNode(self.m_biped_class.m_com):
return self.ReStart()
modifiers = QtWidgets.QApplication.keyboardModifiers()
if modifiers == QtCore.Qt.ControlModifier:
rt.selectMore(target_node)
elif modifiers == QtCore.Qt.AltModifier:
rt.deselect(target_node)
else:
rt.select(target_node)
rt.redrawViews()
def select(self, name='', index=0):
node = self.GetNode(name, index)
result = rt.IsValidNode(node)
modifiers = QtWidgets.QApplication.keyboardModifiers()
if node is not None and result:
if modifiers == QtCore.Qt.ControlModifier:
rt.selectMore(node)
elif modifiers == QtCore.Qt.AltModifier:
rt.deselect(node)
else:
rt.select(node)
rt.redrawViews()
return result
def select_nodes(max_nodes, add=False):
"""
Select given Max nodes
:param max_nodes: list<MaxPlus.INode>
:param add: bool, Whether to add given node names to an existing selection or not
"""
max_nodes = python.force_list(max_nodes)
sel = list() if not add else list(rt.selection)
for max_node in max_nodes:
max_node = node.get_pymxs_node(max_node)
sel.append(max_node)
if not sel:
return
rt.select(sel)
def _uvSnaps(self, assetName):
originalSelection = rt.execute("selection as array")
validShapes = rt.execute(
"for o in selection where superClassOf o == geometryClass collect o"
)
if len(validShapes) > 10:
msg = "There are %s objects for UV snapshots.\nAre you sure you want to include snapshots to the Asset?" % (
len(validShapes))
state = rt.queryBox(msg, title='Too many objects for UV Snapshot')
if state:
pass
else:
return
assetDirectory = os.path.join(self.directory, assetName)
UVdir = os.path.join(assetDirectory, "UV_snaps")
if not os.path.isdir(os.path.normpath(UVdir)):
os.makedirs(os.path.normpath(UVdir))
rt.execute("max modify mode")
for i in validShapes:
objName = i.name
UVpath = os.path.join(UVdir, '%s_uv.jpg' % objName)
rt.select(i)
defUnwrapMod = rt.Unwrap_UVW()
rt.addModifier(i, defUnwrapMod)
defUnwrapMod.setMapChannel = 1
defUnwrapMod.renderuv_fillmode = 0
defUnwrapMod.renderuv_seamColor = rt.Name("green")
defUnwrapMod.renderuv_showframebuffer = False
defUnwrapMod.renderuv_force2sided = False
defUnwrapMod.renderuv_fillColor = rt.Name("black")
defUnwrapMod.renderuv_showoverlap = False
defUnwrapMod.renderuv_overlapColor = rt.Name("red")
defUnwrapMod.renderuv_edgeColor = rt.Name("white")
defUnwrapMod.renderuv_visibleedges = True
defUnwrapMod.renderuv_invisibleedges = False
defUnwrapMod.renderuv_seamedges = False
defUnwrapMod.renderUV(UVpath)
rt.deleteModifier(i, defUnwrapMod)
rt.select(originalSelection)
def create_box_control(name, init_pos=None, length=10, width=10, height=10, color=None):
"""
Creates a box control
:param name: str
:param init_pos:
:param length:
:param width:
:param height:
:param color:
:return:
"""
pos = init_pos or [0, 0, 0]
if rt.classOf(pos) != rt.Point3:
pos = rt.Point3(*pos)
if color and rt.classOf(color) != rt.color:
color = rt.color(*color)
if not color:
color = rt.yellow
rt.setCommandPanelTaskMode(rt.Name('modify'))
base_box = rt.Box(
lengthsegs=1, widthsegs=1, heightsegs=1, length=length, width=width, height=height,
mapcoords=True, pos=pos, isSelected=True)
rt.select(base_box)
rt.convertTo(base_box, rt.PolyMeshObject)
rt.subobjectLevel = 2
edge_bitarray = rt.BitArray()
edge_indices = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]
edge_bitarray.count = len(edge_indices)
for i, index in enumerate(edge_indices):
edge_bitarray[i] = index
base_box.EditablePoly.SetSelection(rt.Name('Edge'), edge_bitarray)
ctrl_name = rt.uniquename(name)
base_box.EditablePoly.createShape(ctrl_name, False, base_box)
rt.subobjectLevel = 0
rt.delete(base_box)
box_ctrl = rt.getNodeByName(ctrl_name)
rt.convertTo(box_ctrl, rt.SplineShape)
box_ctrl.wirecolor = color
rt.CenterPivot(box_ctrl)
transform.reset_xform_and_collapse(box_ctrl, freeze=True)
return box_ctrl
def select_nodes_by_name(names, add=False):
"""
Selects nodes by name
:param names: list<str>, names of nodes to select
:param add: bool, Whether to add given node names to an existing selection or not
"""
names = python.force_list(names)
nodes = list() if not add else list(rt.selection)
for n in names:
node = get_node_by_name(n)
if node:
nodes.append(node)
# Clear selection if need it
if not add:
rt.clearSelection()
rt.select(nodes)
def createHelperBoneSystem():
sysOption = config.SystemOption()
regularMesh = rt.getNodeByName(sysOption.regularMeshName)
referenceMesh = rt.getNodeByName(sysOption.referenceMeshName)
primarySkinMod = 0
for i in range(0, len(regularMesh.Modifiers)):
if str(rt.classof(regularMesh.Modifiers[i])) == 'Skin':
regularMesh.Modifiers[i].name = 'Skin_Original'
primarySkinMod = regularMesh.Modifiers[i]
break
poseLearner = ln.PoseLearner(regularMesh, referenceMesh, primarySkinMod,
sysOption)
poseLearner.processStart()
# re-select the mesh to refresh the modifiers list displaying
rt.select(regularMesh)
def createHelperBoneSystem(self):
regularMesh = rt.getNodeByName('Regular')
referenceMesh = rt.getNodeByName('Reference')
primarySkinMod = 0
for i in range(0, len(regularMesh.Modifiers)):
if str(rt.classof(regularMesh.Modifiers[i])) == 'Skin':
regularMesh.Modifiers[i].name = "Skin_Backup"
primarySkinMod = regularMesh.Modifiers[i]
break
# primaryBoneNameList = ['Bip001 L Clavicle', 'Bip001 L UpperArm', 'Bip001 L Forearm']
primaryBoneNameList = ['Root']
poseLearner = ln.PoseLearner(regularMesh, referenceMesh, primarySkinMod, primaryBoneNameList, self.sysOption)
poseLearner.processStart()
# re-select the mesh to refresh the modifiers list displaying
rt.select(regularMesh)
def startTransfer(self):
mxs.execute("max create mode")
with pymxs.undo(True):
for i in self.skinMeshes:
skinSource = mxs.skinUtils.ExtractSkinData(i[0])
skinSource = mxs.getNodeByName("SkinData_{}".format(i[0].name))
count = mxs.skinOps.GetNumberBones(i[1])
newBones = []
for item in range(count):
# print(item +1, i[0].name, mxs.skinOps.GetBoneNode(i[1], item + 1))
try:
newBones.append(self.dict[mxs.skinOps.GetBoneNode(
i[1], item + 1)])
except:
pass
oldSkin = i[1]
oldSkin.enabled = False
skinMod = mxs.Skin()
skinMod.name = "Transfered Skin"
mxs.addModifier(i[0], skinMod, before=i[2] - 1)
for bone in newBones:
mxs.skinOps.addbone(skinMod, bone, 0)
mxs.select(i[0])
mxs.selectmore(skinSource)
mxs.skinUtils.ImportSkinDataNoDialog(True, False, False, False,
False, 1.0, 0)
mxs.delete(skinSource)
mxs.clearSelection()
mxs.execute("max modify mode")
def select_node(node, replace_selection=True, **kwargs):
"""
Selects given object in the current scene
:param replace_selection: bool
:param node: str
"""
node = node_utils.get_pymxs_node(node)
if replace_selection:
return rt.select(node)
else:
return rt.selectMore(node)
print each.name #get first selected firstItem = rt.selection[0] print firstItem.name #create simple object rt.sphere(radius=50, position=rt.point3(25, 25, 25), segments=8) #select all objects rt.select(rt.objects) # with MaxPlus MaxPlus.Core.GetRootNode().Children #clear selection rt.clearselection() rt.select(firstItem) print rt.firstItem.name
def recreate(self):
defaultSize = 2
bones = mxs.Array()
if len(self.result) > 0:
self.newNodes = []
self.dict = {}
temp = mxs.Array()
lastNode = None
index = 0
rootNode = mxs.BoneSys.createBone(mxs.point3(0, 0, 0),
mxs.point3(0, 1, 0),
mxs.point3(0, 1, 0))
rootNode.transform = mxs.Matrix3(1)
rootNode.size = 2
rootNode.name = "rootBone"
mxs.join(temp, rootNode)
def new_create_constraints(node, nNode):
posList = mxs.position_list() # Create Pos_List
const = mxs.Position_Constraint() # Create Pos_Constraint
const.appendTarget(nNode, 100) # Add target to Constraint
secsub = mxs.setPropertyController(node.controller, "Position",
posList) # Add PosList to node
mxs.setPropertyController(secsub, 'Available', const)
posList = mxs.rotation_list() # Create Pos_List
const = mxs.Orientation_Constraint() # Create Pos_Constraint
const.appendTarget(nNode, 100) # Add target to Constraint
secsub = mxs.setPropertyController(node.controller, "Rotation",
posList) # Add PosList to node
mxs.setPropertyController(secsub, 'Available', const)
def create_constraints(nNode, node):
# Position
posList = mxs.position_list() # Create Pos_List
const = mxs.Position_Constraint() # Create Pos_Constraint
const.appendTarget(nNode, 100) # Add target to Constraint
secsub = mxs.setPropertyController(node.controller, "Position",
posList) # Add PosList to node
mxs.setPropertyController(secsub, 'Available', const)
# Rotation
posList = mxs.rotation_list() # Create Pos_List
const = mxs.Orientation_Constraint() # Create Pos_Constraint
const.appendTarget(nNode, 100) # Add target to Constraint
secsub = mxs.setPropertyController(node.controller, "Rotation",
posList) # Add PosList to node
mxs.setPropertyController(secsub, 'Available', const)
for obj in self.result:
endPos = mxs.point3(0, 0, 0)
if obj.children.count > 0:
endPos = obj.children[0].transform.pos
else:
endPos = (mxs.transmatrix(mxs.point3(defaultSize, 0, 0)) *
obj.transform).pos
zPos = (mxs.transmatrix(mxs.point3(0, 0, 1)) * obj.transform).pos
d = mxs.BoneSys.createBone(obj.transform.pos, endPos, zPos)
d.transform = obj.transform
d.name = obj.name
d.wirecolor = obj.wirecolor
mxs.join(bones, d)
self.dict[obj] = d
self.newNodes.append(obj)
# Create parent connections
if mxs.isValidNode(obj.parent):
d.parent = self.dict[obj.parent]
else:
d.parent = rootNode
create_constraints(obj, d)
mxs.select(bones)
mxs.selectmore(rootNode)
mxs.redrawViews()
def SelectAllSceneObjects(self):
rt.select(rt.objects)
def changeSelection(self):
item = self.lw_skiin.selectedItems()
num = self.lw_skiin.row(item[0])
mxs.select(self.skinMeshes[num][0])
mxs.modPanel.setCurrentObject(self.skinMeshes[num][1])
def buildWiperMesh(self, p1, p2):
"""
Build the wiper mesh
Parameters
----------
p1 : Point3
the world position of the first dummy placed on the exterior part of the wiper
p2 : Point3
the world position of the second dummy placed on the exterior part of the wiper
"""
animationLength = self.animInEndFrame - self.animInStartFrame + 1
projectMeshVertices = []
projectMeshFaces = []
vColors = [rt.Point3(0, 0, 0) for i in range(animationLength * 2)]
vert_count = 0
if rt.DEBUG_MODE:
print(
"------------------------------------------------------------------"
)
#fill projectMeshVertices with the exterior points of the wiper for each frame
f = self.animInStartFrame
while f <= self.animInEndFrame:
with at(f):
projectMeshVertices.append(p1.transform.position)
projectMeshVertices.append(p2.transform.position)
f += 1
# fill the vertexColors array during animation IN
vIndex = 0
f = self.animInStartFrame
while f <= self.animInEndFrame:
with at(f):
self.setColorByFrame(f, vColors[vIndex])
self.setColorByFrame(f, vColors[vIndex + 1])
f += 1
vIndex += 2
# fill the vertexColors array during animation OUT
vIndex = 0
f = self.animOutEndFrame
while f >= self.animOutStartFrame:
with at(f):
self.setColorByFrame(f, vColors[vIndex])
self.setColorByFrame(f, vColors[vIndex + 1])
f -= 1
vIndex += 2
axis = rt.Point3(1, 0, 0)
result = rt.dot(p2.transform.position, axis)
for i in range(1, len(projectMeshVertices) - 1):
#build the triangle with the righ orientation
if i % 2 != 0:
projectMeshFaces.append(
rt.Point3(vert_count + 3, vert_count + 2, vert_count + 1))
else:
projectMeshFaces.append(
rt.Point3(vert_count + 2, vert_count + 3, vert_count + 1))
vert_count += 1
#build the mesh with an array of vertex and triangles
projectionMesh = rt.mesh(vertices=rt.Array(*(projectMeshVertices)),
faces=rt.Array(*(projectMeshFaces)))
rt.defaultVCFaces(projectionMesh)
#set the vertex color for each vertex
for i in range(len(projectMeshVertices)):
rt.setVertColor(projectionMesh, i + 1, vColors[i])
if result > 0:
rt.select(projectionMesh)
rt.execute("max modify mode")
normalModifier = rt.NormalModifier()
rt.addModifier(projectionMesh, rt.NormalModifier())
normal = rt.Name("Normal")
projectionMesh.modifiers[normal].flip = True
rt.maxOps.CollapseNode(projectionMesh, False)
#quadrify
rt.select(projectionMesh)
rt.convertToPoly(projectionMesh)
rt.execute("max modify mode")
rt.PolyToolsModeling.Quadrify(True, False)
edge = rt.Name("EDGE")
edgeNumber = projectionMesh.EditablePoly.getNumEdges()
edgeList = [1] if result < 0 else [2]
edgeSelection = rt.BitArray(*(edgeList))
rt.subObjectLevel = 2
projectionMesh.EditablePoly.SetSelection(edge, edgeSelection)
projectionMesh.EditablePoly.SelectEdgeRing()
projectionMesh.connectEdgeSegments = 3
rt.execute('macros.run "Ribbon - Modeling" "ConnectEdges"')
return projectionMesh
def saveAsset(self,
assetName,
exportUV=True,
exportOBJ=True,
exportFBX=True,
exportABC=True,
selectionOnly=True,
sceneFormat="max",
notes="N/A",
**info):
"""
Saves the selected object(s) as an asset into the predefined library
"""
# self.ssResolution = 1000
if assetName == "":
msg = "Asset Name cannot be empty"
state = rt.messageBox(msg, title='Info')
return
if assetName in self.assetsList:
msg = "This Asset already exists.\nDo you want to overwrite?"
state = rt.queryBox(msg, title='Manager Question')
if state:
pass
else:
return
originalSelection = self._getSelection(asMaxArray=True)
originalPath = self._getSceneFile()
dump, origExt = os.path.splitext(originalPath)
assetDirectory = os.path.join(self.directory, assetName)
assetAbsPath = os.path.join(assetDirectory,
"%s%s" % (assetName, u'.%s' % sceneFormat))
if selectionOnly:
selection = self._getSelection(asMaxArray=True)
if len(selection) == 0:
msg = "No object selected"
rt.messageBox(msg, title='Info')
return
else:
rt.select(rt.objects)
selection = self._getSelection(asMaxArray=True)
# originalSelection = self._getSelection(asMaxArray=True)
if not os.path.exists(assetDirectory):
os.mkdir(assetDirectory)
# GET TEXTURES
# ------------
if selectionOnly:
possibleFileHolders = rt.execute("selection as Array")
filteredBitmaps = self._getFileNodes(possibleFileHolders)
else:
allTexture = rt.usedMaps()
allBitmap = rt.getClassInstances(rt.bitmapTexture)
# this makes sure only the USED bitmaps will stored
filteredBitmaps = [
x for x in allBitmap if x.filename in allTexture
]
textureDatabase = [
x for x in self._buildPathDatabase(filteredBitmaps, assetDirectory)
]
self._copyTextures(textureDatabase)
# CREATE PREVIEWS
# ---------------
thumbPath, ssPath, swPath = self._createThumbnail(
assetName, selectionOnly=selectionOnly, viewFit=True)
# CREATE UV SNAPSHOTS
# ----------------
rt.select(selection)
if exportUV:
self._uvSnaps(assetName)
# SAVE SOURCE
# -----------
fManager.SaveSelected(assetAbsPath)
# EXPORT OBJ
# ----------
if exportOBJ:
objFilePath = os.path.join(assetDirectory, "%s.obj" % assetName)
if self._exportObj(objFilePath,
exportSettings=self.exportSettings):
objName = "{0}.obj".format(assetName)
else:
objName = "N/A"
else:
objName = "N/A"
# EXPORT FBX
# ----------
if exportFBX:
fbxFilePath = os.path.join(assetDirectory, "%s.fbx" % assetName)
frame = self._getCurrentFrame()
if self._exportFbx(fbxFilePath,
exportSettings=self.exportSettings,
timeRange=[frame, frame]):
fbxName = "{0}.fbx".format(assetName)
else:
fbxName = "N/A"
else:
fbxName = "N/A"
# EXPORT ALEMBIC
# --------------
if exportABC:
abcFilePath = os.path.join(assetDirectory, "%s.abc" % assetName)
frame = self._getCurrentFrame()
if self._exportAlembic(abcFilePath,
exportSettings=self.exportSettings,
timeRange=[frame, frame]):
abcName = "{0}.abc".format(assetName)
else:
abcName = "N/A"
else:
abcName = "N/A"
# NUMERIC DATA
# ------------
polyCount = sum(rt.getPolygonCount(x)[0] for x in selection)
# polyCount = sum(rt.getPolygonCount(x)[0] for x in countLoop)
tiangleCount = sum(rt.getPolygonCount(x)[1] for x in selection)
# tiangleCount = sum(rt.getPolygonCount(x)[1] for x in countLoop)
versionInfo = rt.maxversion()
vInfo = [versionInfo[0], versionInfo[1], versionInfo[2]]
# DATABASE
# --------
dataDict = {}
dataDict['sourceProject'] = "3dsMax"
dataDict['version'] = vInfo
dataDict['assetName'] = assetName
dataDict['objPath'] = objName
dataDict['fbxPath'] = fbxName
dataDict['abcPath'] = abcName
dataDict['sourcePath'] = os.path.basename(assetAbsPath)
dataDict['thumbPath'] = os.path.basename(thumbPath)
dataDict['ssPath'] = os.path.basename(ssPath)
dataDict['swPath'] = os.path.basename(swPath)
dataDict['textureFiles'] = [x["Texture"] for x in textureDatabase]
dataDict['Faces/Triangles'] = ("%s/%s" %
(str(polyCount), str(tiangleCount)))
dataDict['origin'] = originalPath
dataDict['notes'] = notes
self._setData(assetName, dataDict)
rt.clearSelection()
self._returnOriginal(textureDatabase)
# self.scanAssets() # scanning issued at populate function on ui class
rt.select(originalSelection)
rt.messageBox("Asset Created Successfully", title='Info', beep=False)
def createPreview(self, *args, **kwargs):
"""Creates a Playblast preview from currently open scene"""
# rt = pymxs.runtime
openSceneInfo = self.getOpenSceneInfo()
if not openSceneInfo:
msg = "This is not a base scene. Scene must be saved as a base scene before playblasting."
# raise Exception([360, msg])
self._exception(360, msg)
return
# logger.warning(msg)
# return -1, msg
# get view info
viewportType = rt.viewport.getType()
if str(viewportType) == "view_camera":
currentCam = str(rt.getActiveCamera().name)
else:
currentCam = str(viewportType)
validName = currentCam.replace("|", "__").replace(" ", "_")
extension = "avi"
# versionName = rt.getFilenameFile(rt.maxFileName) #
versionName = rt.maxFilePath + rt.maxFileName # abs path of the filename with extension
relVersionName = os.path.relpath(
versionName, start=openSceneInfo["projectPath"]
) # relative path of filename with ext
if not os.path.isdir(os.path.normpath(openSceneInfo["previewPath"])):
os.makedirs(os.path.normpath(openSceneInfo["previewPath"]))
playBlastFile = os.path.join(
openSceneInfo["previewPath"],
"{0}_{1}_PB.{2}".format(self.niceName(versionName), validName,
extension))
relPlayBlastFile = os.path.relpath(playBlastFile,
start=openSceneInfo["projectPath"])
if os.path.isfile(playBlastFile):
try:
os.remove(playBlastFile)
except WindowsError:
msg = "The file is open somewhere else"
logger.warning(msg)
return -1, msg
jsonInfo = self._loadJson(openSceneInfo["jsonFile"])
if jsonInfo == -1:
msg = "Database file is corrupted"
return -1, msg
# returns 0,"" if everything is ok, -1,msg if error
pbSettings = self.loadPBSettings()
originalValues = {"width": rt.renderWidth, "height": rt.renderHeight}
originalSelection = rt.execute("selection as array")
# change the render settings temporarily
rt.renderWidth = pbSettings["Resolution"][0]
rt.renderHeight = pbSettings["Resolution"][1]
if pbSettings["PolygonOnly"]:
dspGeometry = True
dspShapes = False
dspLights = False
dspCameras = False
dspHelpers = False
dspParticles = False
dspBones = False
else:
dspGeometry = True
dspShapes = True
dspLights = True
dspCameras = True
dspHelpers = True
dspParticles = True
dspBones = True
dspGrid = pbSettings["ShowGrid"]
dspFrameNums = pbSettings["ShowFrameNumber"]
percentSize = pbSettings["Percent"]
if pbSettings["WireOnShaded"]:
rndLevel = rt.execute("#litwireframe")
else:
rndLevel = rt.execute("#smoothhighlights")
if pbSettings["ClearSelection"]:
rt.clearSelection()
# find the path of where the avi file be created
# if rt.maxFilePath:
# previewname = rt.getFilenameFile(rt.maxFileName)
# else:
# previewname = "Untitled"
# sourceClip = rt.GetDir(rt.execute("#preview")) + "\_scene.avi"
# if os.path.isfile(sourceClip):
# try:
# os.remove(sourceClip)
# except WindowsError:
# msg = "Cannot continue creating preview.\n Close '%s' and try again" %sourceClip
# logger.error(msg)
# return -1, msg
test = rt.createPreview(filename=playBlastFile,
percentSize=percentSize,
dspGeometry=dspGeometry,
dspShapes=dspShapes,
dspLights=dspLights,
dspCameras=dspCameras,
dspHelpers=dspHelpers,
dspParticles=dspParticles,
dspBones=dspBones,
dspGrid=dspGrid,
dspFrameNums=dspFrameNums,
rndLevel=rndLevel)
# prior to version 2020, filename flag is not working
if not os.path.isfile(playBlastFile):
# find the path of where the avi file be created
if rt.maxFilePath:
previewname = rt.getFilenameFile(rt.maxFileName)
else:
previewname = "Untitled"
sourceClip = rt.GetDir(rt.execute("#preview")) + "\_scene.avi"
shutil.copy(sourceClip, playBlastFile)
# if os.path.isfile(sourceClip):
# try:
# os.remove(sourceClip)
# except WindowsError:
# msg = "Cannot continue creating preview.\n Close '%s' and try again" %sourceClip
# logger.error(msg)
# return -1, msg
# return
# return the render width and height to original:
rt.renderWidth = originalValues["width"]
rt.renderHeight = originalValues["height"]
rt.select(originalSelection)
# shutil.copy(sourceClip, playBlastFile)
if pbSettings["ConvertMP4"]:
convertedFile = self._convertPreview(playBlastFile,
overwrite=True,
deleteAfter=False,
crf=pbSettings["CrfValue"])
relPlayBlastFile = os.path.relpath(
convertedFile, start=openSceneInfo["projectPath"])
# os.startfile(convertedFile)
else:
relPlayBlastFile = os.path.relpath(
playBlastFile, start=openSceneInfo["projectPath"])
## find this version in the json data
for version in jsonInfo["Versions"]:
if relVersionName == version["RelativePath"]:
version["Preview"][currentCam] = relPlayBlastFile
self._dumpJson(jsonInfo, openSceneInfo["jsonFile"])
return 0, ""
def _selectionChanged(self):
selection = self.getSelectedRootList()
selection = sceneUtils.getDescendantsOfMultiple(selection)
rt.select(selection)
def projectVertexColor(self, nodeToBake, nodeToProject, outputPath,
padding):
"""
Project the vertex color of a given node to a given surface and bake the result in the given path
Parameters
----------
nodeToBake : INode
the node used to bake the texture
nodeToProject : INode
the node used to project the vertex color
outputPath : str
the path of the baked texture
"""
rt.disableSceneRedraw()
rt.select(nodeToBake)
snap = rt.snapshot(nodeToBake, name=nodeToBake.name + "_new")
snap.material = rt.standard(showInViewport=False, name="GlassMat")
nodeToProject.material = rt.standard(diffuseMap=rt.Vertex_Color(),
showInViewport=False,
name="WiperMat")
# --Clear all render elements
snap.iNodeBakeProperties.removeAllBakeElements()
# --Preparing the Bake Elements:
be1 = rt.diffusemap() # --instance of the bake element class
be1.outputSzX = be1.outputSzY = 1024 # --set the size of the baked map --specifythe full file path, name and type:
be1.fileType = outputPath
be1.fileName = rt.filenameFromPath(be1.fileType)
be1.filterOn = True # --enable filtering
be1.shadowsOn = False # --disable shadows
be1.lightingOn = False # --disable lighting
be1.enabled = True # --enable baking
snap.iNodeBakeProperties.nDilations = padding # --expand the texturea bit
snap.iNodeBakeProperties.addBakeElement(be1) # --add first element
snap.iNodeBakeProperties.bakeEnabled = True # --enabling baking
snap.iNodeBakeProperties.bakeChannel = 2 # --channel to bake
snap.INodeBakeProjProperties.bakeEnabled = True # --enabling baking
snap.INodeBakeProjProperties.bakeChannel = 2 # --channel to bake
snap.INodeBakeProjProperties.subObjBakeChannel = 2
snap.INodeBakeProjProperties.enabled = True #enable projection baking
# add a projection modifier and set it as the projection source
projection = rt.Projection()
rt.addModifier(snap, projection)
projection.addObjectNode(nodeToProject)
projection.resetCage()
snap.INodeBakeProjProperties.projectionMod = projection
snap.INodeBakeProjProperties.rayMissColor = rt.Point3(0, 0, 0)
#select the object enter modify mode, offset the cage and bake the texture at the given path
rt.select(
snap
) # --we are baking the selection, so we select the object --Call the rendererto bake both elements:
rt.execute("max modify mode")
projection.pushCage(0.1)
rt.render(rendertype=rt.Name("bakeSelected"),
vfb=False,
progressBar=True,
outputSize=rt.Point2(1024, 1024))
print("baked image in {0}".format(be1.fileType))
rt.delete(snap)
rt.enableSceneRedraw()
rt.CompleteRedraw()
def old_recreate(self):
with pymxs.undo(True):
if len(self.result) > 0:
self.newNodes = []
self.dict = {}
temp = mxs.Array()
lastNode = None
index = 0
rootNode = mxs.point()
rootNode.size = 2
rootNode.showlinks = True
rootNode.Box = True
rootNode.cross = False
rootNode.axistripod = False
rootNode.centermarker = False
mxs.join(temp, rootNode)
def create_constraints(node, nNode):
# Position
sub = mxs.getSubAnim(nNode, 3)
secsub = mxs.getSubAnim(sub, 1)
secsub.controller = mxs.Position_List()
posCtrl = mxs.Position_Constraint()
thirdsub = mxs.getSubAnim(secsub, 2)
thirdsub.controller = posCtrl
posConstraintInterface = posCtrl.constraints
posConstraintInterface.appendTarget(node, 100)
# Rotation
sub = mxs.getSubAnim(nNode, 3)
secsub = mxs.getSubAnim(sub, 2)
secsub.controller = mxs.rotation_list()
posCtrl = mxs.Orientation_Constraint()
thirdsub = mxs.getSubAnim(secsub, 2)
thirdsub.controller = posCtrl
posConstraintInterface = posCtrl.constraints
posConstraintInterface.appendTarget(node, 100)
for i in self.result:
# Create new nodes and add them to list and dict
nNode = mxs.point()
nNode.showlinks = True
nNode.size = 2
nNode.transform = i.transform
nNode.name = i.name
nNode.wireColor = i.wireColor
self.dict[i] = nNode
self.newNodes.append(i)
# Create parent connections
if mxs.isValidNode(i.parent):
nNode.parent = self.dict[i.parent]
else:
nNode.parent = rootNode
# Create Constraints
create_constraints(i, nNode)
# final part
mxs.join(temp, nNode)
lastNode = nNode
index += 1
mxs.select(temp)
mxs.redrawViews()
print('centering points ch points')
hull_verts = [hull.points[vert] - center for vert in hull.vertices]
print('working out svd')
pcloud = matrix(hull_verts)
_, _, vh = svd(pcloud)
print('building matrix')
xaxis, yaxis, zaxis = vh.tolist()
xaxis = mxs.point3(*map(float, xaxis))
yaxis = mxs.point3(*map(float, yaxis))
zaxis = mxs.point3(*map(float, zaxis))
transform = mxs.matrix3(mxs.normalize(xaxis),
mxs.normalize(yaxis),
mxs.normalize(zaxis),
mxs.point3(*map(float, center)))
return transform
if __name__ == '__main__':
if not list(mxs.selection):
raise RuntimeError('select something my guy')
pnt = mxs.point(name='volume align transform')
pnt.transform = volume_based_transform(mxs.selection[0])
mxs.select(pnt)
def _doubleClickedItem(self):
selected = self.selectedItems()
s = selected[len(selected) - 1]
if(s.childCount() == 0):
rt.select(self._rootDict[s])
userprop.openUserPropertyWindow()
