Beispiel #1
0
    def saveScreenshot(self, name, directory):
        """
        Saves screenshot out to disk
        Args:
            name: Name of the screenshot
            directory: Directory to save into
        """
        # get camera, current position and focus object
        cameraName = cmds.lookThru(q=True)
        prevPosition = cmds.getAttr("{0}.translate".format(cameraName))
        objName = cmds.ls(sl=True, l=True)
        if objName:
            objName = objName[0]
        else:
            cmds.error("No object has been selected")

        # frame camera to object
        cmds.viewFit()  # 'f' on keyboard
        distance = lib.distanceBetween(cameraName, objName)
        frameDistance = distance * 0.5
        cmds.dolly(cameraName, d=-frameDistance)

        # take screenshot
        screenshotDir = mnpr_system.renderFrame(os.path.join(directory, name),
                                                100, 100, 1, ".jpg")

        # bring camera back to normal
        lib.setAttr(cameraName, "translate", prevPosition)
        return screenshotDir
Beispiel #2
0
    def createCamera(self, *args):
        selectedFaces = cmds.ls(sl=True, fl=True)
        cameraName = cmds.camera(name="BadGeoFinderCam", ncp=0.001)
        cameraShape = cameraName[1]
        cmds.currentTime(0, e=True)
        for face in range(len(selectedFaces)):
            currentTime = cmds.currentTime(q=True)
            cmds.currentTime(currentTime + 1, e=True)
            print "target = " + str(selectedFaces[face])
            face_pos = cmds.xform(selectedFaces[face],
                                  q=True,
                                  bb=True,
                                  ws=True)
            x_pos = (face_pos[0] + face_pos[3]) / 2
            y_pos = (face_pos[1] + face_pos[4]) / 2
            z_pos = (face_pos[2] + face_pos[5]) / 2
            cube = cmds.polyCube(n="BGF_Cube_" + str(face))
            print cube
            cmds.move(x_pos, y_pos, z_pos, cube)
            nConstraint = cmds.normalConstraint(selectedFaces[face], cube)
            cube_pos = cmds.xform(cube, q=True, t=True, ws=True)
            cube_rot = cmds.xform(cube, q=True, ro=True, ws=True)
            cmds.xform(cameraName, t=cube_pos, ro=cube_rot, ws=True)
            cmds.rotate(0, 45, 0, cameraName, r=True)
            cmds.select(selectedFaces[face])
            cmds.viewFit(cameraShape, f=0.5)
            cmds.select(cameraName)
            cmds.setKeyframe()

            cmds.delete(nConstraint, cube)
            cmds.select(selectedFaces)
Beispiel #3
0
    def update_cam_position(self):
        objeto = cmds.ls(self.UI_object)
        if len(objeto) < 1:
            return

        # cam position
        obj_pos = cmds.xform(objeto[0], q=True, t=True)

        # interpolacion lineal
        percentage =  0 #float((float(self.slider_timeline.value()) / 100) * 100)
        position = self.cam_pos_start + (self.UI_object_full_rotation * percentage)
        rotation = self.cam_rot_start + ((self.cam_rot_end - self.cam_dist_start) * percentage)
        distance = self.cam_dist_start + ((self.cam_rot_end - self.cam_dist_start) * percentage)
        height = self.cam_height_start + (self.cam_height_end - self.cam_height_start) * percentage

        # update de pos of the camera
        obj_pos[0] += math.sin(math.radians(position)) * distance
        obj_pos[1] += (float(height) / 100) * self.UI_object_height
        obj_pos[2] += math.cos(math.radians(position)) * distance

        cmds.xform(self.UI_camera, t=obj_pos)

        # update the rotation with the inverse of the position angle in obj space
        rotation_percentage = float(rotation) / 100
        xpos = self.UI_object_bottom[0]
        ypos = self.UI_object_bottom[1] + rotation_percentage * self.UI_object_height
        zpos = self.UI_object_bottom[2]

        try:
            cmds.viewPlace(self.UI_cameraShape, la=(xpos,ypos,zpos))
        except:
            cmds.viewFit(self.UI_cameraShape , all=True)
Beispiel #4
0
    def create_setup(self):
        objecto = cmds.ls(self.UI_object)
        cmds.viewFit(self.UI_cameraShape , all=True)
        if len(objecto) < 1:
            return

        # CREATE CAMERA OR CONFIGURE IT
        _width, _depth , height , _center , bottom, radius = self.getObjectData(objecto[0])

        self.UI_object_height = height
        self.UI_object_radius = radius
        self.UI_object_bottom = bottom

        # CENTRAR LOS WIDGETS THE TURN AROUND HERE
        # slider distancia
        self.Qslider_dist.blockSignals(True)
        medium = (radius * 5)
        self.Qslider_dist.setRange(0, radius  * 5)
        self.Qslider_dist.setValue(medium)
        self.Qslider_dist.blockSignals(False)

        self.Qslider_dist_end.setRange(radius, radius  * 5)

        # altura slider
        self.Qslider_height.blockSignals(True)
        self.Qslider_height.setValue(50 + 15)
        self.Qslider_height.blockSignals(False)

        # altura slider
        self.Qslider_rot.blockSignals(True)
        self.Qslider_rot.setValue(50 + 10)
        self.Qslider_rot.blockSignals(False)

        # timeline
        self.slider_timeline.setValue(0)
Beispiel #5
0
    def saveScreenshot(self, name):
        """
    This function saves a screenshot of the library mesh
    Args:
      name: The name of the file to be saved

    Returns: The path to the screenshot

    """
        directory = self.DIRECTORY
        screenshotPath = os.path.join(directory, "%s.jpg" % name)
        cmds.viewFit()
        #We deselect the mesh so we can screenshot it prettier
        cmds.select(clear=True)
        #Save as jpeg
        cmds.setAttr('defaultRenderGlobals.imageFormat', 8)
        cmds.playblast(completeFilename=screenshotPath,
                       forceOverwrite=True,
                       format='image',
                       width=200,
                       height=200,
                       showOrnaments=False,
                       startTime=1,
                       endTime=1,
                       viewer=False)

        return screenshotPath
Beispiel #6
0
    def screenshot(self):
        self.playblastpath = r"Q:\rig\scripts\test\q_repos\aas_scripts\aas_mayaTools\ani_scripts\strack_asset\midchangepic.jpg"  # 设置截图保存路径
        filename = pm.sceneName()
        if filename:
            strinfo = re.compile('.ma|.mb')
            self.path = strinfo.sub('.jpg', filename)
            cmds.viewFit()
            cmds.setAttr("defaultRenderGlobals.imageFormat", 8)
            if os.path.exists(self.path):
                picplayblast = cmds.playblast(
                    completeFilename=self.playblastpath,
                    forceOverwrite=True,
                    format='image',
                    width=500,
                    height=500,
                    showOrnaments=False,
                    startTime=1,
                    endTime=1,
                    viewer=False)

            else:
                picplayblast = cmds.playblast(completeFilename=self.path,
                                              forceOverwrite=True,
                                              format='image',
                                              width=500,
                                              height=500,
                                              showOrnaments=False,
                                              startTime=1,
                                              endTime=1,
                                              viewer=False)

            map = QtGui.QPixmap(picplayblast)
            self.screenshotbtn.setPixmap(map)
        else:
            self.Message.setText("<h3>请打开这个文件(注意不要导入)</h3>")
    def build(self, force_new=True):
        """
        Main function to build the rig
        """

        if self._import_scenes:
            mc.file(force=force_new, new=True)

        print('Building rig for asset {}'.format(self._asset_name))

        self.create_main_groups()

        if self._import_scenes:
            self.import_model()
            self.import_proxy()
            self.import_builder()
        else:
            self._generate_input_data_structure()

        self.create_main_controls()
        self.create_main_attributes()
        self.connect_main_controls()

        self.clean_model_group()
        self.clean_proxy_group()

        self.setup()

        self.finish()

        mc.select(mc.ls())
        mc.viewFit(animate=True)
        mc.select(clear=True)
Beispiel #8
0
def createSnapShotCamera(objs, rotation=[0, 0, 0], resolution=[400, 600]):
	
    # build the bounding box and find it's centre
    bBox = createBoundingBox(objs)
    focusPoint = cmds.xform(bBox, query=True, ws=True, t=True)

    # build the camera the move and orient it
    cam = cmds.camera(ar=True, ff=3, fl=20)
    cmds.setAttr(cam[1]+'.renderable', True)
    cmds.setAttr(cam[1]+'.displayFilmGate', True)
    cmds.setAttr(cam[1]+'.displayResolution', True)
    cmds.setAttr(cam[1]+'.horizontalFilmAperture', resolution[0]*1.0/resolution[1]*1.0)
    cmds.setAttr(cam[1]+'.verticalFilmAperture', 1)
    cmds.setAttr(cam[1]+'.backgroundColor', 0.3, 0.3, 0.3, type='double3') #transform 
    
    cmds.xform(cam[0], t=focusPoint, ro=rotation, ws=True)
	
    # build the bounding box then fit the camera
    cmds.select(bBox)
    cmds.viewFit(cam[0], an = False, f = 1 )
    cmds.delete(bBox)
	
    # set the render globals
    cmds.currentTime(1)
    cmds.setAttr('defaultRenderGlobals.imageFormat', 8)
    cmds.setAttr('defaultRenderQuality.edgeAntiAliasing', 0)
    cmds.setAttr('defaultRenderQuality.shadingSamples', 2)
    cmds.setAttr('defaultRenderQuality.maxShadingSamples', 8)
    cmds.setAttr('defaultRenderQuality.useMultiPixelFilter', 1)
    cmds.setAttr('defaultRenderQuality.enableRaytracing', 0)
    cmds.setAttr('defaultResolution.width', resolution[0])
    cmds.setAttr('defaultResolution.height', resolution[1])
    cmds.setAttr('defaultResolution.deviceAspectRatio', resolution[0]*1.0/resolution[1]*1.0)
    
    return cam
Beispiel #9
0
def takeSnapShot(targetObj, renderPath, rotX=-30.0, rotY=45.0, rotZ=0.0, resX=300, resY=300, useBoundingBox=False):
	'''
	Take a snapshot of the selected object using the Maya renderer then move the image to a directory
	'''
	
	# build the bounding box and find it's centre
	bBox = targetObj
	if useBoundingBox is True:
		bBox = buildBoundingBoxGeo(targetObj, noChildren=False, ignoreInv=True)
	focusPoint = cmds.xform(bBox, query=True, ws=True, t=True)
	
	# build the camera the move and orient it
	tempCam = cmds.camera(ar=True, ff=3, fl=35)
	camName = tempCam[1]
	cmds.setAttr(camName+'.renderable', True)
	cmds.setAttr(camName+'.displayFilmGate', True)
	cmds.setAttr(camName+'.displayResolution', True)
	cmds.setAttr(camName+'.backgroundColor', 0.5, 0.5, 0.5, type='double3') #transform
	cmds.move(focusPoint[0], focusPoint[1], focusPoint[2], tempCam, ws=True) 
	cmds.rotate( rotX, rotY, rotZ, tempCam, ws=True)
	
	# build the bounding box then fit the camera
	cmds.select(bBox, r=True)
	cmds.viewFit(camName, an = False, f = 0.9 )
	if useBoundingBox is True:
		cmds.delete(bBox)
	
	# set the render globals
	cmds.currentTime(1)
	cmds.setAttr('defaultRenderGlobals.imageFormat', 8)
	cmds.setAttr('defaultRenderQuality.edgeAntiAliasing', 0)
	cmds.setAttr('defaultRenderQuality.shadingSamples', 2)
	cmds.setAttr('defaultRenderQuality.maxShadingSamples', 8)
	cmds.setAttr('defaultRenderQuality.useMultiPixelFilter', 1)
	cmds.setAttr('defaultRenderQuality.enableRaytracing', 0)
	
	# build the lightrig
	lightRigGrp = cmds.group(em=True, name='lightRigGroup')
	lightMain = cmds.directionalLight(rotation=(-20, -45, 0), intensity=0.8)
	lightFill = cmds.directionalLight(rotation=(-20, 45, 0), intensity=0.4)
	lightUnder = cmds.directionalLight(rotation=(75, 0, 0), intensity=0.15)
	lightKey = cmds.directionalLight(rotation=(-25, 145, 0), intensity=4.0)
	cmds.parent([lightMain, lightFill, lightUnder, lightKey], lightRigGrp)
	cmds.rotate( rotX, rotY, rotZ, lightRigGrp, ws=True)
	
	# select everything, build the special shader, render, then delete everything
	cmds.select([targetObj, lightRigGrp], r=True)
	renderLayerName = cmds.createRenderLayer(name='tempSnapShot_rlayer', mc=True)
	shaderNodes = buildReverseNormalShader() #build the shader
	cmds.sets(targetObj, e=True, forceElement=shaderNodes[0]) #adding the shader here means it's in the render layer
	tempImage= cmds.render(camName, layer=renderLayerName, x=resX, y=resY)
	cmds.editRenderLayerGlobals(currentRenderLayer='defaultRenderLayer')
	cmds.delete([lightRigGrp, tempCam[0], renderLayerName, shaderNodes[0], shaderNodes[1], shaderNodes[2], shaderNodes[3]])
	
	# copy the thumbnail to the desired location
	output = cmds.sysFile(tempImage, rename=renderPath)
	if output==True:
		print 'Path for thumbnail: ' + renderPath
		return renderPath
	return None
Beispiel #10
0
    def save_snapshot(self, geo):
        # Create new camera, isolated selected object, frame and take snapshot
        # Delete cam and return to perspective cam
        self.create_img_cam()
        cmds.lookThru(self.cameraName)
        cmds.select(geo)

        if cmds.isolateSelect('modelPanel4', q=True, state=True):
            cmds.isolateSelect('modelPanel4', state=False)
            cmds.isolateSelect('modelPanel4', state=True)
            cmds.isolateSelect('modelPanel4', addSelected=True)
        else:
            cmds.isolateSelect('modelPanel4', state=True)
            cmds.isolateSelect('modelPanel4', addSelected=True)

        cmds.viewFit()
        imageSnapshot = (os.path.join(self.img_path, geo)) + ".jpg"
        imageSnapshot = os.path.normpath(imageSnapshot)
        cmds.refresh(cv=True, fe = "jpg", fn = imageSnapshot)
        cmds.isolateSelect('modelPanel4', state=False)
        self.return_to_perspCam()
        if self.cameraName:
            cmds.delete(self.cameraName[0])

        return imageSnapshot
Beispiel #11
0
    def saveScreenshot(self, name):
        path = os.path.join(self.userPath, '%s.jpg' % name)
        activePanel = cmds.paneLayout('viewPanes', q=True, pane1=True)

        cmds.viewFit()
        cmds.setAttr('defaultRenderGlobals.imageFormat', 8)

        # Isolate selection
        if cmds.ls(selection=True):
            cmds.isolateSelect(activePanel, update=1)
            cmds.isolateSelect(activePanel, state=1)
            cmds.isolateSelect(activePanel, addSelected=1)

        cmds.modelEditor(activePanel, edit=True, sel=False)

        cmds.playblast(completeFilename=path,
                       forceOverwrite=True,
                       format='image',
                       width=200,
                       height=200,
                       showOrnaments=False,
                       startTime=1,
                       endTime=1,
                       viewer=False)

        cmds.modelEditor(activePanel, edit=True, sel=True)

        cmds.isolateSelect(activePanel, state=0)
    def saveScreenshot(self, name, directory=DIRECTORY):
        """
         to save screenshot of the model
        Args:
            name: (str) name of the model
            directory: (str) (path) path of the control library

        Returns:
            path: path of image of the screenshot

        """

        path = os.path.join(directory, '%s.jpg' %
                            name)  # to get the path of the screenshot

        cmds.viewFit(
        )  # view fit from maya commands of selected object i.e click 'f' key
        cmds.setAttr('defaultRenderGlobals.imageFormat',
                     8)  # set maya render to image format of jpg

        cmds.playblast(
            completeFilename=path,
            forceOverwrite=True,
            format='image',
            width=200,
            height=200,
            showOrnaments=False,
            startTime=1,
            endTime=1,
            viewer=False)  # get playblast of 1 frame and save in given path

        # return the path of the image
        return path
def create_camera():
    # creates a camera
    mel.eval('camera -centerOfInterest 5 -focalLength 35 -cameraScale 1;objectMoveCommand; cameraMakeNode 2 "";')
    cmds.select(clear=True)
    cmds.select("camera1")
    # render settings
    mel.eval('setAttr "frontShape.renderable" 0;')
    mel.eval('setAttr "topShape.renderable" 0;')
    mel.eval('setAttr "sideShape.renderable" 0;')
    mel.eval('setAttr "perspShape.renderable" 0;')
    mel.eval('setAttr "cameraShape1.renderable" 1;')
    # prep for render
    mel.eval('select -r camera1_aim; move -absolute -worldSpaceDistance 0 0 0;')
    mel.eval('select -r camera1; move -absolute -worldSpaceDistance 0 ' + str(5) + ' 0;')
    mel.eval('select -r shirt')
    cmds.viewFit('camera1', f=0.95*(SHIRT_SCALE/0.8))
    # shirt material settings
    mel.eval('select -r shirt;')
    mel.eval('shadingNode -asShader lambert;')
    mel.eval('rename lambert2 "shirt_mat";')
    mel.eval('sets -renderable true -noSurfaceShader true' + \
        '-empty -name -shirt_matSG;')
    mel.eval('connectAttr -f shirt_mat.outColor shirt_matSG.surfaceShader;')
    mel.eval('setAttr "shirt_mat.color" -type double3 1 1 1;')
    mel.eval('setAttr "shirt_mat.ambientColor" -type double3 1 1 1;')
    mel.eval('select -r shirt ; sets -e -forceElement shirt_matSG;')
    # pointer material settings
    mel.eval('shadingNode -asShader lambert;')
    mel.eval('rename lambert2 "pointer_mat";')
    mel.eval('sets -renderable true -noSurfaceShader true' + \
        '-empty -name -pointer_matSG;')
    mel.eval('connectAttr -f pointer_mat.outColor pointer_matSG.surfaceShader;')
    mel.eval('setAttr "pointer_mat.transparency" -type double3 1 1 1;')
Beispiel #14
0
def __icon(*arg):

    if "file" not in CACHE.viewkeys(): return
    mc.select(cl=True)
    for e in mc.lsUI(ed=True):
        try:
            mc.viewFit(p=e)
        except:
            pass
    f = CACHE["file"][:-3] + ".png"
    if os.path.isfile(f): os.remove(f)
    fmt = mc.getAttr("defaultRenderGlobals.imageFormat")
    mc.setAttr("defaultRenderGlobals.imageFormat", 32)
    i = mc.playblast(cf=f,
                     fmt="image",
                     cc=False,
                     fr=1,
                     v=False,
                     orn=False,
                     os=True,
                     p=100,
                     wh=[200, 200],
                     qlt=100)
    mc.setAttr("defaultRenderGlobals.imageFormat", fmt)
    mc.image("img_FRW", e=True, i=f)
Beispiel #15
0
def gpsTurntable():
	# Set up framerange
	startTime = cmds.playbackOptions ( query = True, minTime = True )
	endTime = cmds.playbackOptions ( query = True, maxTime = True )

	# Get current selection
	selectionList = cmds.ls (selection = True)

	if selectionList:

		# Get centre of selection
		bbox = cmds.exactWorldBoundingBox()

		centre_x = (bbox[0] + bbox[3]) / 2.0
		centre_y = (bbox[1] + bbox[4]) / 2.0
		centre_z = (bbox[2] + bbox[5]) / 2.0
		
		# Create new group
		new_grp = cmds.group(empty=True, name="Turntable_%s_grp#" %selectionList[0])
		cmds.move(centre_x, centre_y, centre_z, new_grp)

		# Create Turntable camera
		new_cam = cmds.camera()
		cmds.select (selectionList, r = True)
		cmds.viewFit (new_cam[0], allObjects = False)
		cmds.parent (new_cam[0], new_grp)
		cmds.setKeyframe (new_grp, time = startTime-1, attribute = "rotateY", value=0)
		cmds.setKeyframe (new_grp, time = endTime, attribute = "rotateY", value=360)
		cmds.selectKey (new_grp, time = (startTime-1, endTime), attribute = "rotateY", keyframe = True)
		cmds.keyTangent (inTangentType = "linear", outTangentType = "linear")
		cmds.rename ("Turntable_%s_cam#" %selectionList[0])
		
	else:
		cmds.warning("Please select one or more objects!")
Beispiel #16
0
 def saveScreenShot(self, name, directory=DIRECTORY):
     path = os.path.join(directory, '%s.jpg'%name)
     cmds.viewFit()
     cmds.setAttr('defaultRenderGlobals.imageFormat', 8)
     cmds.playblast(completeFilename=path, forceOverwrite=True, format='image', width=200, height=200,
                    showOrnaments = False, startTime=1, endTime=1, viewer=False )
     return path
Beispiel #17
0
	def update_editor_view(self):
		cmds.viewFit()

		panels = cmds.getPanel(type='modelPanel')
		for panel in panels:
			modelEditor = cmds.modelPanel(panel, query=True, modelEditor=True)
			cmds.modelEditor(modelEditor, edit=True, displayAppearance='smoothShaded', displayTextures=True, textures=True, joints=False)
def focus_cam_object(node_name, cam_name="persp"):
    """
        Focus on an object with specified camera

        Parameters
        ----------
            node_name (string): Maya node name
            cam_name (string): Maya camera name

        Returns
        -------
            Exception: Raise an exception if node_name is not foundable
            True (Boolean): Always return True if completed

    """
    try:
        cmds.select(node_name)
    except:
        raise Exception(
            "Error: No able to found {} in the current scene".format(
                node_name))

    # center perspective camera on it
    cmds.viewFit("persp", node_name)

    return True
Beispiel #19
0
 def CreateViewWindow(self):
     self.camera = None
     form = cmds.formLayout(w=300, h=300)
     self.editorShot = cmds.modelEditor()
     column = cmds.columnLayout('true', bgc=[0, 0, 0])
     cmds.formLayout(form,
                     edit=True,
                     attachForm=[(column, 'top', 10), (column, 'left', 10),
                                 (self.editorShot, 'top', 10),
                                 (self.editorShot, 'bottom', 10),
                                 (self.editorShot, 'right', 10),
                                 (self.editorShot, 'left', 10)],
                     attachNone=[(column, 'bottom'), (column, 'right')],
                     attachControl=(self.editorShot, 'left', 0, column))
     self.camera = cmds.camera(centerOfInterest=2.450351,
                               position=(1.535314, 1.135712, 1.535314),
                               rotation=(0, 0, 0),
                               worldUp=(0, 0, 1))
     cmds.setAttr(self.camera[1] + ".focalLength", 70)
     cmds.modelEditor(self.editorShot, edit=True, camera=self.camera[0])
     cmds.viewFit(self.camera[0])
     cmds.modelEditor(self.editorShot,
                      edit=True,
                      nurbsCurves=False,
                      displayAppearance="smoothShaded",
                      displayTextures=True,
                      headsUpDisplay=False,
                      cameras=False,
                      grid=False,
                      joints=False,
                      textures=True)
    def addCharacter(self, close, *args):
        project = cmds.optionMenu(self.widgets["project"], q=True, value=True)
        selectedCharacter = cmds.textScrollList(self.widgets["characterList"], q=True, si=True)[0]
        rigPath = os.path.join(
            self.mayaToolsDir, "General", "ART", "Projects", project, "AnimRigs", selectedCharacter + ".mb"
        )
        # find existing namespaces in scene
        namespaces = cmds.namespaceInfo(listOnlyNamespaces=True)
        # reference the rig file
        cmds.file(
            rigPath, r=True, type="mayaBinary", loadReferenceDepth="all", namespace=selectedCharacter, options="v=0"
        )
        # clear selection and fit view
        cmds.select(clear=True)
        cmds.viewFit()
        panels = cmds.getPanel(type="modelPanel")
        # turn on smooth shading
        for panel in panels:
            editor = cmds.modelPanel(panel, q=True, modelEditor=True)
            cmds.modelEditor(editor, edit=True, displayAppearance="smoothShaded", displayTextures=True, textures=True)
        # find new namespaces in scene (this is here in case I need to do something later and I need the new name that was created)
        newCharacterName = selectedCharacter
        newNamespaces = cmds.namespaceInfo(listOnlyNamespaces=True)
        for name in newNamespaces:
            if name not in namespaces:
                newCharacterName = name
        # launch UI
        import ART_animationUI

        reload(ART_animationUI)
        ART_animationUI.AnimationUI()
        if close:
            cmds.deleteUI(self.widgets["window"])
    def __init__( self, xformRoots, traceableObjs ):
        self.xformRoots = xformRoots        # all rigs
        self.traceableObjs = traceableObjs  # the list of joints to pay attention to (ignore the rest)
        
        self.substeps = 1             # precision settings
        self.dragDensity = 0.2

        self.selectedMotions = {}     # a dictionary to hold the selected motions for each root
        self.motionPathsVisible = {}  # a dictionary to remember whether (or not) the motion paths for a root were visible when the interaction started

        self.forceReload = False      # force the re-definition of the tool?
        
        # for keeping track of time when mousePressed (when selection started)
        self.startTime = 0

        # make an empty trajectory dictionary
        self.trace = {}
        self.nearestRoot = None
        self.nearestPath = None
        self.interactionPlane = None

        # measure the fit-one truck distance for the camera
        mc.select( xformRoots[0] )
        mc.viewFit()
        self.viewFitDistance = self.CameraToPopDist()
        # zoom back out to view all
        mc.select(clear=True)
        mc.viewFit()
Beispiel #22
0
    def importFiles(self):
        # import guides
        cmds.file(GUIDE_PATH, i=True, defaultNamespace=True)
        # import BlendNode
        cmds.file(IN_BLEND_PATH, i=True, defaultNamespace=True)

        cmds.viewFit()
    def viewFromCamPosition(self, positionName, containerName):
        self.changeToPerspCam()

        cmd = ""
        if (positionName =='PERSPECTIVE'):
            cmd = "viewSet -animate `optionVar -query animateRollViewCompass` -p"
            #cmds.viewSet(p=True, an=False);
        elif (positionName == 'TOP'):
            cmd = "viewSet -animate `optionVar -query animateRollViewCompass` -top"
        elif (positionName == 'BOTTOM'):
            cmd = "viewSet -animate `optionVar -query animateRollViewCompass` -bottom"
        elif (positionName == 'RIGHT'):
            cmd = "viewSet -animate `optionVar -query animateRollViewCompass` -rightSide"
        elif (positionName == 'LEFT'):
            cmd = "viewSet -animate `optionVar -query animateRollViewCompass` -leftSide"
        elif (positionName == 'FRONT'):
            cmd = "viewSet -animate `optionVar -query animateRollViewCompass` -front"
        elif (positionName == 'BACK'):
            cmd = "viewSet -animate `optionVar -query animateRollViewCompass` -back"

        cmds.select(containerName)

        # Execute MEL command
        mel.eval(cmd)
        cmds.viewFit(an=False)
    def TraceGestureRelease( self ):
        """ when the mouse is released, find the matching joint trajectory """
        if debug>0: print("begin RELEASE")
        releasePosition = Vector( mc.draggerContext( 'TraceGesture', query=True, dragPoint=True) ).projectToPlane( self.trace[self.nearestRoot].normal, planePt=self.trace[self.nearestRoot].planePt )
        if debug>0: print "release! ", releasePosition
        theTrace = self.trace[self.nearestRoot]
        selectedMotion = None
        if theTrace.closestJoint and theTrace.timespan and (theTrace.timespan[1]-theTrace.timespan[0]) > 1 and \
           not mc.draggerContext( 'TraceGesture', query=True, modifier=True) == "ctrl":        
            theDTW = theTrace.dtws[theTrace.closest]
            if debug > 0:
                print "closest = ", theTrace.closestJoint, theTrace.timespan
                if not mc.objExists("DTW_Y"):
                    mc.group(n="DTW_Y",empty=True)
                for pt in theDTW.Y:
                    loc = mc.spaceLocator(p=pt)
                    mc.parent(loc,"DTW_Y")
        ##    ghostJoint(trace[nearestRoot].closestJoint,trace[nearestRoot].timespan)

            # Build the motion curve and store it's name in the selectedMotions dictionary
            duration = [ int(theTrace.timespan[0]), int(theTrace.timespan[1]+1) ]
            keyframes = [ theTrace.searchList[theTrace.closestJoint].points[frame] for frame in range(duration[0],duration[1]) ]
            selectedMotion = bmt.CurveMotionTrace( theTrace.closestJoint, keys=keyframes ) #duration=theTrace.timespan )
            
        else:
            self.ScrubToNearestTimeOnPath( releasePosition, self.nearestRoot, self.nearestPath )
            cam2pop = self.CameraToPopDist()
            path = theTrace.searchList[self.nearestPath]
            pointKey = path.ClosestTimeTo(releasePosition)
            closestPoint = path.points[pointKey]
            closestPtOnPath = closestPoint.projectToPlane( theTrace.normal, planePt=theTrace.planePt )
            mouse2path = (releasePosition - closestPtOnPath).mag()
            # if motion paths are visible and no drag happened
            # and releasePosition is very close to the path,
            # then select the whole motion path
            if self.motionPathsVisible[self.nearestRoot] and mouse2path < 0.3:  
                # Build the motion curve and store it's name in the selectedMotions dictionary
                duration = [ mc.playbackOptions(q=True,min=True),mc.playbackOptions(q=True,max=True)+1 ]
                keyframes = [ theTrace.searchList[self.nearestPath].points[frame] for frame in range(duration[0],duration[1]) ]
                selectedMotion = bmt.CurveMotionTrace( self.nearestPath, keys=keyframes ) #duration=[mc.playbackOptions(q=True,min=True),mc.playbackOptions(q=True,max=True)] )

            # if not scrubbing
            if not mc.draggerContext( 'TraceGesture', query=True, modifier=True) == "ctrl" and \
               cam2pop >= self.viewFitDistance:      # if trucked out, and mouse is clicked (w/ no drag)
                mc.select(self.nearestRoot)     # zoom in on the nearest root for a better view
                mc.viewFit(fitFactor=2.5)            # the invisible parts of the roots can artificially enlarge the BB, so truck in a little extra
                mc.select(clear=True)
        if selectedMotion:
            selectedMotionCurve = selectedMotion.construct(self.nearestPath)
            
            if not self.nearestRoot in self.selectedMotions.keys():
                self.selectedMotions[self.nearestRoot] = []
            mc.setAttr("%s_MotionTraces.visibility"%self.nearestRoot, 0)
            selectedMotionCurve = mc.rename(selectedMotionCurve, "%s_selection%d"%(self.nearestPath,len(self.selectedMotions[self.nearestRoot])))
            self.selectedMotions[self.nearestRoot].append( selectedMotionCurve )
            self.AddCustomAttr( selectedMotionCurve, "isTraceSelection", True )
            self.AddCustomAttr( selectedMotionCurve, "interactTime", time.time()-self.startTime )
            self.AddCustomAttr( selectedMotionCurve, "startFrame", duration[0] )
            self.AddCustomAttr( selectedMotionCurve, "endFrame", duration[1] )
        mc.select(cl=True)
Beispiel #25
0
    def save_screenshot(self, name, directory=DIRECTORY):
        '''[summary]

        Arguments:
            name {string} -- Name of the asset to be used to make
                              screenshot file

        Keyword Arguments:
            directory {string} -- Path of the asset library
                                    (default: {LIBRARY_PATH})

        Returns:
            string -- Returns path of the screenshot file
        '''

        path = os.path.join(directory, '{0}.jpg'.format(name))

        cmds.viewFit()
        cmds.setAttr('defaultRenderGlobals.imageFormat', 8)

        cmds.playblast(
            completeFilename=path,
            forceOverwrite=True,
            format='image',
            width=200,
            height=200,
            showOrnaments=False,
            startTime=1,
            endTime=1,
            viewer=False)

        return path
def center_camera():
    # center the camera
    bbx = cmds.xform("shirt", q=True, bb=True, ws=True)
    centerX = (bbx[0] + bbx[3]) / 2.0
    centerZ = (bbx[2] + bbx[5]) / 2.0
    mel.eval('select -r camera1_aim; move -absolute -worldSpaceDistance ' + str(centerX) + ' 0 ' + str(centerZ) + ';')
    mel.eval('select -r camera1; move -absolute -worldSpaceDistance ' + str(centerX) + ' 5 ' + str(centerZ) + ';')
    cmds.viewFit('camera1', all=True)
Beispiel #27
0
 def playblast_picture(self):
     filename=(str(self.playblast_filename))
     strinfo = re.compile('.ma|.mb')
     path= strinfo.sub('.jpg',filename)
     cmds.viewFit()
     cmds.setAttr("defaultRenderGlobals.imageFormat", 8)
     cmds.playblast(completeFilename=path, forceOverwrite=True, format='image', width=800, height=800,
                    showOrnaments=False, startTime=1, endTime=1, viewer=False)
Beispiel #28
0
def re_open_current_file():
    current_file = mc.file(q=True, sceneName=True)
    if os.path.exists(current_file):
        mc.file(new=True, force=True)
        mc.file(current_file, open=True)
        mc.viewFit()
    else:
        mc.file(new=True, force=True)
Beispiel #29
0
def create_turntable():
    # # save current file
    # mc.file(save=1, f=1)
    # sel the group for turntable
    sel = mc.ls(sl=1)
    group_name = "tt_rotation"
    # cam_name = "tt_camera"
    if sel:
        if pm.ls(group_name):
            logging.warning("tt_rotation group exist.")
            return
        else:
            # group the sel as tt_rotation
            mc.group(n="tt_rotation")
            # mc.parent(sel, "tt_rotation")
            mc.xform("tt_rotation", rotatePivot=[0, 0, 0], worldSpace=1)
            # key the tt_rotation group
            mc.setKeyframe("tt_rotation",
                           value=0,
                           t=0,
                           itt="linear",
                           ott="linear",
                           at="rotateY")
            mc.setKeyframe('tt_rotation',
                           v=360,
                           t=120,
                           itt='linear',
                           ott='linear',
                           at='rotateY')
            # set animation range
            mc.playbackOptions(minTime=0, animationStartTime=0)
            mc.playbackOptions(maxTime=120, animationEndTime=120)
            bb = bounding_by_frame([0, 120], ['tt_rotation'])
            box = create_warp_box_bounding(bb)
            view = OpenMayaUI.M3dView.active3dView()
            cam = OpenMaya.MDagPath()
            view.getCamera(cam)
            camPath = cam.fullPathName()
            # duplicate a camera
            new_camera = mc.duplicate(camPath)[0]
            mc.rename(new_camera, "tt_camera")
            # look though the camera
            mc.viewFit("tt_camera",
                       fitFactor=mc.getAttr('defaultResolution.pixelAspect') /
                       mc.getAttr('defaultResolution.deviceAspectRatio') * 1.2)
            #center = mc.objectCenter(box)
            #distance = max([abs(each) for each in bb])
            #distance *= 2.42
            #cam_ = mc.listRelatives(camPath,parent=True)[0]
            #mc.setAttr("%s.translateX" % cam_,center[0])
            #mc.setAttr("%s.translateY" % cam_,center[1])
            #mc.setAttr("%s.translateZ" % cam_,center[2])
            #mc.camera(camPath,e=True,centerOfInterest=distance)
            mc.delete(box)
            return True
    else:
        logging.error('No object selected, please select an object')
        return False
def fitCamera(*args):


	cam = "cameraForShapes1"

	cmds.viewFit( cam,  f=0.75)
	cmds.setAttr(cam + '.overrideEnabled', 1)
	cmds.setAttr (cam + '.overrideDisplayType', 2)
	cmds.select(clear=True)
Beispiel #31
0
 def cleanMe(self): 
     cmds.viewFit()
     object = pm.ls(tr=True)[0:6]
     for x in object:
         pm.select(x)
         pm.polyNormalPerVertex(x, ufn=True)
         pm.polySoftEdge(x, a=180, ch=1)
         pm.bakePartialHistory(x, ppt=True)
         pm.select(cl=True)
def YupZup():
    if cmds.upAxis(q=True, axis=True) == "y":
        cmds.upAxis(ax="z", rv=True)
    else:
        cmds.upAxis(ax="y", rv=True)

    for cam in cmds.listCameras():
        cmds.viewSet(cam, animate=False, home=True)

    cmds.viewFit(all=True)
def YupZup():
    if cmds.upAxis(q=True, axis=True) == "y":
        cmds.upAxis(ax="z", rv=True)
    else:
        cmds.upAxis(ax="y", rv=True)

    for cam in cmds.listCameras():
        cmds.viewSet(cam, animate=False, home=True)

    cmds.viewFit(all=True)
Beispiel #34
0
def create_camera(model):
    """Create the camera to focus on the mode.

    Arguments:
        model(unicode): Model to fit in view.
    """
    qc_camera = cmds.camera(name="QC_Camera")
    qc_camera_shape = qc_camera[1]
    cmds.select(model)
    cmds.viewFit(qc_camera_shape, fitFactor=0.8)
    return qc_camera[0]
Beispiel #35
0
def cleanup():
    '''Closes all windows/panels and sets viewport to bounding box.'''
    win_exceptions = [
        'MayaWindow', 'clToolBoxWindow', 'clOutlinerWindow',
        'clShowConnectionsWindow'
    ]
    windows = cmds.lsUI(windows=True)
    windows = list(set(windows).difference(win_exceptions))
    for w in windows:
        cmds.deleteUI(w)
    clear_panels()
    for p in ['modelPanel1', 'modelPanel2', 'modelPanel3', 'modelPanel4']:
        cmds.modelEditor(p, e=True, displayAppearance='boundingBox')

    for func in [
            lambda *args: cmds.setAttr(
                'Transform_Ctrl.GeoRes',
                cmds.attributeQuery(
                    'GeoRes', n='Transform_Ctrl', listEnum=True)[0].split(':').
                index('Proxy')),
            lambda *args: cmds.setAttr('Transform_Ctrl.GeoVis', 1),
            lambda *args: cmds.setAttr('Transform_Ctrl.GeoSmooth', 0),
            lambda *args: cmds.setAttr('COG_Ctrl.PivotCtrlVis', 0),
            lambda *args: cmds.setAttr('COG_Ctrl.BendCtrlVis', 0),
            lambda *args: cmds.setAttr('COG_Ctrl.SquashCtrlVis', 0),
            lambda *args: cmds.setAttr('COG_Ctrl.DefCtrlVis', 0),
            lambda *args: cmds.setAttr('Smooth.visibility', 1),
            lambda *args: cmds.setAttr('NoSmooth.visibility', 1),
            lambda *args: cmds.setAttr('Geo_Layer.visibility', 1),
            lambda *args: cmds.setAttr('Geometry_Layer.visibility', 1),
            lambda *args: cmds.setAttr('Controls_Layer.visibility', 1),
            lambda *args: cmds.setAttr('LgtRg_Layer.visibility', 1),
            lambda *args: cmds.setAttr('Smooth.displayType', 0),
            lambda *args: cmds.setAttr('NoSmooth.displayType', 0),
            lambda *args: cmds.setAttr('Geo_Layer.displayType', 2),
            lambda *args: cmds.setAttr('Geometry_Layer.displayType', 2),
            lambda *args: cmds.setAttr('Controls_Layer.displayType', 0),
            lambda *args: cmds.setAttr('LgtRg_Layer.displayType', 0),
            lambda *args: cmds.setAttr('Transform_Ctrl.t', 0, 0, 0),
            lambda *args: cmds.setAttr('Transform_Ctrl.r', 0, 0, 0),
            lambda *args: cmds.setAttr('Transform_Ctrl.s', 1, 1, 1),
            lambda *args: cmds.setAttr('COG_Ctrl.t', 0, 0, 0),
            lambda *args: cmds.setAttr('COG_Ctrl.r', 0, 0, 0),
            lambda *args: cmds.setAttr('COG_Ctrl.s', 1, 1, 1),
            lambda *args: cmds.setAttr('COG_Pivot_Ctrl.t', 0, 0, 0)
    ]:
        try:
            func()
        except:
            pass
    cmds.viewFit(allObjects=True, animate=False, f=.9)
    return
    def objectSel(self, item):
        global objs
        items = self.objectQList.selectedItems()
        objs = []
        for i in list(items):
            objs.append(i.text())
        self.statusBar.showMessage(str(objs), 4000)

        cmds.showHidden(grpTemp + '*')
        cmds.select(objs)
        cmds.isolateSelect(viewer, s=False)
        cmds.isolateSelect(viewer, s=True)
        cmds.viewFit(objectViewerCam)
    def addCharacter(self, close, *args):
        project = cmds.optionMenu(self.widgets["project"], q=True, value=True)
        selectedCharacter = cmds.textScrollList(self.widgets["characterList"],
                                                q=True,
                                                si=True)[0]
        rigPath = self.mayaToolsDir + "/General/ART/Projects/" + project + "/AnimRigs/" + selectedCharacter + ".mb"

        #find existing namespaces in scene
        namespaces = cmds.namespaceInfo(listOnlyNamespaces=True)

        #reference the rig file
        cmds.file(rigPath,
                  r=True,
                  type="mayaBinary",
                  loadReferenceDepth="all",
                  namespace=selectedCharacter,
                  options="v=0")

        #clear selection and fit view
        cmds.select(clear=True)

        #query autoKeyFrame state
        if not cmds.autoKeyframe(q=True, state=True):
            cmds.viewFit()
        #cmds.viewFit()
        panels = cmds.getPanel(type='modelPanel')

        #turn on smooth shading
        for panel in panels:
            editor = cmds.modelPanel(panel, q=True, modelEditor=True)
            cmds.modelEditor(editor,
                             edit=True,
                             displayAppearance="smoothShaded",
                             displayTextures=True,
                             textures=True)

        #find new namespaces in scene (this is here in case I need to do something later and I need the new name that was created)
        newCharacterName = selectedCharacter
        newNamespaces = cmds.namespaceInfo(listOnlyNamespaces=True)

        for name in newNamespaces:
            if name not in namespaces:
                newCharacterName = name

        #launch UI
        import ART_animationUI
        reload(ART_animationUI)
        ART_animationUI.AnimationUI()

        if close:
            cmds.deleteUI(self.widgets["window"])
Beispiel #38
0
def snapShot(output_folder, isolate=True, fit=False):
    """ Generate viewport snapshot.
	"""
    # Get current selection, frame and panel
    currentSel = mc.ls(sl=True)
    currentFrame = mc.currentTime(q=True)
    currentPanel = mc.playblast(ae=True)

    # Isolate the current object
    if isolate:
        mc.isolateSelect(currentPanel, state=1)
        mc.isolateSelect(currentPanel, addSelected=True)

    # Frame view to selection
    if fit:
        mc.viewFit(fitFactor=1)

    # Store current selection and deselect all
    mc.select(cl=True)

    # Generate playblast
    mc.playblast(
        completeFilename=os.path.join(output_folder, 'preview.jpg'),
        #mc.playblast(filename=os.path.join(output_folder, 'preview'),
        frame=(currentFrame),
        framePadding=4,
        rawFrameNumbers=True,
        width=512,
        height=288,
        percent=100,
        format='image',
        compression='jpg',
        quality=90,
        viewer=False,
        offScreen=True,
        clearCache=True,
        showOrnaments=False)

    # Turn off isolate selection
    if isolate:
        mc.isolateSelect(currentPanel, state=0)

    # Reset view
    if fit:
        mc.viewSet(previousView=True)

    # Reselect original selection
    for sel in currentSel:
        mc.select(sel, add=True)
Beispiel #39
0
 def createCam(s):
     if not cmds.objExists(s.camName):
         s.camera = cmds.camera(n=s.camName)[0]
     else:
         s.camera = cmds.ls(s.camName)[0]
     cmds.viewSet(s.camera, p=True) # Move camera to perspective position
     sel = cmds.ls(sl=True)
     objs = [a for a in s.data if cmds.objExists(a)]
     if objs: cmds.select(objs, r=True)
     cmds.viewFit(s.camera, f=0.5)
     cmds.select(sel, r=True)
     cmds.setAttr("%s.focalLength" % s.camera, 500)
     cmds.setAttr("%s.horizontalFilmAperture" % s.camera, 5)
     cmds.setAttr("%s.verticalFilmAperture" % s.camera, 5)
     cmds.setAttr("%s.visibility" % s.camera, 0)
Beispiel #40
0
 def __createPreviewShape(self):
     selected_shape = self.__get_selectedShape()
     
     if selected_shape:
         if self.preview_curve is None or not cmds.objExists(self.preview_curve):
             self.preview_curve = createCurve(selected_shape, '%s:PREVIEW_CRV' % self.ns)
             
             cmds.parent(self.preview_curve, self.grp)
         else:
             replaceCurve(selected_shape, [self.preview_curve])
     else:
         if cmds.objExists(self.preview_curve):
             cmds.delete(self.preview_curve)
             self.preview_curve = None
             
     self.__isolateSelectedInViewport()
     cam_shape = cmds.listRelatives(self.viewport_cam, shapes=True)[0]
     cmds.viewFit(cam_shape, namespace=':')
Beispiel #41
0
    def prep_view(self):
        """
        prep current view panel with required settings for screen grab
        """
        mel.eval("lookThroughModelPanel %s %s" % (self.camera, self._current_panel))
        if self._isolate_objs:
            # mel.eval('enableIsolateSelect %s %s;' %
            #                         (self._current_panel, self._isolate_objs))
            mc.isolateSelect(self._current_panel, state=self._isolate_objs)
            mc.isolateSelect(self._current_panel, addSelected=True)
            mc.viewFit()

        mc.select(clear=True)

        # attempt to use Viewport 2.0 for better image
        try:
            mc.modelEditor(self._current_panel, edit=True, rendererName="vp2Renderer")
        except Exception, e:
            raise "Issue activating Viewport 2.0. %s" % e
def new_scene(force=True):
	""" Open new scene.
    Set all scene variables and options correctly.
	"""
	axis = os.getenv("UPAXIS")
	units = os.getenv("UNITS")
    # Force new open
	if force:
		cmds.file(f=force, new=1)
	else:
		mel.eval('saveChanges("file -f -new")')
		cmds.file(f=force, new=1)
	# Up Axis
	if cmds.upAxis(q=1, axis=1).capitalize() != axis.capitalize():
		cmds.upAxis(axis=axis, rv=1)
	# FPS
	intFps=int(os.getenv("FPS"))
	fps=fps_val(intFps)
	cmds.currentUnit(time=fps, ua=0)
	# Units
	cmds.currentUnit(l=units)
	# Set Clipping Planes
	cmds.setAttr("perspShape.nearClipPlane", 0.001)
	cmds.setAttr("perspShape.farClipPlane", 1000)
	cmds.setAttr("sideShape.nearClipPlane", 0.001)
	cmds.setAttr("sideShape.farClipPlane", 1000)
	cmds.setAttr("topShape.nearClipPlane", 0.001)
	cmds.setAttr("topShape.farClipPlane", 1000)
	cmds.setAttr("frontShape.nearClipPlane", 0.001)
	cmds.setAttr("frontShape.farClipPlane", 1000)
	# Grid
	if units == "meter":
		cmds.grid(size=10, divisions=5, sp=5)
	elif units == "centimeter":
		cmds.grid(size=100, divisions=50, sp=5)
	elif units == "millimeter":
		cmds.grid(size=1000, divisions=500, sp=5)
    # Set timeline to first frame 
	cmds.currentTime(1)
	cmds.playbackOptions(aet=100, min=1, max=100)
    # Fit view
	cmds.viewFit(an=1, all=1)
Beispiel #43
0
def clear() :
    
    global rigidbody
    global camera
    global lastCam
    global currentPanel
    global selection
    
    if camera and lastCam and currentPanel :
        pos = m.xform(camera, q=True, t=True, ws=True)
        ori = m.xform(camera, q=True, ro=True, ws=True)
        m.xform(lastCam, t=pos, ws=True)
        m.xform(lastCam, ro=ori, ws=True)
        m.setAttr( lastCam + ".rz", 0)
        
        m.modelPanel( currentPanel, cam=lastCam, e=True)   
        m.select( selection )
        m.viewFit()
        
    
    for i in [ rigidbody, camera ] :        
        if i and m.objExists( i ) : m.delete(i)
        i = None
Beispiel #44
0
def doScreenGrab(node, currentAssetCategory="environments"):
    '''Saves out an image of the asset.
    '''
    nodeName = node.rpartition("|")[2]
    currentAssetLibrary = ddConstants.ASSET_DIRECTORIES[currentAssetCategory]
    currentImageLibrary = ddConstants.IMAGE_DIRECTORIES[currentAssetCategory]
    charType = { "hero": "hero", "bg": "background", "sec": "secondary" }
    chesspieceTypes = ["CPF", "CPO", "CPD", "CPS"]
    
    invalidNodes = ddCheckNames.do(nodes=node, currentAssetCategory=currentAssetCategory)
    if invalidNodes:
        sys.stdout.write("Legalize names before taking screen grab.\n")
        return
    
    dirs = list()
    version = ""
    divider = ""
    dividerGRP = ""
    
    imagePath = currentAssetLibrary
    smallImagesPath = currentImageLibrary 
    
    if currentAssetCategory == "environments":
        dirs = nodeName.rpartition("|")[2].split("_GRP")[0].split("_")
        version = nodeName.rpartition("|")[2].split("_GRP_")[1].split("_")[0]
        
        imagePath = currentAssetLibrary
        smallImagesPath = currentImageLibrary 
        
        for i in range(len(dirs)):
            if not os.path.isdir(smallImagesPath):
                os.mkdir(smallImagesPath)
            imagePath = os.path.join(imagePath, dirs[i])
            smallImagesPath = os.path.join(smallImagesPath, dirs[i])

        imagePath = "%s_%s.jpg" % (imagePath, version)
        smallImagesPath = "%s_%s.jpg" % (smallImagesPath, version)

    elif currentAssetCategory == "characters":
        nodeSplits = nodeName.split("_")
        for nodeSplit in nodeSplits:
            if nodeSplit in chesspieceTypes:
                divider = nodeSplit
                
        dirParts = nodeName.split("_%s" % divider)[0].split("_")
        imagePath = currentAssetLibrary
        smallImagesPath = currentImageLibrary 

        dividerGRP = "%s_GRP" % divider
        version = nodeName.split("_%s_" % dividerGRP)[1].split("_")[0]

        for i in range(2):
            # eg bg (background) and buffalo
            if dirParts[i+1] in charType.keys():
                dirs.append(charType[dirParts[i+1]])
            elif re.search('^[A-Z]+', dirParts[i+1]):
                print '%s_%s' % (dirParts[i+1], dirParts[i+2])
                dirs.append('%s_%s' % (dirParts[i+1], dirParts[i+2]))
            else:
                dirs.append(dirParts[i+1])

        fileName = nodeName.rpartition("_%s" % dividerGRP)[0].replace("%s_%s_" % (dirParts[0], dirParts[1]), "")
        fileVersionName = "%s_%s_%s" % (fileName, divider, version) 
            
        for i in range(len(dirs)):
            if not os.path.isdir(smallImagesPath):
                os.mkdir(smallImagesPath)
            imagePath = os.path.join(imagePath, dirs[i])
            smallImagesPath = os.path.join(smallImagesPath, dirs[i])

        imagePath = os.path.join(imagePath, "chesspiece", "published")
        imagePath = os.path.join(imagePath, "%s.jpg" % fileVersionName)
        smallImagesPath = os.path.join(smallImagesPath.rpartition(os.sep)[0], "%s.jpg" % fileVersionName)
        
        
    cmds.select(node, replace=True)
    
    currentPanel = "modelPanel4"
    if not cmds.modelEditor(currentPanel, exists=True):
        currentPanel = cmds.getPanel(withFocus=True)
        
    mel.eval('enableIsolateSelect %s true;' % currentPanel)
    cmds.isolateSelect(currentPanel, state=1)
    mel.eval('lookThroughModelPanel persp %s' % currentPanel)
    cmds.viewFit()
    if not currentAssetCategory == "characters":
        cmds.setAttr("perspShape.preScale", 1.5)
    nearClipPlane = cmds.getAttr("perspShape.nearClipPlane")
    farClipPlane = cmds.getAttr("perspShape.farClipPlane")
    cmds.setAttr("perspShape.nearClipPlane", 0.1)
    cmds.setAttr("perspShape.farClipPlane", 100000)
    
    cmds.select(clear=True)
    cmds.modelEditor(currentPanel, edit=True, displayAppearance="smoothShaded", displayTextures=True, displayLights="default")
    
    cmds.playblast(
        frame=1, format="image", completeFilename=smallImagesPath, clearCache=True, viewer=False, 
        showOrnaments=False, compression="jpg", quality=40, percent=100, widthHeight=[144,144]
        )
    
    cmds.playblast(
        frame=1, format="image", completeFilename=imagePath, clearCache=True, viewer=False, 
        showOrnaments=False, compression="jpg", quality=40, percent=100, widthHeight=[1024,768]
        )
    
    cmds.isolateSelect(currentPanel, state=0)
    cmds.setAttr("perspShape.preScale", 1.0)
    cmds.setAttr("perspShape.nearClipPlane", nearClipPlane)
    cmds.setAttr("perspShape.farClipPlane", farClipPlane)
    
    sys.stdout.write("Screen grab saved to: %s\n" % imagePath)
    mc.setAttr("ten_robe_model_main_TEN_ROBE_HERO.translateZ", tz)
    mc.setAttr("ten_robe_model_main_TEN_ROBE_HERO.rotateX", rx)
    mc.setAttr("ten_robe_model_main_TEN_ROBE_HERO.rotateY", ry)
    mc.setAttr("ten_robe_model_main_TEN_ROBE_HERO.rotateZ", rz)
    
generateScene()

#######################
## Set Up Simulation ##
#######################

#This code is brought to you in part by Brennan Mitchell and viewers like you. Thank you.


mc.select('ten_robe_sim_model_main_ten_collide_body', replace=True)
mc.viewFit() #Snap View to Body Collider
mc.playbackOptions(animationStartTime=STARTPRE)
mc.playbackOptions(minTime=STARTPRE)
mc.currentTime(STARTPRE)

#Wrap Colliders to Alembic
mc.select('ten_robe_sim_model_main_ten_collide_body', replace=True) #Wrap Body
mc.select('TEN_ANIM', add=True)
mc.CreateWrap()
#mc.setAttr('wrap1.exclusiveBind', 0)

mc.select('ten_robe_sim_model_main_ten_collide_mitten_l', replace=True) #Wrap Left Mitten
mc.select('TEN_ANIM', add=True)
mc.CreateWrap()
#mc.setAttr('wrap2.exclusiveBind', 0)
Beispiel #46
0
def do(nodes=None):
    """
    Publish shader attached to nodes.
    @param nodes: One or more GEO or shader nodes.
    """
    currentShaderLibrary = getAssetShaderLibrary()

    # Swatches file storage location.
    if not os.path.isdir(currentShaderLibrary):
        raise Exception("Directory %s does not exist" % currentShaderLibrary)

    if not nodes:
        nodes = cmds.ls(selection=True, long=True)
    # If still no nodes...
    if not nodes:
        sys.stdout.write("Select a mesh with an attached shader to be published.\n")

    if not isinstance(nodes, list):
        nodes = [nodes]

    for node in nodes:
        currentNode = node

        # Check if referenced.
        if cmds.referenceQuery(node, isNodeReferenced=True):
            confirm = cmds.confirmDialog(
                title="Warning",
                messageAlign="center",
                message="Cannot publish a referenced shader. Try importing from reference.",
                button=["Ok"],
                defaultButton="Ok",
                cancelButton="Ok",
                dismissString="Ok",
            )
            if confirm == "Ok":
                return

        # If node is not a mesh, look for a shading engine.
        if not cmds.listRelatives(currentNode, shapes=True):
            # Check if node is a GRP with one mesh below.
            children = cmds.listRelatives(currentNode, children=True)
            if children:
                if len(children) == 1 and cmds.listRelatives(children[0], shapes=True):
                    currentNode = children[0]
                else:
                    confirm = cmds.confirmDialog(
                        title="Warning",
                        messageAlign="center",
                        message="Unable to determine which shader to publish.",
                        button=["Ok"],
                        defaultButton="Ok",
                        cancelButton="Ok",
                        dismissString="Ok",
                    )
                    if confirm == "Ok":
                        return
            else:
                # Look for a connected shading engine.
                shadingEngines = [
                    x for x in (cmds.listHistory(currentNode, future=True) or []) if cmds.nodeType(x) == "shadingEngine"
                ]
                if shadingEngines:
                    currentNode = shadingEngines[0]
                else:
                    confirm = cmds.confirmDialog(
                        title="Warning",
                        messageAlign="center",
                        message="Unable to find a shader to publish.",
                        button=["Ok"],
                        defaultButton="Ok",
                        cancelButton="Ok",
                        dismissString="Ok",
                    )
                    if confirm == "Ok":
                        return

        # Get the shader category.
        directory = getCategoryFolder()
        shadingEngine = doNameShaders(node=currentNode, directory=directory)
        if not shadingEngine:
            continue

        rootName = shadingEngine.replace("_SG", "")

        # Create swatch.
        swatch = cmds.polyPlane(name="%s_Swatch" % rootName, width=1, height=1, sx=1, sy=1, ax=[0, 0, 1], ch=0)
        swatchShape = cmds.listRelatives(swatch, shapes=True, path=True)
        cmds.sets(swatchShape, forceElement=shadingEngine)

        imagePath = os.path.join(directory, "%s.png" % rootName)

        # Create snapshot.
        screenGrabCam = cmds.camera(centerOfInterest=378.926)
        cmds.setAttr("%s.tz" % screenGrabCam[0], 378.926)
        cmds.setAttr("%s.orthographic" % screenGrabCam[1], 1)

        cmds.select(swatch, replace=True)

        currentPanel = "modelPanel4"
        if not cmds.modelEditor(currentPanel, exists=True):
            currentPanel = cmds.getPanel(withFocus=True)

        mel.eval("enableIsolateSelect %s true;" % currentPanel)
        cmds.isolateSelect(currentPanel, state=1)
        mel.eval("lookThroughModelPanel %s %s" % (screenGrabCam[0], currentPanel))

        cmds.viewFit()
        cmds.setAttr("%s.orthographicWidth" % screenGrabCam[1], 1)
        cmds.select(clear=True)
        gridValue = cmds.modelEditor(currentPanel, query=True, grid=True)
        cmds.modelEditor(
            currentPanel,
            edit=True,
            displayAppearance="smoothShaded",
            displayTextures=True,
            displayLights="default",
            grid=False,
        )
        cmds.playblast(
            frame=1,
            format="image",
            completeFilename=imagePath,
            clearCache=True,
            viewer=False,
            showOrnaments=False,
            compression="png",
            quality=40,
            percent=100,
            widthHeight=[144, 144],
        )
        cmds.isolateSelect(currentPanel, state=0)
        cmds.modelEditor(currentPanel, edit=True, grid=gridValue)
        mel.eval("lookThroughModelPanel persp %s" % currentPanel)
        cmds.delete(screenGrabCam[0])
        sys.stdout.write("Screen grab of swatch saved to: %s\n" % imagePath)

        # Delete unknown nodes (mental ray).
        ddDeleteUnknownNodes.do()

        # Export swatch file.
        swatchPath = os.path.join(directory, "%s.ma" % rootName)
        cmds.select(swatch, replace=True)
        exportedFile = cmds.file(swatchPath, type="mayaAscii", exportSelected=True, force=True)
        ddRemoveRequires.do(path=swatchPath)

        if exportedFile:
            cmds.delete(swatch)
    def renderImagesFromCameras(self, generalSettings, fluidIndex, progress, progressIndex):
        """
        :type generalSettings: MayaCacheCmdSettings
        """
        listRenderedImages = list()

        self.viewFromCamPosition('PERSPECTIVE', generalSettings.fluidBoxName)

        renderImageFlag = False    # True --> Images are rendered
        if (generalSettings.cam_perspective) == True | (generalSettings.cam_viewcube == True) | (generalSettings.cam_custom_name != None) | (generalSettings.cam_rotation != 0):
            renderImageFlag = True

        # Create image folder
        path = generalSettings.outputPath + "/" + str(fluidIndex) + "/images/"
        if not os.path.exists(path) & renderImageFlag:
            os.mkdir(path)

        # Settings
        fileName = "image"
        start = str(int(round(generalSettings.animationStartTime)))
        end = str(int(round(generalSettings.animationEndTime)))

        if generalSettings.cam_perspective:
            self.viewFromCamPosition('PERSPECTIVE', generalSettings.fluidBoxName)
            path = generalSettings.outputPath + "/" + str(fluidIndex) + "/images/perspective/"
            listRenderedImages.append(path)
            os.mkdir(path)
            #self.executeMELRemderCmd(path, fileName, start, end, resW, resH)
            mel.eval('RenderIntoNewWindow')

            # Rendering
            try:
                self.renderImages(path, fileName, start, end)
            except Exception as e:
                raise e
                return

            progressIndex += 1
            progress.setValue(progressIndex)

        if (generalSettings.cam_viewcube == True):
            os.mkdir(generalSettings.outputPath + "/" + str(fluidIndex) + "/images/viewcube/")

            # FRONT
            self.viewFromCamPosition('FRONT', generalSettings.fluidBoxName)
            path = generalSettings.outputPath + "/" + str(fluidIndex) + "/images/viewcube/FRONT/"
            listRenderedImages.append(path)
            os.mkdir(path)
            #self.renderImages(path, fileName, start, end)
            try:
                self.renderImages(path, fileName, start, end)
            except Exception as e:
                raise e
                return

            progressIndex += 1
            progress.setValue(progressIndex)

            # RIGHT
            self.viewFromCamPosition('RIGHT', generalSettings.fluidBoxName)
            path = generalSettings.outputPath + "/" + str(fluidIndex) + "/images/viewcube/SIDE/"
            listRenderedImages.append(path)
            os.mkdir(path)
            #self.renderImages(path, fileName, start, end)
            try:
                self.renderImages(path, fileName, start, end)
            except Exception as e:
                raise e
                return
            progressIndex += 1
            progress.setValue(progressIndex)

            # TOP
            self.viewFromCamPosition('TOP', generalSettings.fluidBoxName)
            path = generalSettings.outputPath + "/" + str(fluidIndex) + "/images/viewcube/TOP/"
            listRenderedImages.append(path)
            os.mkdir(path)
            self.renderImages(path, fileName, start, end)
            progressIndex += 1
            progress.setValue(progressIndex)

        if (generalSettings._cam_custom_name != None):
            # View from camera
            try:
                cmdStr = "lookThroughModelPanel" + " " + str(generalSettings.cam_custom_name) + " " + "modelPanel4;"
                mel.eval(cmdStr)
            except Exception as er:
                self.lgr.error('An error occured while camera was changed! Details: %s', er.message)
                self.lgr.error('Could not look through camera %s', generalSettings._cam_custom_name)
                raise Exception(er.message)
                return

            #cmdStr = "lookThroughModelPanel" + " " + str(generalSettings.cam_custom_name) + " " + "modelPanel4;"
            #mel.eval(cmdStr)

            path = generalSettings.outputPath + "/" + str(fluidIndex) + "/images/custom/"
            os.mkdir(path)

            mel.eval('RenderIntoNewWindow')
            #self.renderImages(path, fileName, start, end)
            try:
                self.renderImages(path, fileName, start, end)
            except Exception as e:
                raise e
                return
            progressIndex += 1
            progress.setValue(progressIndex)
            listRenderedImages.append(path)

            self.viewFromCamPosition('PERSPECTIVE', generalSettings.fluidBoxName)

        if generalSettings.cam_rotation != 0:

            # Change to perspective camera
            self.viewFromCamPosition('PERSPECTIVE', generalSettings.fluidBoxName)
            cmds.viewFit('persp', an=False)

            path = generalSettings.outputPath + "/" + str(fluidIndex) + "/images/rotation/"
            os.mkdir(path)

            # Rotate
            stepAcc = 0
            valueY = int(round(float(generalSettings.cam_rotation)))

            while stepAcc < 360:
                # Rotate camera
                cmds.setAttr('persp.rotateY',  stepAcc)
                cmds.viewFit('persp', an=False)
                #cmds.dolly(d=-15)

                path = generalSettings.outputPath + "/" + str(fluidIndex) + "/images/rotation/" + "deg_" + str(stepAcc) + "/"
                os.mkdir(path)

                try:
                    self.renderImages(path, fileName, start, end)
                except Exception as e:
                    raise e
                    return

                listRenderedImages.append(path)
                stepAcc = stepAcc + valueY

            progressIndex += 1
            progress.setValue(progressIndex)

        cmds.viewFit('persp', an=False)

        return [int(progressIndex), listRenderedImages]
Beispiel #48
0
def boxParty(bpm, songLen, numBoxes):
	cmds.camera()
	cmds.rename('partyCam')
	
	bps = bpm/60.0
	fpb = 24/bps
	cmds.polyCube(name='boxMain', w=1,h=1,d=1)
	
	for i in range(0,numBoxes):
		cmds.select('boxMain')
		cmds.instance(name= 'box' + str(i))
		randX = random.random()*10 - 5
		randY = random.random()*10 - 5
		randZ = random.random()*10 - 5
		cmds.xform(t=(randX,randY,randZ))
	
	cmds.hide('boxMain')
	cmds.select([node for node in cmds.ls() if 'box' in node and 'Shape' not in node])
	cmds.group(name='dancingBoxes')
	cmds.select('dancingBoxes')
	cmds.viewFit('partyCamShape')
	
	#for each beat
	framesKeyed = 0
	elevAngle = 0
	#moveToggle = True
	
	beat = 1
	while framesKeyed/24 < songLen:
		cmds.currentTime(framesKeyed-fpb+4) # set time to get latest position
		for i in range(0,numBoxes):
		#pulsing
			cmds.select('box'+str(i))
			cmds.setKeyframe(at='scaleX', value=1, t=framesKeyed-2)
			cmds.setKeyframe(at='scaleX', value=1.7, t=framesKeyed)
			cmds.setKeyframe(at='scaleX', value=1, t=framesKeyed+2)
			
			cmds.setKeyframe(at='scaleY', value=1, t=framesKeyed-2)
			cmds.setKeyframe(at='scaleY', value=1.7, t=framesKeyed)
			cmds.setKeyframe(at='scaleY', value=1, t=framesKeyed+2)
			
			cmds.setKeyframe(at='scaleZ', value=1, t=framesKeyed-2)
			cmds.setKeyframe(at='scaleZ', value=1.7, t=framesKeyed)
			cmds.setKeyframe(at='scaleZ', value=1, t=framesKeyed+2)
	
		#translating
			if beat == 1 or beat == 3:
				cmds.select('box' + str(i))
				pos = cmds.xform(ws=True, q=True, t=True)
				direction = random.randint(0,2)
				
				displacement = random.randint(0,10) - 5
				
				#try to keep within borders
				while pos[direction] + displacement > 6 or pos[direction] + displacement < -6:
					displacement = random.randint(0,10) - 5
					direction = random.randint(0,2)
				
				if direction == 0: #going in x direction
					cmds.setKeyframe(at='translateX', value = pos[0], t = framesKeyed)
					cmds.setKeyframe(at='translateX', value = pos[0] + displacement, t = framesKeyed+4)
					cmds.setKeyframe(at='translateY', value = pos[1], t=framesKeyed)
					cmds.setKeyframe(at='translateY', value = pos[1], t=framesKeyed+4)
					cmds.setKeyframe(at='translateZ', value = pos[2], t=framesKeyed)
					cmds.setKeyframe(at='translateZ', value = pos[2], t=framesKeyed+4)
				elif direction == 1: #going in y direction
					cmds.setKeyframe(at='translateY', value = pos[1], t = framesKeyed)
					cmds.setKeyframe(at='translateY', value = pos[1] + displacement, t = framesKeyed+4)
					cmds.setKeyframe(at='translateX', value = pos[0], t=framesKeyed)
					cmds.setKeyframe(at='translateX', value = pos[0], t=framesKeyed+4)
					cmds.setKeyframe(at='translateZ', value = pos[2], t=framesKeyed)
					cmds.setKeyframe(at='translateZ', value = pos[2], t=framesKeyed+4)
				else: #going in z direction
					cmds.setKeyframe(at='translateZ', value = pos[2], t = framesKeyed)
					cmds.setKeyframe(at='translateZ', value = pos[2] + displacement, t = framesKeyed+4)
					cmds.setKeyframe(at='translateX', value = pos[0], t=framesKeyed)
					cmds.setKeyframe(at='translateX', value = pos[0], t=framesKeyed+4)
					cmds.setKeyframe(at='translateY', value = pos[1], t=framesKeyed)
					cmds.setKeyframe(at='translateY', value = pos[1], t=framesKeyed+4)
			
		#key partyCam every 4 beats
		if beat == 1:
			cmds.setKeyframe('partyCam', at='translateX', t = framesKeyed)
			cmds.setKeyframe('partyCam', at='translateY', t = framesKeyed)
			cmds.setKeyframe('partyCam', at='translateZ', t = framesKeyed)
			cmds.setKeyframe('partyCam', at='rotateX', t = framesKeyed)
			cmds.setKeyframe('partyCam', at='rotateY', t = framesKeyed)
			cmds.setKeyframe('partyCam', at='rotateZ', t = framesKeyed)

			elevAngleChange = random.random()*70 - 35
			aAngleChange = random.random()* 360 - 180
			if elevAngle + elevAngleChange > 70 or elevAngle + elevAngleChange < -20:
				elevAngle = elevAngle - elevAngle
			else:
				elevAngle = elevAngle + elevAngleChange
			
			cmds.tumble('partyCamShape', ea=elevAngle, aa=aAngleChange)
			cmds.setKeyframe('partyCam', at='translateX', t = framesKeyed+4)
			cmds.setKeyframe('partyCam', at='translateY', t = framesKeyed+4)
			cmds.setKeyframe('partyCam', at='translateZ', t = framesKeyed+4)
			cmds.setKeyframe('partyCam', at='rotateX', t = framesKeyed+4)
			cmds.setKeyframe('partyCam', at='rotateY', t = framesKeyed+4)
			cmds.setKeyframe('partyCam', at='rotateZ', t = framesKeyed+4)
		
		if beat == 4:
			beat = 1
		else: 
			beat += 1
		framesKeyed += fpb
 def rotateCamerY(valueY):
     stepAcc = 0
     while stepAcc < 360:
         stepAcc = stepAcc + valueY
         cmds.setAttr('persp.rotateY',  stepAcc)
         cmds.viewFit('persp', an=False)