Source Code for Module nukescripts.fnFlipbookRenderer

  1  import nuke 
  2  import string 
  3  from os import unlink as unlink 
  4  from foundry.frameserver.nuke.bases import RenderQueueObserverMixin 
  5  from foundry.ui import executeInMainThread 
  6   
  7  incompleteRenderStr = """Render did not complete, do you want to show the completed range? 
  8  Frame range contains %s frames but only %s finished.""" 
  9   
 10   
 11 -class SimpleFlipbook(): 
 12    #todo: extract the flipbookdialog options and the flipbooktorun options into 
 13    #another class so that we dont need it's details 
 14 -  def __init__(self, flipbookDialog, flipbookToRun): 
 15      self._flipbookDialog = flipbookDialog 
 16      self._flipbookToRun = flipbookToRun 
 17   
 18 -  def getFlipbookOptions(self): 
 19      #common method 
 20      frameRange = nuke.FrameRanges(self._flipbookDialog._frameRange.value().split(',')) 
 21      views = self._flipbookDialog._selectedViews() 
 22      return (frameRange, views) 
 23   
 24   
 25 -  def getOptions(self): 
 26      #common method 
 27      options = self._flipbookDialog._getOptions( self._nodeToFlipbook ) 
 28      extraOptions = self._flipbookToRun.getExtraOptions( self._flipbookDialog, self._nodeToFlipbook ) 
 29      options.update( extraOptions ) 
 30      return options 
 31   
 32   
 33 -  def doFlipbook(self): 
 34      self.initializeFlipbookNode() 
 35      self.runFlipbook() 
 36   
 37   
 38 -  def initializeFlipbookNode(self): 
 39      self._nodeToFlipbook = self._flipbookDialog._node 
 40   
 41   
 42 -  def runFlipbook(self): 
 43      #this method is used for firing up the flipbook viewer given a node 
 44      if self._nodeToFlipbook: 
 45        frameRange, views = self.getFlipbookOptions() 
 46        self._flipbookToRun.runFromNode(self._nodeToFlipbook, 
 47                                        frameRange, 
 48                                        views, 
 49                                        self.getOptions() ) 
 50   
 51   
 52 -class SynchronousRenderedFlipbook(SimpleFlipbook): 
 53   
 54 -  def __init__(self, flipbookDialog, flipbookToRun): 
 55      SimpleFlipbook.__init__(self, flipbookDialog, flipbookToRun) 
 56   
 57 -  def doFlipbook(self): 
 58      self.initializeFlipbookNode() 
 59      self.renderFlipbookNode() 
 60   
 61   
 62 -  def initializeFlipbookNode(self): 
 63      self._nodeToFlipbook, self._writeNode = self._flipbookDialog._createIntermediateNode() 
 64   
 65   
 66 -  def renderFlipbookNode(self): 
 67      try: 
 68        frameRange, views = self.getFlipbookOptions() 
 69        nuke.executeMultiple((self._writeNode,), 
 70                             frameRange, 
 71                             views, 
 72                             self._flipbookDialog._continueOnError.value()) 
 73      except RuntimeError, msg: 
 74        import traceback 
 75        print traceback.format_exc() 
 76        if msg.args[0][0:9] == "Cancelled": 
 77          splitMsg = string.split(msg.args[0]) 
 78          msg =  incompleteRenderStr% (splitMsg[3], splitMsg[1]) 
 79          if nuke.ask(msg) == False: 
 80            nuke.delete(self._nodeToFlipbook) 
 81            self._nodeToFlipbook = None 
 82        else: 
 83          nuke.delete(self._nodeToFlipbook) 
 84          self._nodeToFlipbook = None 
 85          nuke.message("Flipbook render failed:\n%s" % (msg.args[0],)) 
 86      self.runFlipbook() 
 87   
 88   
 89   
 90 -class BackgroundRenderedFlipbook(SynchronousRenderedFlipbook): 
 91   
 92 -  def __init__(self, flipbookDialog, flipbookToRun): 
 93      SynchronousRenderedFlipbook.__init__(self, flipbookDialog, flipbookToRun) 
 94   
 95 -  def renderFlipbookNode(self): 
 96      # Override of renderFlipbookNode from SynchronousRenderedFlipbook 
 97      # this will trigger the render on a bg process that will launch the flipbook 
 98      # on finished. 
 99      try: 
100        frameRange, views = self.getFlipbookOptions() 
101        self._flipbookDialog._showDeprecatedWarningMessage() 
102        nuke.executeBackgroundNuke(nuke.EXE_PATH, 
103                                   [self._writeNode], 
104                                   frameRange, 
105                                   views, 
106                                   self._flipbookDialog._getBackgroundLimits(), 
107                                   self._flipbookDialog._continueOnError.value(), 
108                                   self._flipbookDialog._flipbookEnum.value(), 
109                                   self.getOptions() ) 
110      except RuntimeError, msg: 
111        import traceback 
112        print traceback.format_exc() 
113        nuke.delete(self._nodeToFlipbook) 
114        self._nodeToFlipbook = None 
115        nuke.message("Flipbook render failed:\n%s" % (msg.args[0],)) 
116   
117 -class FrameserverRenderedFlipbook(SynchronousRenderedFlipbook): 
118 -  def __init__(self, flipbookDialog, flipbookToRun): 
119      SynchronousRenderedFlipbook.__init__(self, flipbookDialog, flipbookToRun) 
120   
121   
122 -  def renderFlipbookNode(self, ): 
123      name, wasSaved = self._flipbookDialog.saveFileToRender("tmp_flipbook",True) 
124      try: 
125        nodeName = self._writeNode.fullName() 
126        frameRange, views = self.getFlipbookOptions() 
127        flipbookRenderPath= nuke.filename(self._nodeToFlipbook) 
128        options = self.getOptions() 
129        import hiero.ui.nuke_bridge.FnNsFrameServer as FrameServer 
130        task = FlipbookFrameServerTask(name, 
131          frameRange, 
132          nodeName, 
133          flipbookRenderPath, 
134          options, 
135          views, 
136          self._flipbookToRun ) 
137        FrameServer.renderFrames( 
138          name, 
139          frameRange, 
140          nodeName, 
141          views) 
142      finally: 
143        if wasSaved: 
144          unlink(name) 
145   
146 -class FlipbookFrameServerTask(RenderQueueObserverMixin): 
147   
148 -  def __init__(self, scriptPath, frameRange, nodeName, flipbookpath, options, views,flipbookToRun): 
149      #flipbook options 
150      self._flipbookToRun = flipbookToRun 
151      self._flipbookpath = flipbookpath 
152      self._frameRange = frameRange 
153      self._options = options 
154      self._views = views 
155      #needed to control the observer process 
156      self._scriptPath = scriptPath 
157      self._nodeName = nodeName 
158      self._totalFrames = frameRange.maxFrame() - frameRange.minFrame() + 1 
159      self._successfulFrames = 0 
160      self._completedFrames = 0 
161      import hiero.ui.nuke_bridge.FnNsFrameServer as FrameServer 
162      FrameServer.addBackgroundRenderObserver(self) 
163   
164 -  def showFlipbookWindow(self): 
165      try: 
166        if self._totalFrames != self._successfulFrames: 
167          msg =  incompleteRenderStr% (self._totalFrames, self._successfulFrames) 
168          if nuke.ask(msg) == False: 
169            return 
170        self._flipbookToRun.runFromPath(self._flipbookpath, 
171                                        self._frameRange, 
172                                        self._views, 
173                                        self._options) 
174      except Exception, e: 
175        nuke.tprint(e) 
176      finally: 
177        import hiero.ui.nuke_bridge.FnNsFrameServer as FrameServer 
178        FrameServer.removeBackgroundRenderObserver(self) 
179   
180 -  def renderFinished(self): 
181      executeInMainThread(self.showFlipbookWindow) 
182   
183 -  def onFrameRendered(self, scriptPath, frame, nodeName): 
184      """ Callback when a frame is rendered.  If it's for the script being 
185      rendered, increment the count. """ 
186      if scriptPath == self._scriptPath and nodeName == self._nodeName: 
187        self._completedFrames = self._completedFrames + 1 
188        self._successfulFrames = self._successfulFrames + 1 
189        if self._completedFrames == self._totalFrames: 
190          self.renderFinished() 
191   
192   
193 -  def onFrameRenderError(self, scriptPath, frame, nodeName, errorMsg): 
194      """ Callback when there is an error rendering a frame.  Set the error state 
195      and cancel. """ 
196      if scriptPath == self._scriptPath and nodeName == self._nodeName: 
197        self._completedFrames = self._completedFrames + 1 
198        if self._completedFrames == self._totalFrames: 
199          self.renderFinished() 
200   
201 -  def onFrameRenderCancelled(self, scriptPath, frame, nodeName): 
202      if scriptPath == self._scriptPath and nodeName == self._nodeName: 
203        self._completedFrames = self._completedFrames + 1 
204        if self._completedFrames == self._totalFrames: 
205          self.renderFinished() 
206   
207   
208 -def getFlipbookRenderer(flipbookDialog, flipbookToRun): 
209    if not flipbookDialog._requireIntermediateNode(flipbookDialog._node): 
210      return SimpleFlipbook( flipbookDialog, flipbookToRun ) 
211    else: 
212      #require intermediateNode 
213      if flipbookDialog.isBackgrounded(): 
214        return BackgroundRenderedFlipbook( flipbookDialog, flipbookToRun ) 
215      elif flipbookDialog._frameserverRender.value(): 
216        return FrameserverRenderedFlipbook( flipbookDialog, flipbookToRun ) 
217      else: 
218        return SynchronousRenderedFlipbook( flipbookDialog, flipbookToRun ) 
219    raise RuntimeError("No suitable Flipbook Rendered could be found") 
220