foregroundRender_render

# -*- coding: utf-8 -*-
# ***************************************
#
# Author: Xinghai Zhao
# Created on: 2016.2.4  16:55:58
#
# ***************************************

'''
1.0.0:
render: use foregroundRender
    can use vray,hareward and mental ray renderer

tryRender: try foregroundRender except close Maya
'''

__version__ = '1.0.0'


import os,socket,logging
import cPickle as pickle

import bglobal,bjobsys

import maya.cmds as cmds
import maya.mel

import mayaSubmitQube.renderSetting


def getFormatType(format):
    format_dir = {'JPEG':'jpg','Tiff':'tiff',
                  'Maya IFF':'iff','Targa':'tga',
                  'PNG':'png','Custom Image Format':'exr',
                 }
    return format_dir.get(format) if format_dir.get(format) != None else 'png'



def render(startFrame = None,endFrame = None,frameStep = 1,
           render_dir = None,filename = None,
           renderLayer = None,camera = None,
           height = None,width = None,pixelAspectRatio = None,
           renderer = None,**kwargs):

    startFrame           = startFrame       if startFrame not in ['None'] else None
    endFrame             = endFrame         if endFrame not in ['None'] else None
    render_dir           = render_dir       if render_dir not in ['None'] else None
    filename             = filename         if filename not in ['None'] else None
    renderLayer          = renderLayer      if renderLayer not in ['None'] else None
    camera               = camera           if camera not in ['None'] else None
    renderer             = renderer         if renderer not in ['None'] else None
    try:
        height           = height           if int(height) not in ['None'] else None
    except:
        height           = None
    try:
        width            = width            if int(width) not in ['None'] else None
    except:
        width            = None
    try:
        frameStep        = frameStep        if float(frameStep) not in ['None'] else 1
    except:
        frameStep        = 1
    try:
        pixelAspectRatio = pixelAspectRatio if float(pixelAspectRatio) not in ['None'] else None
    except:
        pixelAspectRatio = None


    # ----------------------------------- render settings -------------------------------------- #
    scenepath = bglobal.toCurrent(cmds.file(q=True,sn = True))
    workspace = bglobal.toCurrent(cmds.workspace(q=True,fullName = True))
    # set render_dir
    if not render_dir:
        render_dir = '/'.join([workspace,'images'])

    if not filename:
        filename = os.path.basename(scenepath).rsplit('.',1)[0]

    render_dir = bglobal.toCurrent(render_dir)
    if not os.path.isdir(render_dir):
        try:
            os.makedirs(render_dir)
        except:
            raise Exception('can not make Folder named: %s ' % render_dir)

    # get frame
    if not startFrame:
        startFrame = cmds.currentTime(q = True)
    if not endFrame:
        endFrame = startFrame
    if endFrame < startFrame:
        endFrame = startFrame

    # set renderLayer
    if not renderLayer:
        renderLayer = cmds.editRenderLayerGlobals(q = True,currentRenderLayer = True)
    elif not renderLayer in cmds.ls(type = 'renderLayer'):
        _log = 'can not find renderLayer: %s' % renderLayer
        renderLayer = cmds.editRenderLayerGlobals(q = True,currentRenderLayer = True)
        logging.warning('%s,use %s' %(_log,renderLayer))
    else:
        if cmds.editRenderLayerGlobals(q = True,currentRenderLayer = True) != renderLayer:
            cmds.editRenderLayerGlobals(currentRenderLayer = renderLayer)

    # get camera
    if not camera:
        _cameras = [i for i in cmds.listCameras(p = True) if cmds.getAttr('%s.renderable' % i)]
        if _cameras:
            camera = _cameras[0]
        else:
            camera = 'persp'

    # load renderer
    if renderer:
        if renderer != cmds.getAttr('defaultRenderGlobals.currentRenderer'):
            renderer_dict = {'vray':'vrayformaya',
                             'arnold':'mtoa',
                             'mentalRay':'Mayatomr'}
            for key in renderer_dict.keys():
                if renderer == key:
                    if not cmds.pluginInfo(renderer_dict[key], q=True, l=True):
                        try:
                            cmds.loadPlugin(renderer_dict[key])
                            break
                        except:
                            raise Exception('can not load vray renderer')

        try:
            cmds.setAttr('defaultRenderGlobals.currentRenderer',renderer,type = 'string')
        except:
            raise Exception('error: set currentRenderer %s fail' % renderer)

    else:

        renderer = cmds.getAttr('defaultRenderGlobals.currentRenderer')

    # foreclose arnold
    if renderer in ['arnold']:
        raise Exception('error: foreground model can not use %s renderer' % renderer)

    #set width,height,pixelAspectRatio
    if width:
        if renderer == 'vray':
            cmds.setAttr('vraySettings.width',width)
        else:
            cmds.setAttr("defaultResolution.w",width)
    if height:
        if renderer == 'vray':
            cmds.setAttr('vraySettings.height',height)
        else:
            cmds.setAttr("defaultResolution.h",height)
    if pixelAspectRatio:
        if renderer == 'vray':
            cmds.setAttr('vraySettings.pixelAspect',pixelAspectRatio)
        else:
            cmds.setAttr("defaultResolution.pixelAspect",pixelAspectRatio)

    # set filename
    _pad = 4
    _format = 'png'
    if renderer == 'vray':
        _pad = cmds.getAttr('vraySettings.fileNamePadding')
        if cmds.getAttr('vraySettings.imageFormatStr'):
            _format = cmds.getAttr('vraySettings.imageFormatStr').split('(')[0].strip()
    else:
        _pad = cmds.getAttr('defaultRenderGlobals.extensionPadding')
        _format = getFormatType(cmds.getAttr('defaultRenderGlobals.imageFormat',asString = True))

    hostname = socket.gethostname()
    scenename = scenepath.replace('/','-')
    if not scenename:
        scenename = 'untitled'

    # get frame tmp path
    tmp_frame_path = '/'.join([os.path.dirname(scenepath),'%s_%s_%s' % (socket.gethostname(),scenepath.replace('/','_').replace(':','_'),'frame_tmp')])

    frame = startFrame
    while frame <= endFrame:

        # set frame tmp
        if not os.path.isfile(tmp_frame_path):
            _info_file = open(tmp_frame_path,'wb')
            pickle.dump({},_info_file)
            _info_file.close()

        _info_file = open(tmp_frame_path,'rb')
        _info = pickle.load(_info_file)
        _info_file.close()

        if _info.get('frame') == 'frame':
            if _info.get('try') != None:
                _info['try'] += 1
            else:
                _info['try'] = 1
        else:
            _info['frame'] = frame
            _info['try'] = 1

        _info['completed'] = False
        _info['startFrame'] = startFrame
        _info['frameStep'] = frameStep
        _info['endFrame'] = endFrame

        _info_file = open(tmp_frame_path,'wb')
        pickle.dump(_info,_info_file)
        _info_file.close()

        #set frame
        if cmds.currentTime(q = True) != frame:
            cmds.currentTime(frame)

        #get filename.frame
        _filename = '.'.join([filename,str(frame).zfill(_pad)])

        #set temp name
        if renderer == 'vray':
            #_filename += '_'.join([hostname,scenename,renderLayer,camera,str(frame)])
            cmds.setAttr('vraySettings.fileNamePrefix',
                     bglobal.toCurrent(os.path.join(render_dir,_filename)),
                     type = 'string')
        else:
            cmds.setAttr('defaultRenderGlobals.imageFilePrefix',_filename,type = 'string')

        # ------------------------------------------------------------------------------------------ #
        # --------------------------------------- render ------------------------------------------- #
        # open renderView
        if renderer == 'vray':
            maya.mel.eval('vray showVFB')
        else:
            cmds.RenderViewWindow()

        # rendering
        logging.info('start rendering frame: %s' % frame)
        if renderer == 'vray':
            maya.mel.eval('vrend -camera %s' % camera)
            while maya.mel.eval('vrend -isRendering'):
                time.sleep(10)
        else:
            maya.mel.eval('renderWindowRenderCamera("render","renderView","%s")' % camera)
        logging.info('frame: %s is finished' % frame)

        # ------------------------------------------------------------------------------------------ #
        # --------------------------------------saveImage------------------------------------------- #
        _target = ''
        if renderer == 'vray':
            _target = bglobal.toCurrent(os.path.join(render_dir,'.'.join([_filename,_format])))
            _source = bglobal.toCurrent(os.path.join(render_dir,'.'.join([_filename+'_tmp',_format])))
            if not os.path.isfile(_source):
                raise Exception('can not find render Temp')

            if os.path.isfile(_target):
                try:
                    os.remove(_target)
                except:
                    raise Exception('path: %s is exist' % _target)
            try:
                os.rename(_source,_target)
            except:
                raise Exception('can not save %s' % _save)
            #if cmds.getAttr('vraySettings.imageFormatStr') == 'exr (multichannel)':
            #    _save = '%s/%s.exr' % (render_dir,filename)
            #    maya.mel.eval('vray vfbControl -savemultiimage "%s";' % _save)
            #else:
            #    _save = '%s/%s.%s' % (render_dir,filename,format)
            #    maya.mel.eval('vray vfbControl -saveimage "%s";' % _save)

            #tmp = workspace + '/images/tmp'
            #if os.path.isdir(tmp):
            #    format = 'png'
            #    if cmds.getAttr('vraySettings.imageFormatStr'):
            #        format = cmds.getAttr('vraySettings.imageFormatStr').split('(')[0].strip()
            #    _fullname = '.'.join([_filename,format])
            #    for _dir in os.walk(tmp):
            #        for i in _dir[2]:
            #            if i == _fullname:
            #                _source = os.path.join(_dir[0],i)
            #                _target = os.path.join(render_dir,'.'.join([filename,format]))
            #                os.rename(_source,_target)

            #else:
                #raise Exception('error: setting fail')
        else:
            _target = '.'.join(['/'.join([render_dir,filename]),_format])
            if os.path.isfile(_target):
                try:
                    os.remove(_target)
                except:
                    raise Exception('path: %s is exist' % _target)
            try:
                maya.mel.eval('renderWindowSaveImageCallback "renderView" "%s" "%s"' %('/'.join([render_dir,_filename]),getFormatType(format)))
            except:
                raise Exception('can not save %s' % _target)

        logging.info('save image:%s' % _target)

        # set frame tmp
        _info_file = open(tmp_frame_path,'wb')
        _info['completed'] = True
        pickle.dump(_info,_info_file)
        _info_file.close()

        frame += frameStep



def tryRender(**kwargs):
    try:
        render(**kwargs)
        return cmds.quit(force = True,exitCode = 0,abort = True)
    except:
        logging.error('render fail')
        return cmds.quit(force = True,exitCode = 666,abort = True)