loc_list = sg.find('Asset', [['project.Project.id', 'is', PRJ_ID], ['custom_entity01_sg_assets_custom_entity01s.CustomEntity01.code', 'is', EP], ['sg_type_one.CustomEntity04.code', 'is', TYPE_ONE]], ['code', 'sg_reference'])

print loc_list

loc_paths = [os.path.abspath(i['sg_reference']['local_path']+'3d\\'+i['sg_reference']['name']+'_rig.ma') for i in loc_list]

print '\n'.join(loc_paths)

project_id = prj_name + '_id'

#print 'DEBUG project_id', project_id

#print 'helpers.ProjectHelper.' + project_id

if cmds.window('LAYOUTCUTTER', exists=True) == True:

cmds.deleteUI('LAYOUTCUTTER')

window = cmds.window('LAYOUTCUTTER', title="Let's get some wood..")

cmds.columnLayout()

cmds.text( label='Step 1: Remove imageplanes from "ep" shots and set absolute paths. Set camera attributes.' )

cmds.separator()

cmds.button( label='Step 1', command=set_step1 )

cmds.separator( height=5, style='singleDash' )

cmds.text( label='Step 2: Location assembly . Remove "chars" references, remove shots and cameras.' )

cmds.separator()

cmds.button( label='Step 2', command=set_step2 )

cmds.separator( height=5, style='singleDash' )

cmds.text( label='Step 3: cut 3D animatic' )

cmds.separator()

cmds.checkBoxGrp('serv_shots_grp', numberOfCheckBoxes=2, label='Include Shots: ', labelArray2=['sh0001', 'ID'])

cmds.text('progress', label='start/end', visible=False)

progressControl = cmds.progressBar('progress_control',width=600, visible=False)

cmds.scrollField('LOC', editable=True, wordWrap=False, w=600, h=60, text=get_loc())

cmds.checkBox('copy_flag',label='Copy to 2_prod', value=True)

cmds.checkBox('copyftp_flag',label='Copy to FTP', value=True)

cmds.textFieldButtonGrp('NAMEFIELD', text="cutscene", bc=lambda *args: start_cutting(progressControl), buttonLabel="CUT",

label="Cut Scenes Name Prefix:")

cmds.text( label='Exclude List' )

cmds.scrollField('EX', editable=True, wordWrap=False, w=250, h=250, text='chars\nlocs\nloc')

cmds.button( label='DEBUG', command=lambda *args: debug(args))

print 'FUNC get_shot_paths, shot type:', type(shot)

prefix = str(pm.textFieldButtonGrp('NAMEFIELD', q=1, text=1))

#if '_' in str(shot):

#print 'Renaming shot %s' %str(shot)

#shot.rename(str(shot).split('_')[1])

unresolved_PATH = SCENE_PATH.replace('//omega/'+PRJ_NAME, '%root%')

shot_cut_path_unr = unresolved_PATH.rsplit('/', 2)[0] + '/' + shot.name() + '/' + 'cut/'

shot_work_path_unr = shot_cut_path_unr.replace('cut/','work/')

shot_work_path_res = shot_work_path_unr.replace('%root%', '//omega/'+PRJ_NAME)

shot_work_path_ftp = shot_work_path_unr.replace('%root%', '//gamma/homes/ftp'+PRJ_NAME)

shot_cut_filename_path_unr = shot_cut_path_unr + EP + '_' + shot.name() +'_cut_v001.mov'

audio_filename_path_unr = shot_cut_path_unr + EP + '_' + shot.name() + '_cut_v001.wav'

shot_path_res = SCENE_PATH + '/' + prefix + '/'

#shot_save_noextpath = shot_path_res + EP + '_' + shot.name() + '_layout_v001'

shot_filename = EP + '_' + shot.name() + '_layout_v001.ma'

shot_filename_path_res = shot_path_res + shot_filename

shot_filename_work_path_res = shot_work_path_res + shot_filename

shot_filename_work_path_ftp = shot_work_path_ftp + shot_filename

#print 'shot:', shot.name()

#print 'shot_cut_path_unr:', shot_cut_path_unr

#print 'shot_work_path_unr:', shot_work_path_unr

#print 'shot_work_path_res:', shot_work_path_res

#print 'shot_work_path_ftp:', shot_work_path_ftp

#print 'shot_filename:', shot_filename

#print 'shot_filename_work_path_res:', shot_filename_work_path_res

#print 'shot_filename_work_path_ftp:', shot_filename_work_path_ftp

#print 'shot_cut_filename_path_unr:', shot_cut_filename_path_unr

#print 'audio_filename_path_unr:', audio_filename_path_unr

#print 'shot_path_res:', shot_path_res

#print 'shot_filename_path_res:', shot_filename_path_res

shot_paths = { 'shot_cut_path_unr': shot_cut_path_unr,

'shot_work_path_unr': shot_work_path_unr,

'shot_work_path_res': shot_work_path_res,

'shot_work_path_ftp': shot_work_path_ftp,

'shot_filename': shot_filename,

'shot_filename_work_path_res': shot_filename_work_path_res,

'shot_filename_work_path_ftp': shot_filename_work_path_ftp,

'shot_cut_filename_path_unr': shot_cut_filename_path_unr,

'audio_filename_path_unr': audio_filename_path_unr,

'shot_path_res': shot_path_res,

'shot_filename_path_res': shot_filename_path_res,

}

for i in shot_paths.items():

print i

print 'START service_shots_status'

opt_sh0001 = cmds.checkBoxGrp('serv_shots_grp', q=1, value1=1)

opt_id = cmds.checkBoxGrp('serv_shots_grp', q=1, value2=1)

if not opt_sh0001:

opt_sh0001 = '0001'

else:

opt_sh0001 = ' '

if not opt_id:

opt_id = 'id'

else:

opt_id = ' '

print '@@@ service_shots_status: ', [opt_sh0001, opt_id]

exclude_shots = service_shots_status()

#remove imageplanes from "ep" shots

shots = pm.ls(type='shot')

print 'DEBUG shots', shots

for s in shots[:]:

for e in exclude_shots:

if e not in s.name():

print 'leave shot: ', s.name()

pass

else:

shots.remove(s)

print 'remove: ', s

print '@@@ raise_warn_dlg: ', result_list

if cmds.window('check_win', exists=True) == True:

cmds.deleteUI('check_win')

result_str = ''.join([i+'\n' for i in result_list])

check_win = cmds.window('check_win')

cmds.paneLayout(configuration='single')

cmds.scrollField(editable=False, wordWrap=True, text=result_str)

cmds.showWindow()

res = cmds.confirmDialog( title='Confirm', message='Are you sure?', button=['Yes','No'], defaultButton='Yes', cancelButton='No', dismissString='No', parent=check_win)

#get excluded shots

shots = filter_excluded_shots()

result_list = []

stop_step1 = False

#check equal naming for shot name and Shot Name attribute

for shot in shots:

if shot.name() != shot.getShotName():

result_list.append(shot.name() + ' has shotName: ' + shot.getShotName())

if len(result_list) > 0:

res = raise_warn_dlg(result_list)

if res == 'Yes':

result_list = []

elif res == 'No':

return 'stop step1'

cmds.deleteUI('check_win')

#check shots sequence coherence

for shot in shots:

print '@ #check shots sequence coherence'

cur_ind = shots.index(shot)

if cur_ind > 0:

#if cur_ind > 0 and opt_id not in shot or opt_sh0001 not in shot:

shot = fix_shot_naming(shot)

print 'DEBUG cur_ind', cur_ind

print 'DEBUG shot:', shot

prw_ind = shots.index(shot) - 1

curr_shot = int(shot[2:])

prev_shot = fix_shot_naming(shots[prw_ind])

#print 'DEBUG i8', shot[8:]

#print 'DEBUG i8-1', shots[prw_ind][8:]

if curr_shot - int(prev_shot[2:]) != 1:

result_list.append(prev_shot + ' and ' + shot)

if result_list:

res = raise_warn_dlg(result_list)

if res == 'No':

pass

elif res == 'Yes' or not result_list:

for i in shots:

ip = cmds.connectionInfo(i + '.clip', sourceFromDestination = True)

if ip:

ipp = ip.split('.')[0].split('>')[1]

if 'id' not in i:

print 'shot:', i, 'removing imagePlane:', ipp

cmds.delete(ipp)

#replace paths in imageplanes

ips = cmds.ls(type='imagePlane')

for i in ips:

p1 = cmds.getAttr(i + '.imageName')

p2 = p1.replace('omega/'+PRJ_NAME, '%root%')

p3 = p2[p2.find('%root%'):]

cmds.setAttr(i + '.imageName', p3, type='string')

print i, p1, '-->', p3, '\n'

cams = getCameras()

for i in cams:

cmds.setAttr(i + '.farClipPlane', 100000)

all_scene_refs = pm.listReferences()

for ref in all_scene_refs:

ref_path = str(ref.path)

if 'chars' in ref_path:

print 'unload', str(ref)

ref.remove()

fix_ref_paths()

#remove shots, cameras and audio

shots = pm.ls(type="shot")

cams = getCameras()

audio = pm.ls(type='audio')

for i in shots+cams+audio:

try:

i.setLock(False)

except:

pass

pm.delete(i)

shot.setLock(False)

if '_' in str(shot):

shot_new_name = str(shot).split('_')[1]

print 'Renaming shot %s' %shot_new_name

return shot.rename(shot_new_name)

else:

# Kill all jobs

cmds.scriptJob(ka=True)

exclude_shots = service_shots_status()

# Get shots

shots = pm.ls(type="shot", sl=1)

allShots = pm.ls(type="shot")

allCams = pm.ls(type="camera")

if not shots: shots = allShots

location_path = str(pm.scrollField('LOC', q=1, text=1).replace('\\\\omega\\'+PRJ_NAME, '%root%'))

cmds.progressBar('progress_control', edit=True, progress=0, maxValue=len(shots), visible=True)

for count, shot in enumerate(shots):

cmds.text('progress', edit=True, label=shot+'/'+shots[-1], visible=True)

if cmds.progressBar(progressControl, query=True, isCancelled=True):

break

if exclude_shots[0] not in str(shot) and exclude_shots[1] not in str(shot):

print 'SHOT:', shot

print 'SHOT type:', type(shot)

#if count != 0:

cmds.file(SCENE_FULLPATH, prompt=False, force=1, open=1, resetError=1)

shot = fix_shot_naming(shot)

shot_paths = get_shot_paths(shot)

#remove audio

audio = pm.ls(type='audio')

for i in audio:

pm.delete(i)

#fix ref paths, remove all refs except exclude list and load location ref

fix_ref_paths()

replace_location(location_path, shot_paths['shot_filename'])

# Get camera for this shot

print '@DEBUG start Get camera for this shot'

cam = pm.listConnections(shot, type="shape")

print '@DEBUG cam', cam

camShape = cmds.listRelatives(str(cam[0]), shapes=True)[0]

print '@DEBUG camShape', camShape

print '@DEBUG start Get camera for this shot2'

if str(shot) in str(cam[0]) and 'Camera1' in str(cam[0]):

camName = 'cam_' + str(cam[0]).split('_')[1].replace('Camera1', '')

print 'CAMERA OK\n'

cmds.rename(str(cam[0]), camName)

elif str(cam[0]) == 'cam_'+str(shot):

print 'NEW CAMERA OK\n'

pass

else:

print 'create CAMERA for shot', shot, '\n'

cloneCamera(cam, camShape, str(shot))

#create image plane for shot camera

im_plane = create_imagePlane(cam[0], shot, shot_paths['shot_cut_filename_path_unr'])

#cleanup cameras

tmp = getCameras()

tmp.remove(str(cam[0]))

print 'delete cam',str(cam[0]), tmp

cmds.delete(tmp)#delete unused cameras

#create sound

print '@DEBUG create sound'

createSound(shot_paths['audio_filename_path_unr'])

# get out shot's range and move all animation of it to 1st frame

print '@DEBUG move all animation'

sf = int(shot.getStartTime())

ef = int(shot.getEndTime())

alMoveACsegment(sf, ef)

pm.playbackOptions(max=(1 + ef - sf), ast=1, aet=(1 + ef - sf), min=1)

print '@DEBUG move all animation1'

print shots

allShots = pm.ls(type='shot')

pm.lockNode(allShots, lock=False)

print '@DEBUG move all animation2'

print shots

pm.delete(allShots)

#create destination folder for saving scene

print '@DEBUG create destination folder'

create_folder(shot_paths['shot_path_res'])

#rename and save maya scene

print '@DEBUG rename and save maya scene'

cmds.file(rename=(shot_paths['shot_filename_path_res']))

cmds.file(save=1, type="mayaAscii", options="v=0;", f=1)

#copy scene to work path and ftp

if cmds.checkBox('copy_flag', query=True, value=True) == True:

copy_it(shot_paths['shot_filename_path_res'], shot_paths['shot_filename_work_path_res'])

if cmds.checkBox('copyftp_flag', query=True, value=True) == True:

create_folder(shot_paths['shot_work_path_ftp'])

copy_it(shot_paths['shot_filename_path_res'], shot_paths['shot_filename_work_path_ftp'])

#pm.sound(offset=1, file=sound_file_path)

sound_node = cmds.createNode('audio')

cmds.setAttr(sound_node+'.offset', 1)

cam_shape = cam.getShape()

print '@cam_shape:', cam_shape

if not pm.listConnections(cam_shape+'.imagePlane[0]', sh=True):

mel.eval('source AEcameraImagePlaneNew')

mel.eval('AEcameraImagePlaneCommand ' + str(cam_shape) + '.imagePlane ' + str(cam_shape) + '.horizontalFilmAperture ' + str(cam_shape) + '.verticalFilmAperture;')

print 'Creating Image Plane --->'

im_plane = pm.listConnections(cam_shape+'.imagePlane[0]', sh=True)[0].split('->')[1]

print 'Setting Image Plane --->', im_plane

pm.setAttr(im_plane+'.imageName', shot_cut_filename_path_unr)

#print 'DEBUG shot_cut_filename_path_unr', shot_cut_filename_path_unr

pm.setAttr(im_plane+'.type', 2)

#disconnect image plane from shot

pm.disconnectAttr(shot+'.clip')

all_scene_refs = pm.listReferences()

for i in all_scene_refs:

path_unr = i.unresolvedPath()

if '%root%' not in path_unr:

path_fix = path_unr.replace('//','/').split('/',3)[-1]

print 'replace for: ' + str(i) + ' with: ' + '%root%'+'/' + path_fix

i.replaceWith('%root%'+'/'+path_fix)

else:

'check namespace'

print '@DEBUG start replace_location'

all_scene_refs = pm.listReferences()

if location_path:

location_path = location_path.split('\n')

exclude_list = get_exclude_asset_list()

for ref in all_scene_refs:

ref_path = str(ref.path)

ref_namespace = str(ref.namespace)

if [True for i in exclude_list if i in ref_path.split('/') or i in ref_namespace.split('_')]:

print 'LEAVE REF:', str(ref)

else:

print 'REMOVE REF:', str(ref)

ref.remove()

for loc in location_path:

print loc

#shot_filename_no_ext = shot_filename.split('.')[0]

loc_namespace = loc.rsplit('\\',1)[1].split('.')[0]

print 'LOCATION', loc

pm.createReference(loc, namespace=loc_namespace)

else:

namespace_wo_digits = ''.join([s for s in ref.namespace if not s.isdigit()])

ref_filename_wo_ext = ref.unresolvedPath().rsplit('/', 1)[1].split('.')[0]

if namespace_wo_digits != ref_filename_wo_ext:

print 'error namespace: ', ref, ref.namespace

print 'path_unr: ', ref.unresolvedPath()

print 'ref_filename_wo_ext: ', ref_filename_wo_ext

# Get all cameras first

cameras = pm.ls(type=('camera'), l=True)

# Let's filter all startup / default cameras

startup_cameras = [camera for camera in cameras if pm.camera(camera.parent(0), startupCamera=True, q=True)]

# non-default cameras are easy to find now. Please note that these are all PyNodes

non_startup_cameras_pynodes = list(set(cameras) - set(startup_cameras))

# Let's get their respective transform names, just in-case

non_startup_cameras_transform_pynodes = map(lambda x: x.parent(0), non_startup_cameras_pynodes)

# Now we can have a non-PyNode, regular string names list of them

non_startup_cameras = map(str, non_startup_cameras_pynodes)

non_startup_cameras_transforms = map(str, non_startup_cameras_transform_pynodes)

lastFrame = 0.0

preRange = "0:" + str((startFrame - 1))

allaCurves = pm.ls(type="animCurve")

refCurves = pm.ls(type="animCurve", referencedNodes=1)

animCurves = [x for x in allaCurves if x not in refCurves]

for aCurve in animCurves:

if (pm.objectType(aCurve) == "animCurveTU") or (pm.objectType(aCurve) == "animCurveTA") or (pm.objectType(aCurve) == "animCurveTL"):

pm.setAttr((str(aCurve) + ".ktv"),

l=1)

pm.setAttr((str(aCurve) + ".ktv"),

l=0)

lastFrame = float(pm.findKeyframe(aCurve, which="last"))

if lastFrame <= endFrame:

lastFrame = float(endFrame + 2)

postRange = str((endFrame + 1)) + ":" + str(lastFrame)

if (pm.getAttr(str(aCurve) + ".pre") == 0) and (pm.getAttr(str(aCurve) + ".pst") == 0):

pm.setKeyframe(aCurve, insert=1, time=startFrame)

pm.setKeyframe(aCurve, insert=1, time=endFrame)

pm.cutKey(aCurve, time=preRange)

pm.cutKey(aCurve, time=postRange)

#print "\nanimCurve: " + str(aCurve)

pm.keyframe(aCurve, e=1, iub=True, o='over', r=1, time=(str(startFrame) + ":" + str(endFrame)),