def OnNamespaceFilePathSwapped(self, objNS, pOldPath, pNewPath, applyEdits ):
lScene = self.mSys.Scene
if (False == applyEdits):
# do we have any other instances with old path
anyOtherInstance = False
for ns in self.mSys.Scene.Namespaces:
if isinstance(ns, FBFileReference):
refPath = ns.ReferenceFilePath
if pOldPath == refPath and ns != objNS:
anyOtherInstance = True
break
if True == anyOtherInstance:
misc.DisconnectAllShaders(objNS)
misc.DescriptionDisconnect(objNS)
else:
misc.DeleteShadersGraph(objNS, pOldPath)
modelsMask = []
objNS.RevertRefEdit()
imp.DoFbxShadersGraphImport(True, 2, objNS, modelsMask)
# holder
base = os.path.splitext(pNewPath)[0]
newXml = base + '.xml'
misc.DescriptionStore(objNS, str(newXml))
else:
misc.SwapShadersGraph(objNS, str(pOldPath), str(pNewPath))
def HasReferenceNewUpdate(objNS):
filename = objNS.ReferenceFilePath
date = misc.GetFileLastWrite(filename)
# check for xml last write
xmlname, origFName = misc.DescriptionGetLocalFileName(objNS)
if '' == xmlname:
lOption = FBMessageBox(
'Reference Tool',
'Description Holder is missing for ' + objNS.LongName, 'Ok',
'Create A New')
if 2 == lOption:
misc.DescriptionStore(objNS)
return False
xmldoc = minidom.parse(xmlname)
shadersGraphElem = xmldoc.getElementsByTagName('ShadersGraph')
if 0 == len(shadersGraphElem):
return False
xmlLastWrite = str(shadersGraphElem[0].getAttribute('LastWrite'))
print date
print xmlLastWrite
return (date > xmlLastWrite)
def PopulateShadersGraph(self, pParentItem, pNSObj):
lList = []
misc.CollectReferenceContent(pNSObj, lList)
lShaders = []
lShaderModels = []
for lPlug in lList:
if isinstance(lPlug, FBModel):
for lShader in lPlug.Shaders:
if lShader in lShaders:
ndx = lShaders.index(lShader)
lShaderModels[ndx].append(lPlug)
else:
lShaders.append(lShader)
lShaderModels.append([lPlug])
for shader, models in zip(lShaders, lShaderModels):
lStrList = [shader.LongName]
lStrModels = misc.MBGetShaderTypeName(shader)
'''
for model in models:
lStrModels = lStrModels + model.Name
lStrModels = lStrModels + '; '
'''
lStrList.append(lStrModels)
lItem = QtGui.QTreeWidgetItem( lStrList )
pParentItem.addChild( lItem )
self.uiTreeNamespace.expandItem( lItem )
def StoreShader(newdoc, top_element, shader, namespaceToRemove):
shader_elem = newdoc.createElement('Shader')
shader_elem.setAttribute('ClassName', misc.MBGetShaderTypeName(shader))
shader_elem.setAttribute('Name', shader.Name)
shader_elem.setAttribute(
'LongName',
misc.RemoveFirstNamespace(shader.LongName, namespaceToRemove + 'S'))
shader_elem.setAttribute(
'System', str(shader.HasObjectFlags(FBObjectFlag.kFBFlagSystem)))
top_element.appendChild(shader_elem)
# Attachments
atts_elem = newdoc.createElement('Attachments')
attCount = 0
for i in range(shader.GetDstCount()):
comp = shader.GetDst(i)
if False == isinstance(comp, FBScene):
attCount += 1
atts_elem.setAttribute('Count', str(attCount))
shader_elem.appendChild(atts_elem)
for i in range(shader.GetDstCount()):
comp = shader.GetDst(i)
if isinstance(comp, FBScene):
continue
dst_elem = newdoc.createElement('Dst')
atts_elem.appendChild(dst_elem)
longname = comp.LongName
longname = misc.RemoveFirstNamespace(longname, namespaceToRemove)
dst_elem.setAttribute('ClassName', comp.ClassName())
dst_elem.setAttribute('Name', comp.Name)
dst_elem.setAttribute('LongName', longname)
# Properties
props_elem = newdoc.createElement('Properties')
shader_elem.appendChild(props_elem)
numberOfExported = 0
for prop in shader.PropertyList:
status = StoreProperty(newdoc, props_elem, prop, namespaceToRemove)
numberOfExported += status
props_elem.setAttribute('Count', str(numberOfExported))
def SaveShaderGraph(filename, FBXFileName, shadersList, modelsList,
namespaceToRemove):
impl = minidom.getDOMImplementation()
newdoc = impl.createDocument(None, 'ShadersGraph', None)
top_element = newdoc.documentElement
top_element.setAttribute('FileName', FBXFileName)
# TODO: put file size and file last write
size = os.path.getsize(FBXFileName)
date = misc.GetFileLastWrite(FBXFileName)
top_element.setAttribute("FileSize", str(size))
top_element.setAttribute("LastWrite", str(date))
shaders_elem = newdoc.createElement('Shaders')
shaders_elem.setAttribute('Count', str(len(shadersList)))
top_element.appendChild(shaders_elem)
for shader in shadersList:
StoreShader(newdoc, shaders_elem, shader, namespaceToRemove)
models_elem = newdoc.createElement('Models')
models_elem.setAttribute('Count', str(len(modelsList)))
top_element.appendChild(models_elem)
for comp in modelsList:
StoreModel(newdoc, models_elem, comp, namespaceToRemove)
res = open(filename, 'w')
res.writelines(newdoc.toprettyxml())
res.close()
def OnBtnInstanceClicked( self ):
lIndexes = self.uiTableNamespace.selectedIndexes()
for lIndex in lIndexes:
if lIndex.column() == 0:
lNSObj = self.mNSModel.GetNamespace(lIndex.row())
lInstanceCount = self.uiSpinInstanceTimes.value()
lBtnClicked, lName = PickRefName()
if lBtnClicked == 2: return
lNameList = FBStringList()
if lInstanceCount == 1:
lNameList.Add( lName )
else:
for lCount in range( 0, lInstanceCount ):
lNameList.Add( lName + str(lCount+1) )
lApplyRefEdits = False
if lNSObj.GetContentModified( FBPlugModificationFlag.kFBContentAllModifiedMask ):
lMsgBox = QtGui.QMessageBox( QtGui.QMessageBox.Question, 'Instancing', 'Do you want to apply reference edits after instancing?', QtGui.QMessageBox.Yes | QtGui.QMessageBox.No, self )
if lMsgBox.exec_() == QtGui.QMessageBox.Yes:
lApplyRefEdits = True
lStatus = lNSObj.DuplicateFileRef( lNameList, lApplyRefEdits )
if True == lStatus:
misc.DescriptionConnectModels(lNSObj, lNameList)
self.mNSModel.Refresh()
self.UpdateUI()
self.UpdateTreeNamespace()
def DoFbxShadersGraphImport(silent, importMode, objNS, modelsMask):
userChoise = 1 #importMode
if not silent:
userChoise = FBMessageBox('Shader Graph Importer',
'Please choose an operation',
'Apply to reference',
'Apply to source scene', 'Cancel')
if 1 == userChoise:
# auto load for references
filename = objNS.ReferenceFilePath
base = os.path.splitext(filename)[0]
xmlname = base + '.xml'
# TODO: if description file is not exist, let's try to make it from fbx
# TODO: xml will be update if it's out of date
if os.path.isfile(filename):
misc.RunCmdExtractXml(filename)
#
#
if os.path.isfile(xmlname):
# step 1 - load missing resources
# ?! promt if user wants to revert shaders properties values
LoadShaderGraphResources(xmlname, xmlname, objNS, True,
(importMode > 1))
# step 2 - apply connections and modifications (on top of last user edits)
LoadShaderGraphConnections(xmlname, xmlname, objNS, True)
else:
FBMessageBox('Shading Graph Importer',
'Shading Graph Description is not found !', 'Ok')
elif 2 == userChoise:
# we don't have reference namespace in a source scene
filename = lApp.FBXFileName
base = os.path.splitext(filename)[0]
xmlname = base + '.xml'
if os.path.isfile(xmlname):
# apply changes to orig scene
LoadShaderGraphResources(xmlname, xmlname, None, False, True)
LoadShaderGraphConnections(xmlname, xmlname, None, False)
else:
FBMessageBox('Shading Graph Importer',
'Shading Graph Description is not found!', 'Ok')
def StoreModel(newdoc, top_element, model, namespaceToRemove):
longname = model.LongName
longName = misc.RemoveFirstNamespace(longname, namespaceToRemove)
model_elem = newdoc.createElement('Model')
model_elem.setAttribute('ClassName', model.ClassName())
model_elem.setAttribute('Name', model.Name)
model_elem.setAttribute('LongName', longName)
model_elem.setAttribute('Visibility', str(model.Visibility))
model_elem.setAttribute('Show', str(model.Show))
top_element.appendChild(model_elem)
def BakeShadersGraphEdits(objNS, xmlname):
if objNS is None:
return False
if False == os.path.isfile(xmlname):
#raise NameError('Shaders Graph description is not found!')
print('Shaders Graph description is not found!')
return False
shadersList = []
modelsList = []
filename = objNS.ReferenceFilePath
#shadersList = misc.FindAllShadersByTags(xmlname, objNS)
misc.CollectReferenceModels(objNS, modelsList)
for model in modelsList:
for shader in model.Shaders:
if not (shader in shadersList):
shadersList.append(shader)
# write a new one
SaveShaderGraph(xmlname, objNS.ReferenceFilePath, shadersList, modelsList,
objNS.LongName)
# 1. bake updates into ref file
misc.RunCmdBake(objNS.ReferenceFilePath, xmlname, objNS.ReferenceFilePath)
# 2. store a new description holder - make baked state as initial
misc.DescriptionStore(objNS)
#except NameError:
# FBMessageBox( 'Shaders Graph', 'Reference object or shaders are not found!', 'Ok')
return True
def RestoreShadersGraph(objNS):
xmlname, origDescFile = misc.DescriptionGetLocalFileName(objNS)
if xmlname == '' or False == os.path.isfile(xmlname):
filename = objNS.ReferenceFilePath
base = os.path.splitext(filename)[0]
xmlname = base + '.xml'
origDescFile = xmlname
#DeleteShadersGraph(objNS)
if os.path.isfile(xmlname):
modelsMask = []
LoadShaderGraphResources(xmlname, origDescFile, objNS, True, True)
LoadShaderGraphConnections(xmlname, origDescFile, objNS, True)
def ComputeShadersMask(objNS):
mask = []
importNS = objNS.LongName + ':'
filename = objNS.ReferenceFilePath
# look to description holder at first
xmlname, origFName = misc.DescriptionGetLocalFileName(objNS)
if xmlname == '' or False == os.path.isfile(xmlname):
base = os.path.splitext(filename)[0]
xmlname = base + '.xml'
if os.path.isfile(xmlname):
xmldoc = minidom.parse(xmlname)
shadersGraphElem = xmldoc.getElementsByTagName('Shader')
def OnBtnShowShaderEditsClicked(self):
if self.mSingleSelection:
lIndexes = self.uiTableNamespace.selectedIndexes()
lNSObj = self.mNSModel.GetNamespace(lIndexes[0].row())
lShaders = []
lList = []
misc.CollectReferenceContent(lNSObj, lList)
for lPlug in lList:
if isinstance(lPlug, FBModel):
for lShader in lPlug.Shaders:
if not (lShader in lShaders):
lShaders.append(lShader)
# compare shaders with shaders Graph description
text = imp.CompareShadersGraph(lNSObj, lShaders)
lMsgBox = QtGui.QMessageBox( self )
lMsgBox.setText( text )
lMsgBox.exec_()
def StoreProperty(newdoc, top_element, prop, namespaceToRemove):
if prop.GetPropertyFlag(FBPropertyFlag.kFBPropertyFlagHideProperty):
return 0
if prop.IsReferenceProperty():
return 0
propname = prop.Name
if 'RefFileName' == propname or 'RefOrigShader' == propname:
return 0
elem = newdoc.createElement('Property')
elem.setAttribute('Name', propname)
elem.setAttribute('Type', str(prop.GetPropertyTypeName()))
value = ""
try:
data = prop.Data
if type(data) is FBTime:
value = data.GetTimeString()
elif type(data) is FBVector2d:
elem.setAttribute("X", str(data[0]))
elem.setAttribute("Y", str(data[1]))
elem.setAttribute("Z", str(data[2]))
value = str(data)
elif type(data) in [FBVector3d, FBColor]:
elem.setAttribute("X", str(data[0]))
elem.setAttribute("Y", str(data[1]))
elem.setAttribute("Z", str(data[2]))
value = str(data)
elif type(data) in [FBVector4d, FBColorAndAlpha]:
elem.setAttribute("X", str(data[0]))
elem.setAttribute("Y", str(data[1]))
elem.setAttribute("Z", str(data[2]))
elem.setAttribute("W", str(data[3]))
value = str(data)
else:
value = str(data)
except NotImplementedError:
value = "undefined"
except Exception:
value = "undefined"
elem.setAttribute("Value", value)
top_element.appendChild(elem)
# write property connectors (models, textues, etc. like FBPropertyObjectList)
srcCount = prop.GetSrcCount()
if srcCount > 0:
conns_elem = newdoc.createElement('Connections')
conns_elem.setAttribute('Count', str(srcCount))
elem.appendChild(conns_elem)
for i in range(srcCount):
comp = prop.GetSrc(i)
src_elem = newdoc.createElement('Source')
conns_elem.appendChild(src_elem)
longname = comp.LongName
longname = misc.RemoveFirstNamespace(longname, namespaceToRemove)
src_elem.setAttribute('ClassName', comp.ClassName())
src_elem.setAttribute('Name', comp.Name)
src_elem.setAttribute('LongName', longname)
return 1
def DoFbxShadersGraphImport2(silent, importMode, objNS, modelsMask):
userChoise = 1 #importMode
if not silent:
userChoise = FBMessageBox('Shader Graph Importer',
'Please choose an operation',
'Apply to reference',
'Apply to source scene', 'Cancel')
if 1 == userChoise:
# auto load for references
NS = objNS.LongName + ':'
filename = objNS.ReferenceFilePath
base = os.path.splitext(filename)[0]
xmlname = base + '.xml'
# DONE: if description file is not exist, let's try to make it from fbx
# DONE: xml will be update if it's out of date
if os.path.isfile(filename):
misc.RunCmdExtractXml(filename)
#
#
if os.path.isfile(xmlname):
refEdits = ''
#if objNS.GetContentModified( FBPlugModificationFlag.kFBContentAllModifiedMask ):
# refEdits = objNS.GetRefEdit()
# objNS.RevertRefEdit()
# step 1 - load missing resources
# ?! promt if user wants to revert shaders properties values
LoadShaderGraphResources(xmlname, xmlname, NS, True,
(importMode > 1))
# step 2 - apply connections and modifications (on top of last user edits)
if len(refEdits) > 0:
objNS.RevertRefEdit()
objNS.ApplyRefEditPyScriptFromString(refEdits)
LoadShaderGraphConnections(xmlname, xmlname, objNS, True)
# restore missing connections, like when merging new objects
else:
userChoise = 1 #FBMessageBox('Shading Graph Importer', 'Do you want to restore shaders graph connections?', 'Ok', 'Cancel')
if 1 == userChoise:
LoadShaderGraphConnections(xmlname, xmlname, objNS, True)
#del(refEdits)
else:
FBMessageBox('Shading Graph Importer',
'Shading Graph Description is not found !', 'Ok')
elif 2 == userChoise:
# we don't have reference namespace in a source scene
filename = lApp.FBXFileName
base = os.path.splitext(filename)[0]
xmlname = base + '.xml'
if os.path.isfile(xmlname):
# apply changes to orig scene
LoadShaderGraphResources(xmlname, xmlname, None, False, True)
LoadShaderGraphConnections(xmlname, xmlname, None, False)
else:
FBMessageBox('Shading Graph Importer',
'Shading Graph Description is not found!', 'Ok')
def CompareShadersGraph(objNS, sceneShaders):
global gReferenceContent
global gReferenceContentNames
gReferenceContent = []
gReferenceContentNames = []
GlobalCollectReferenceContent(objNS)
text = ''
importNS = objNS.LongName + ':'
filename = objNS.ReferenceFilePath
# look to description holder at first
xmlname, origFName = misc.DescriptionGetLocalFileName(objNS)
if xmlname == '' or False == os.path.isfile(xmlname):
base = os.path.splitext(filename)[0]
xmlname = base + '.xml'
if os.path.isfile(xmlname):
numberOfExistShaders = 0
existShaders = []
for shader in sceneShaders:
existShaders.append(False)
xmldoc = minidom.parse(xmlname)
shadersGraphElem = xmldoc.getElementsByTagName('Shader')
text = text + '== Parsing Shaders Graph Description - ' + xmlname + '\n'
if len(shadersGraphElem) > 0:
for shader in shadersGraphElem:
shaderClass = str(shader.getAttribute('ClassName'))
xmlShaderName = str(shader.getAttribute('LongName'))
strSystem = str(shader.getAttribute('System'))
text = text + '\n = Shader ' + xmlShaderName + ' (Class: ' + shaderClass + ') ... '
# DONE: situation when scene shader has been renamed (I'm using RefOrigShader Property)
isExists = False
lSceneShader = None
if 'True' == strSystem:
for lShader in lSystem.Scene.Shaders:
if lShader.HasObjectFlags(
FBObjectFlag.kFBFlagSystem
) or 'Default Shader' == lShader.Name:
lSceneShader = lShader
isExists = True
break
else:
for i, sceneShader in enumerate(sceneShaders):
mbShaderName = sceneShader.LongName
refOrigShader = sceneShader.PropertyList.Find(
'RefOrigShader')
if refOrigShader is not None:
mbShaderName = refOrigShader.Data
if xmlShaderName == mbShaderName:
lSceneShader = sceneShader
existShaders[i] = True
isExists = True
break
if isExists:
numberOfExistShaders += 1
text = text + ' Ok!\n'
else:
text = text + ' Missing!\n'
allTheAttElems = shader.getElementsByTagName('Dst')
allThePropElems = shader.getElementsByTagName('Property')
# DONE: compare prop values
if lSceneShader is not None:
# DONE: we could not have a scene load for retreiving mod state
xmlprops = []
xmlprops = GetXmlProps(allThePropElems)
# shared, edits, collisions
compareInfo = []
compareInfo = ComparePropsAndValues(lSceneShader, xmlprops)
text = text + ' > Checking Properties - total: ' + str(
len(lSceneShader.PropertyList))
text = text + '; shared: ' + str(
compareInfo[0]) + '; edits: ' + str(
compareInfo[1]) + '; collisions: ' + str(
compareInfo[2]) + '; \n'
# DONE: compare attachments
att = []
att = GetXmlAttachments(allTheAttElems, importNS)
mbAtt = []
mbAtt = GetMBAttachments(lSceneShader, objNS)
diff1 = list(set(mbAtt) - set(att))
diff2 = list(set(att) - set(mbAtt))
diff = diff1 + diff2
if lSceneShader.HasObjectFlags(FBObjectFlag.kFBFlagSystem):
diff = diff2
if len(diff) > 0:
text = text + ' > Different shader-model assignment - '
for elem in diff:
text = text + elem + '; '
text = text + '\n'
else:
text = text + ' > No differents in shader-model assignments!\n'
if numberOfExistShaders == len(sceneShaders):
if len(shadersGraphElem) == len(sceneShaders):
text = text + '\nThere are no changes in shaders\n'
else:
text = text + '\nSome Source Description shaders are missing (Disconnected or Removed)\n'
else:
text = text + '\nSome Scene Shaders are missing (User Added or Connected)\n'
for lFlag, lShader in zip(existShaders, sceneShaders):
if False == lFlag:
text = text + ' * ' + lShader.LongName + '\n'
return text
if False == os.path.isfile(ns.ReferenceFilePath):
FBMessageBox('Reference A File',
'Referenced file is not found!', 'Ok')
else:
lNSObj = ns
break
filename = lArg1
if lNSObj is not None:
filename = lNSObj.ReferenceFilePath
# check if we have any shaders graph connected to delete
anyInstances = False
for namespace in lScene.Namespaces:
if namespace != lNSObj:
if isinstance(namespace, FBFileReference):
if namespace.ReferenceFilePath == filename:
anyInstances = True
if False == anyInstances:
misc.DeleteShadersGraph(lNSObj, filename)
# let's find any Description Holder connection
misc.DescriptionDelete(lNSObj)
# remove from monitor manager
lMon = FBFileMonitoringManager()
lMon.RemoveFileFromMonitor(filename)
# Remove temp sys.path
#sys.path.remove( os.path.join( os.path.dirname(lCurFilePath), 'MBFileRefAdvanced' ) )
sys.path.remove(os.path.dirname(lCurFilePath))
if True == objNS.SwapReferenceFilePath( str(pNewPath), applyEdits, applyEdits ):
if False == applyEdits:
# do we have any other instances with old path
anyOtherInstance = False
for ns in self.mSys.Scene.Namespaces:
if isinstance(ns, FBFileReference):
refPath = ns.ReferenceFilePath
if pOldPath == refPath and ns != objNS:
anyOtherInstance = True
break
if True == anyOtherInstance:
misc.DisconnectAllShaders(objNS)
misc.DescriptionDisconnect(objNS)
else:
misc.DeleteShadersGraph(objNS, pOldPath)
modelsMask = []
objNS.RevertRefEdit()
imp.DoFbxShadersGraphImport(True, 2, objNS, modelsMask)
# holder
base = os.path.splitext(pNewPath)[0]
newXml = base + '.xml'
misc.DescriptionStore(objNS, str(newXml))
else:
misc.SwapShadersGraph(objNS, str(pOldPath), str(pNewPath))
lSystem = FBSystem()
lScene = lSystem.Scene
lNSObj = None
if len(lRefName) > 0:
for ns in lScene.Namespaces:
if isinstance(ns, FBFileReference) and lRefName == ns.LongName:
if False == os.path.isfile(ns.ReferenceFilePath):
FBMessageBox('Reference A File',
'Referenced file is not found!', 'Ok')
else:
lNSObj = ns
break
if lNSObj is not None:
# change name of shaders namespace and change name of description holder
lOldName = lArg1
lNewName = lNSObj.LongName
if True == lScene.NamespaceExist(str(lOldName) + 'S'):
lScene.NamespaceRename(str(lOldName) + 'S', str(lNewName) + 'S')
# holder
misc.DescriptionRename(lNSObj, str(lNewName))
# Remove temp sys.path
#sys.path.remove( os.path.join( os.path.dirname(lCurFilePath), 'MBFileRefAdvanced' ) )
sys.path.remove(os.path.dirname(lCurFilePath))
def OnTimer( self ):
for lFilePath, lReload in self.mNSModel.mRefFileReload.items():
if False == os.path.isfile(lFilePath) and True == lReload:
FBMessageBox( "External File Not Found", "The referenced file '%s' is not found!\nReference goes offline" % ( lFilePath ), "Ok" )
if lFilePath in self.mNSModel.mRefFilePath:
for lFileRefName in self.mNSModel.mRefFilePath[lFilePath]:
lFileRefObj = FBFindObjectByFullName( 'FileReference::' + lFileRefName )
if lFileRefObj is not None:
self.mNSModel.RemoveFileFromWatcher( lFileRefObj )
lFileRefObj.IsLoaded = False
self.mNSModel.mRefFileReload[lFilePath] = False
self.UpdateUI()
self.UpdateTreeNamespace()
elif lReload:
FBMessageBox( "External File Changed", "The referenced file '%s' has been changed externally!" % ( lFilePath ), "OK" )
if lFilePath in self.mNSModel.mRefFilePath:
for lFileRefName in self.mNSModel.mRefFilePath[lFilePath]:
lNSObj = FBFindObjectByFullName( 'FileReference::' + lFileRefName )
lOption = FBMessageBox( "External File Changed", "Please choose the following action for Reference: %s!" % ( lFileRefName ), "Load", "Merge", "Ignore" )
if lOption <> 3:
lUndo = FBUndoManager()
lUndo.Clear()
diff = []
edits = ''
misc.DisconnectAllShaders(lNSObj)
if lNSObj.GetContentModified( FBPlugModificationFlag.kFBContentAllModifiedMask ):
edits = lNSObj.GetRefEdit()
lNSObj.IsLoaded = False
lNSObj.IsLoaded = True
filename = lNSObj.ReferenceFilePath
base = os.path.splitext(filename)[0]
xmlname = base + '.xml'
if lOption == 2:
imp.DoFbxShadersGraphImport(True, 2, lNSObj, diff)
if len(edits) > 0:
lNSObj.RevertRefEdit()
lNSObj.ApplyRefEditPyScriptFromString( edits )
imp.LoadShaderGraphConnections(xmlname, xmlname, lNSObj, True)
else:
modelsMask = []
lNSObj.RevertRefEdit()
imp.DoFbxShadersGraphImport(True, 2, lNSObj, modelsMask)
# store new xml data
misc.DescriptionStore(lNSObj)
self.mNSModel.mRefFileReload[lFilePath] = False
self.mNSModel.UpdateFileWatcher()
def LoadShaderGraphConnections(filename, origFileName, objNS, findByTag):
importNS = ''
if objNS is not None:
importNS = objNS.LongName + ':'
global gReferenceContent
global gReferenceContentNames
gReferenceContent = []
gReferenceContentNames = []
GlobalCollectReferenceContent(objNS)
xmldoc = minidom.parse(filename)
shadersGraphElem = xmldoc.getElementsByTagName('Shader')
if len(shadersGraphElem) > 0:
for shader in shadersGraphElem:
shaderClass = str(shader.getAttribute('ClassName'))
shaderName = str(shader.getAttribute('LongName'))
strSystem = str(shader.getAttribute('System'))
# SHADER AND PROPERTIES
allTheAttElems = shader.getElementsByTagName('Dst')
allThePropElems = shader.getElementsByTagName('Property')
newShader = None
if 'True' == strSystem:
for lShader in lSystem.Scene.Shaders:
if lShader.HasObjectFlags(
FBObjectFlag.kFBFlagSystem
) or 'Default Shader' == lShader.Name:
newShader = lShader
break
else:
if True == findByTag:
newShader = misc.FindAShaderByTags(origFileName,
shaderName)
else:
newShader = FBFindObjectByFullName('Shader::' + shaderName)
# connections
if newShader is not None:
for prop in allThePropElems:
RetrieveShaderPropertyValue(newShader, prop, importNS)
for attachment in allTheAttElems:
modelname = str(attachment.getAttribute('LongName'))
ndx = gReferenceContentNames.index(importNS + modelname)
if ndx >= 0:
FBConnect(newShader, gReferenceContent[ndx])
#
# import model visibility and show
modelsElem = xmldoc.getElementsByTagName('Models')
if len(modelsElem) > 0:
allTheModels = modelsElem[0].getElementsByTagName('Model')
for modelelem in allTheModels:
modelName = str(modelelem.getAttribute('LongName'))
show = ('True' == str(modelelem.getAttribute('Show')))
vis = ('True' == str(modelelem.getAttribute('Visibility')))
ndx = gReferenceContentNames.index(importNS + modelName)
if ndx >= 0:
model = gReferenceContent[ndx]
currShow = model.Show
if currShow != show:
model.Show = show
currVis = model.Visibility.Data
if currVis != vis:
model.Visibility = vis
if False == show or False == vis:
print modelName
if isUpdated:
# ask user to reload a shaders graph
lOption = FBMessageBox(
"External File Changed",
"Please choose the following action for Reference: %s!" %
(filename), "Load", "Merge", "Ignore")
if lOption <> 3:
lUndo = FBUndoManager()
lUndo.Clear()
modelsMask = []
edits = ''
misc.DisconnectAllShaders(lNSObj)
if lNSObj.GetContentModified(
FBPlugModificationFlag.kFBContentAllModifiedMask):
edits = lNSObj.GetRefEdit()
lNSObj.IsLoaded = False
lNSObj.IsLoaded = True
filename = lNSObj.ReferenceFilePath
base = os.path.splitext(filename)[0]
xmlname = base + '.xml'
if lOption == 2:
imp.DoFbxShadersGraphImport(True, 2, lNSObj, modelsMask)
def LoadShaderGraphResources(filename, origFileName, objNS, findByTag,
alwaysRetrieveProps):
importNS = ''
shaderNS = ''
if objNS is not None:
importNS = objNS.LongName + ':'
shaderNS = objNS.LongName + 'S:'
global gReferenceContent
global gReferenceContentNames
gReferenceContent = []
gReferenceContentNames = []
GlobalCollectReferenceContent(objNS)
xmldoc = minidom.parse(filename)
shadersGraphElem = xmldoc.getElementsByTagName('Shader')
if len(shadersGraphElem) > 0:
for shader in shadersGraphElem:
shaderClass = str(shader.getAttribute('ClassName'))
shaderName = str(shader.getAttribute('LongName'))
isSystem = ('True' == str(shader.getAttribute('System')))
# SHADER AND PROPERTIES
allTheAttElems = shader.getElementsByTagName('Dst')
allThePropElems = shader.getElementsByTagName('Property')
newShader = None
if True == isSystem:
newShader = FBFindObjectByFullName('Shader::' + shaderName)
else:
if True == findByTag:
newShader = misc.FindAShaderByTags(origFileName,
shaderName)
else:
newShader = FBFindObjectByFullName('Shader::' + shaderName)
if newShader is None:
newShader = CreateShader(shaderClass, shaderNS + shaderName,
allThePropElems)
if False == alwaysRetrieveProps:
if newShader is not None:
for prop in allThePropElems:
RetrieveShaderPropertyValue(
newShader, prop, importNS)
# add props for shader identification
fnameProp = newShader.PropertyCreate(
'RefFileName', FBPropertyType.kFBPT_charptr, 'String',
False, True, None)
origProp = newShader.PropertyCreate(
'RefOrigShader', FBPropertyType.kFBPT_charptr,
'String', False, True, None)
if fnameProp is not None:
fnameProp.Data = origFileName
if origProp is not None:
origProp.Data = shaderName
# connections
if newShader is not None:
for attachment in allTheAttElems:
modelname = str(
attachment.getAttribute('LongName'))
ndx = gReferenceContentNames.index(importNS +
modelname)
if ndx >= 0:
FBConnect(newShader, gReferenceContent[ndx])
#
if newShader is not None:
if True == isSystem:
for attachment in allTheAttElems:
modelname = str(attachment.getAttribute('LongName'))
ndx = gReferenceContentNames.index(importNS +
modelname)
if ndx >= 0:
FBConnect(newShader, gReferenceContent[ndx])
else:
if True == alwaysRetrieveProps:
for prop in allThePropElems:
RetrieveShaderPropertyValue(
newShader, prop, importNS)
for attachment in allTheAttElems:
modelname = str(
attachment.getAttribute('LongName'))
ndx = gReferenceContentNames.index(importNS +
modelname)
if ndx >= 0:
FBConnect(newShader, gReferenceContent[ndx])
# id props
fnameProp = newShader.PropertyList.Find('RefFileName')
if fnameProp is None:
fnameProp = newShader.PropertyCreate(
'RefFileName', FBPropertyType.kFBPT_charptr,
'String', False, True, None)
origProp = newShader.PropertyList.Find('RefOrigShader')
if origProp is None:
origProp = newShader.PropertyCreate(
'RefOrigShader', FBPropertyType.kFBPT_charptr,
'String', False, True, None)
if fnameProp is not None:
fnameProp.Data = origFileName
if origProp is not None:
origProp.Data = shaderName