def projectOpened(self):
self.start = float(gSettings.value('TimerStartTime', 0.0))
endTime = float(gSettings.value('TimerEndTime', 8.0))
self.time = float(gSettings.value('TimerTime', 0.0))
project = currentProjectFilePath()
if project and project.exists():
text = project.content()
try:
root = cElementTree.fromstring(text)
except:
root = None
if root is not None:
self.minTime = float(root.attrib.get('TimerMinTime', 0.0))
self.maxTime = float(root.attrib.get('TimerMaxTime', 8.0))
self.end = min(endTime, self.maxTime)
self.__BPS = float(root.attrib.get('TimerBPS', 2.0))
self.__osc.setBpm(int(round(self.__BPS * 60)))
self.bpmChanged.emit(self.__BPS * 60.0)
return
# legacy project / creating new project
self.minTime = 0.0
self.maxTime = 4.0
self.end = min(endTime, self.maxTime)
self.__BPS = float(gSettings.value('TimerBPS', 2.0))
self.__osc.setBpm(int(round(self.__BPS * 60)))
self.bpmChanged.emit(self.__BPS * 60.0)
def loadState(self):
# save user camera position per scene
userFile = currentProjectFilePath().ensureExt('user')
if not userFile.exists():
return
xUser = parseXMLWithIncludes(userFile)
if xUser is None:
return
xMod = xUser.find('Modeler')
if xMod is None:
return
if 'CurrentModel' in xMod.attrib:
currentModelIndex = int(xMod.attrib['CurrentModel'])
else:
currentModelIndex = -1
if currentModelIndex >= 0 and currentModelIndex < len(self._models.models):
self.selectedModelNodesChanged.emit(self._models.models[currentModelIndex], None)
else:
self.selectedModelNodesChanged.emit(None, None)
ct = list(map(float, xMod.attrib['CameraTransform'].split(',')))
self._cameraTransform = cgmath.Mat44(ct[0],ct[1],ct[2],ct[3],ct[4],ct[5],ct[6],ct[7],ct[8],ct[9],ct[10],ct[11],ct[12],ct[13],ct[14],ct[15])
ct = list(map(float, xMod.attrib['CameraPivot'].split(',')))
self._cameraPivot = cgmath.Vec3(ct[0], ct[1], ct[2])
self.update()
def saveToProject(self):
project = currentProjectFilePath()
root = parseXMLWithIncludes(project)
xModels = cElementTree.SubElement(root, 'Models')
for model in self._models:
model.saveToElementTree(xModels)
with project.edit() as fh:
fh.write(toPrettyXml(root))
def __initializeProject(self):
project = currentProjectFilePath()
if project is not None:
if project.exists():
self.__openProject(project)
return
project = [x for x in list(os.listdir(os.getcwd())) if x.endswith(PROJ_EXT)]
if project:
self.__openProject(os.path.join(os.getcwd(), project[0]))
return
def __loadAllShots(self):
if currentProjectFilePath() is None:
self.setEnabled(False)
return
self.setEnabled(True)
self.__model.clear()
# model.clear() removes the header labels
self.__model.setHorizontalHeaderLabels(
['Name', 'Scene', 'Start', 'End', 'Duration', 'Speed', 'Preroll'])
for sceneName in iterSceneNames():
for shot in _deserializeSceneShots(sceneName):
self.__model.appendRow(shot.items)
self.__table.sortByColumn(2, Qt.AscendingOrder)
def readCameraData(self):
if self.__cameraData is None:
userFile = FilePath(currentProjectFilePath() + '.user')
xCamera = None
if userFile.exists():
xRoot = parseXMLWithIncludes(userFile)
for xSub in xRoot:
if xSub.attrib['name'] == self.__filePath.name():
xCamera = xSub
break
if xCamera is None: # legacy support
xCamera = parseXMLWithIncludes(self.__filePath)
self.__cameraData = CameraTransform(
*[float(x) for x in xCamera.attrib['camera'].split(',')])
return self.__cameraData
def saveState(self):
gSettings.setValue('TimerStartTime', self.__start)
gSettings.setValue('TimerEndTime', self.__end)
gSettings.setValue('TimerTime', self.__time)
project = currentProjectFilePath()
if not project or not project.exists():
# legacy project or no project open
gSettings.setValue('TimerMinTime', self.__minTime)
gSettings.setValue('TimerMaxTime', self.__maxTime)
gSettings.setValue('TimerBPS', self.__BPS)
return
root = cElementTree.Element('Project')
root.attrib['TimerMinTime'] = str(self.__minTime)
root.attrib['TimerMaxTime'] = str(self.__maxTime)
root.attrib['TimerBPS'] = str(self.__BPS)
with project.edit() as fh:
fh.write(toPrettyXml(root))
def __changeProjectHelper(self, title):
"""
Utility that shows a dialog if we're changing projects with potentially unsaved changes.
Returns the current project directory, or the current working directory if no such project.
"""
currentPath = FilePath(os.getcwd())
project = currentProjectFilePath()
if project is not None:
# propose to save near current project
dir = project.parent()
if dir.exists():
currentPath = dir
# check if unsaved changes
if QMessageBox.No == QMessageBox.warning(self, title, 'Any unsaved changes will be lost. Continue?', QMessageBox.Yes | QMessageBox.No):
return
return currentPath
def saveState(self):
# save user camera position per scene
userFile = currentProjectFilePath().ensureExt('user')
if userFile.exists():
xUser = parseXMLWithIncludes(userFile)
else:
xUser = cElementTree.Element('user')
xMod = xUser.find('Modeler')
if xMod is None:
xMod = cElementTree.SubElement(xUser, 'Modeler')
if not self._currentModel is None:
xMod.set('CurrentModel', str(self._models.models.index(self._currentModel)))
xMod.set('CameraTransform', ','.join(map(str, self._cameraTransform[:])))
xMod.set('CameraPivot', ','.join(map(str, self._cameraPivot[:])))
with userFile.edit() as fh:
fh.write(toPrettyXml(xUser))
def loadFromProject(self):
# Clear all
while len(self._models) > 0:
self.removeModel(self._models[0])
project = currentProjectFilePath()
if project and project.exists():
text = project.content()
try:
root = cElementTree.fromstring(text)
except:
root = None
if root is not None:
xModels = root.find('Models')
if not xModels is None:
for xModel in xModels.findall('Model'):
model = Model()
model.models = self
model.loadFromElementTree(xModel)
self._models.append(model)
def _saveSceneShots(sceneName, shots):
sceneFile = currentScenesDirectory().join(sceneName.ensureExt(SCENE_EXT))
xScene = parseXMLWithIncludes(sceneFile)
# save user camera position per scene
userFile = currentProjectFilePath().ensureExt('user')
if userFile.exists():
xUser = parseXMLWithIncludes(userFile)
else:
xUser = cElementTree.Element('user')
if sceneFile in Scene.cache:
cameraData = Scene.cache[sceneFile].cameraData()
if cameraData:
for xSub in xUser:
if xSub.tag == 'scene' and xSub.attrib['name'] == sceneName:
xSub.attrib['camera'] = ','.join(
[str(x) for x in cameraData])
break
else:
cElementTree.SubElement(
xUser, 'scene', {
'name': sceneName,
'camera': ','.join([str(x) for x in cameraData])
})
with userFile.edit() as fh:
fh.write(toPrettyXml(xUser))
# remove old shots
r = []
for xShot in xScene:
r.append(xShot)
for s in r:
xScene.remove(s)
targets = []
for shot in shots:
if shot.sceneName == sceneName:
targets.append(shot)
for shot in targets:
xShot = cElementTree.SubElement(
xScene, 'Shot', {
'name': shot.name,
'scene': sceneName,
'start': str(shot.start),
'end': str(shot.end),
'enabled': str(shot.enabled),
'speed': str(shot.speed),
'preroll': str(shot.preroll)
})
for curveName in shot.curves:
xChannel = cElementTree.SubElement(xShot, 'Channel', {
'name': curveName,
'mode': 'hermite'
})
data = []
for key in shot.curves[curveName]:
data.append(str(key.inTangent.x))
data.append(str(key.inTangent.y))
data.append(str(key.point().x))
data.append(str(key.point().y))
data.append(str(key.outTangent.x))
data.append(str(key.outTangent.y))
data.append(str(int(key.tangentBroken)))
data.append(str(key.tangentMode))
xChannel.text = ','.join(data)
for texName in shot.textures:
cElementTree.SubElement(xShot, 'Texture', {
'name': texName,
'path': shot.textures[texName]
})
with sceneFile.edit() as fh:
fh.write(toPrettyXml(xScene))
