From 27fa6d5b30c296129c0b582b596b38edd0ece98c Mon Sep 17 00:00:00 2001 From: Dillon Barnes Date: Tue, 12 Nov 2024 10:51:40 +0000 Subject: [PATCH 01/13] remove deleting --- lightfield_render.py | 24 ++++++++++++------------ 1 file changed, 12 insertions(+), 12 deletions(-) diff --git a/lightfield_render.py b/lightfield_render.py index 95b48f3..7cc513c 100644 --- a/lightfield_render.py +++ b/lightfield_render.py @@ -1387,24 +1387,24 @@ def cancel(self, context): # CLEAN-UP FILES # +++++++++++++++++++++++++++++++++++++++++++ # if the view files shall not be kept OR (still was rendered AND no filename was specfied) OR the file keeping is forced OR the incomplete render job was discarded - if ((self.render_settings.addon_settings.render_output == '1' or (not ((self.render_settings.job.animation == False and not self.render_settings.job.file_use_temp) or self.animation == True))) and self.render_settings.job.file_force_keep == False) or self.discard_lockfile == True: + # if ((self.render_settings.addon_settings.render_output == '1' or (not ((self.render_settings.job.animation == False and not self.render_settings.job.file_use_temp) or self.animation == True))) and self.render_settings.job.file_force_keep == False) or self.discard_lockfile == True: - LookingGlassAddonLogger.info("Cleaning up the disk files.") + # LookingGlassAddonLogger.info("Cleaning up the disk files.") - # if it was an animation - if self.render_settings.job.animation: + # # if it was an animation + # if self.render_settings.job.animation: - # for all frames of the animation - for frame in range(self.render_settings.job.scene.frame_start, self.render_settings.job.scene.frame_end + self.render_settings.frame_step): + # # for all frames of the animation + # for frame in range(self.render_settings.job.scene.frame_start, self.render_settings.job.scene.frame_end + self.render_settings.frame_step): - # delete views - self.render_settings.job.delete_files(frame) + # # delete views + # self.render_settings.job.delete_files(frame) - # if it was a still image - elif not self.render_settings.job.animation: + # # if it was a still image + # elif not self.render_settings.job.animation: - # delete its views - self.render_settings.job.delete_files() + # # delete its views + # self.render_settings.job.delete_files() From 185eeeac768d81c33c75acfe5514e809035d2633 Mon Sep 17 00:00:00 2001 From: Dillon Barnes Date: Tue, 12 Nov 2024 10:51:45 +0000 Subject: [PATCH 02/13] AmberLG --- __init__.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/__init__.py b/__init__.py index 257e694..099490b 100644 --- a/__init__.py +++ b/__init__.py @@ -19,12 +19,12 @@ # -------------------- DEFINE ADDON ---------------------- bl_info = { - "name": "Alice/LG", + "name": "Amber/LG/", "author": "Christian Stolze", "version": (2, 3, 0), "blender": (2, 93, 6), "location": "View3D > Looking Glass Tab", - "description": "Alice/LG takes your artworks through the Looking Glass (light field displays)", + "description": "Amber/LG is Alice/LG which takes your artworks through the Looking Glass (light field displays) but it doesn't delete files", "category": "View", "warning": "", "doc_url": "https://github.com/regcs/AliceLG/blob/master/README.md", From fa4c3cdb15eea4733766c5476df670d3ac434ad4 Mon Sep 17 00:00:00 2001 From: Liciniuos Date: Fri, 15 Nov 2024 19:56:17 +0000 Subject: [PATCH 03/13] Added option to only render views. Added lots of debug logs --- __init__.py | 2 +- lightfield_render.py | 161 ++++++++++++++++++++++++------------------- ui.py | 5 +- 3 files changed, 95 insertions(+), 73 deletions(-) diff --git a/__init__.py b/__init__.py index 099490b..0960eda 100644 --- a/__init__.py +++ b/__init__.py @@ -21,7 +21,7 @@ bl_info = { "name": "Amber/LG/", "author": "Christian Stolze", - "version": (2, 3, 0), + "version": (2, 3, 3), "blender": (2, 93, 6), "location": "View3D > Looking Glass Tab", "description": "Amber/LG is Alice/LG which takes your artworks through the Looking Glass (light field displays) but it doesn't delete files", diff --git a/lightfield_render.py b/lightfield_render.py index 7cc513c..7c9e4bc 100644 --- a/lightfield_render.py +++ b/lightfield_render.py @@ -469,9 +469,10 @@ def setup_camera(self): self.scene.camera = self._camera_active # assemble quilt + #BookMark def assemble_quilt(self): - LookingGlassAddonLogger.info("Assembling the quilt from the rendered views:") + print("Assembling the quilt from the rendered views:") # GET THE PIXEL DATA OF THE RENDERED VIEWS # ++++++++++++++++++++++++++++++++++++++++++++ @@ -510,7 +511,7 @@ def assemble_quilt(self): return None - LookingGlassAddonLogger.info(" [#] Loaded all views into memory.") + print(" [#] Loaded all views into memory.") # ASSEMBLE THE QUILT @@ -544,7 +545,7 @@ def assemble_quilt(self): quiltPixels = np.reshape(quiltPixels, (self.columns * self.rows * (self.scene.render.resolution_x * self.scene.render.resolution_y * 4))) # log info - LookingGlassAddonLogger.info(" [#] Assembled quilt in memory.") + print(" [#] Assembled quilt in memory.") # copy the viewfile # NOTE: We use copyfile() instead of copy(), because the latter failed @@ -563,7 +564,7 @@ def assemble_quilt(self): self._quilt_image = bpy.data.images.load(filepath=self.quilt_filepath()) # log debug info - LookingGlassAddonLogger.info(" [#] Saved quilt file to: " + self._quilt_image.filepath) + print(" [#] Saved quilt file to: " + self._quilt_image.filepath) # NOTE: Creating a new image via the dedicated operators and methods # didn't apply the correct image formats and settings @@ -571,7 +572,7 @@ def assemble_quilt(self): self._quilt_image.scale(self.scene.render.resolution_x * self.columns, self.scene.render.resolution_y * self.rows) # log info - LookingGlassAddonLogger.info(" [#] Reading quilt pixel data into the image data block.") + print(" [#] Reading quilt pixel data into the image data block.") # apply the assembled quilt pixel data self._quilt_image.pixels.foreach_set(quiltPixels) @@ -589,7 +590,7 @@ def assemble_quilt(self): self._quilt_image.name = self.file_temp_name # log info - LookingGlassAddonLogger.info(" [#] Done.") + print(" [#] Done.") # return the quilt image return self._quilt_image @@ -621,9 +622,9 @@ def delete_files(self, frame=None): # setup the camera system for rendering def clean_up(self): - LookingGlassAddonLogger.info("Cleaning up camera setup.") + print("Cleaning up camera setup.") - # if there is an active camera marker in this frame + # if there is an active camera marker in this frame marker_camera_found = False marker_cameras = [marker for marker in bpy.context.scene.timeline_markers if marker.camera is not None] if marker_cameras: @@ -644,14 +645,14 @@ def clean_up(self): # if no marker camera was found if not marker_camera_found: - + # restore the original active camera self.scene.camera = self._camera_original # delete the temporarily created camera data block if bpy.data.objects.find(self._camera_temp_basename) != -1: - LookingGlassAddonLogger.info(" [#] Delete temporary camera: %s" % (bpy.data.objects[self._camera_temp_basename])) + print(" [#] Delete temporary camera: %s" % (bpy.data.objects[self._camera_temp_basename])) # remove the data blocks bpy.data.cameras.remove(bpy.data.objects[self._camera_temp_basename].data, do_unlink=True, do_id_user=True, do_ui_user=True) @@ -659,7 +660,7 @@ def clean_up(self): # clear the list self._camera_temp.clear() - LookingGlassAddonLogger.info(" [#] Setting scene camera to the original camera: %s" % (self._camera_original)) + print(" [#] Setting scene camera to the original camera: %s" % (self._camera_original)) # MULTIVIEW CAMERA RENDERING # ++++++++++++++++++++++++++++++++++ @@ -675,19 +676,19 @@ def clean_up(self): for view, camera in enumerate(self._camera_temp): # delete the temporarily created camera data block - LookingGlassAddonLogger.info(" [#] Delete temporary camera: %s" % (camera)) + print(" [#] Delete temporary camera: %s" % (camera)) bpy.data.cameras.remove(camera.data, do_unlink=True, do_id_user=True, do_ui_user=True) # remove the corresponding temporary multiview data block if self.scene.render.views.find(self._multiview_view_basename + str(view).zfill(len(str(self.total_views - 1)))) != -1: - LookingGlassAddonLogger.info(" [#] Delete render view: %s" % (self.scene.render.views[self._multiview_view_basename + str(view).zfill(len(str(self.total_views - 1)))])) + print(" [#] Delete render view: %s" % (self.scene.render.views[self._multiview_view_basename + str(view).zfill(len(str(self.total_views - 1)))])) self.scene.render.views.remove(self.scene.render.views[self._multiview_view_basename + str(view).zfill(len(str(self.total_views - 1)))]) # clear the list self._camera_temp.clear() - LookingGlassAddonLogger.info(" [#] Setting scene camera to the original camera: %s" % (self._camera_original)) - LookingGlassAddonLogger.info(" [#] Remaining Cameras: %i" % len(self._camera_temp)) + print(" [#] Setting scene camera to the original camera: %s" % (self._camera_original)) + print(" [#] Remaining Cameras: %i" % len(self._camera_temp)) # set to view format to self.scene.render.views_format = 'STEREO_3D' @@ -732,7 +733,7 @@ def init_render(self, Scene, depsgraph): self._state = "INIT_RENDER" # log info - LookingGlassAddonLogger.info("Rendering job initialized. (lockfile: %s, init: %s)" % (self._use_lockfile, self.init)) + print("Rendering job initialized. (lockfile: %s, init: %s)" % (self._use_lockfile, self.init)) # function that is called before rendering starts def pre_render(self, Scene, depsgraph): @@ -745,26 +746,26 @@ def pre_render(self, Scene, depsgraph): if not self.use_multiview: # output current status - LookingGlassAddonLogger.info("Rendering view is going to be prepared.") - LookingGlassAddonLogger.info(" [#] active camera: %s" % self._camera_active) - LookingGlassAddonLogger.info(" [#] current frame: %s" % self.frame) - LookingGlassAddonLogger.info(" [#] current subframe: %s" % self.subframe) - LookingGlassAddonLogger.info(" [#] current view: %s" % self.view) - LookingGlassAddonLogger.info(" [#] current quilt file: %s" % self.quilt_filepath()) - LookingGlassAddonLogger.info(" [#] current view file: %s" % self.view_filepath()) + print("Rendering view is going to be prepared.") + print(" [#] active camera: %s" % self._camera_active) + print(" [#] current frame: %s" % self.frame) + print(" [#] current subframe: %s" % self.subframe) + print(" [#] current view: %s" % self.view) + print(" [#] current quilt file: %s" % self.quilt_filepath()) + print(" [#] current view file: %s" % self.view_filepath()) # MULTIVIEW CAMERA RENDERING # ++++++++++++++++++++++++++++++++++ elif self.use_multiview: # output current status - LookingGlassAddonLogger.info("Rendering multiview is going to be prepared.") - LookingGlassAddonLogger.info(" [#] active camera: %s" % self._camera_active) - LookingGlassAddonLogger.info(" [#] current frame: %s" % self.frame) - LookingGlassAddonLogger.info(" [#] current subframe: %s" % self.subframe) - LookingGlassAddonLogger.info(" [#] current view: all (multiview)") - LookingGlassAddonLogger.info(" [#] current quilt file: %s" % self.quilt_filepath()) - LookingGlassAddonLogger.info(" [#] current view file: %s" % self.view_filepath()) + print("Rendering multiview is going to be prepared.") + print(" [#] active camera: %s" % self._camera_active) + print(" [#] current frame: %s" % self.frame) + print(" [#] current subframe: %s" % self.subframe) + print(" [#] current view: all (multiview)") + print(" [#] current quilt file: %s" % self.quilt_filepath()) + print(" [#] current view file: %s" % self.view_filepath()) # function that is called after rendering finished def post_render(self, Scene, depsgraph): @@ -772,7 +773,7 @@ def post_render(self, Scene, depsgraph): # update operator state self._state = "POST_RENDER" - LookingGlassAddonLogger.info("Saving view file: %s" % self.view_filepath()) + print("Saving view file: %s" % self.view_filepath()) # save the rendered image in a file #bpy.data.images["Render Result"].save_render(filepath=self.view_filepath(), scene=self.scene) @@ -791,7 +792,7 @@ def cancel_render(self, Scene, depsgraph): self._state = "CANCEL_RENDER" self.scene.addon_settings.render_stop = True - LookingGlassAddonLogger.info("Rendering job was cancelled.") + print("Rendering job was cancelled.") # a class whose instances will store Blender's RenderSettings attribute class RenderSettings: @@ -1372,7 +1373,7 @@ def cancel(self, context): # remove event timer if self._handle_event_timer: context.window_manager.event_timer_remove(self._handle_event_timer) - LookingGlassAddonLogger.info("Removing application handlers.") + print("Removing application handlers.") @@ -1387,24 +1388,33 @@ def cancel(self, context): # CLEAN-UP FILES # +++++++++++++++++++++++++++++++++++++++++++ # if the view files shall not be kept OR (still was rendered AND no filename was specfied) OR the file keeping is forced OR the incomplete render job was discarded - # if ((self.render_settings.addon_settings.render_output == '1' or (not ((self.render_settings.job.animation == False and not self.render_settings.job.file_use_temp) or self.animation == True))) and self.render_settings.job.file_force_keep == False) or self.discard_lockfile == True: + print(f"{self.render_settings.addon_settings.render_output} - output type") #0 + print(self.render_settings.job.animation)# True + print(self.render_settings.job.file_use_temp)# False + print(self.animation)# True + print(self.render_settings.job.file_force_keep)# False + print(self.discard_lockfile)# False + + if ((self.render_settings.addon_settings.render_output == '1' or (not ((self.render_settings.job.animation == False and not self.render_settings.job.file_use_temp) or self.animation == True))) and self.render_settings.job.file_force_keep == False) or self.discard_lockfile == True: - # LookingGlassAddonLogger.info("Cleaning up the disk files.") + #BookMark - # # if it was an animation - # if self.render_settings.job.animation: + print("Cleaning up the disk files.") - # # for all frames of the animation - # for frame in range(self.render_settings.job.scene.frame_start, self.render_settings.job.scene.frame_end + self.render_settings.frame_step): + # if it was an animation + if self.render_settings.job.animation: - # # delete views - # self.render_settings.job.delete_files(frame) + # for all frames of the animation + for frame in range(self.render_settings.job.scene.frame_start, self.render_settings.job.scene.frame_end + self.render_settings.frame_step): - # # if it was a still image - # elif not self.render_settings.job.animation: + # delete views + self.render_settings.job.delete_files(frame) - # # delete its views - # self.render_settings.job.delete_files() + # if it was a still image + elif not self.render_settings.job.animation: + + # delete its views + self.render_settings.job.delete_files() @@ -1473,6 +1483,7 @@ def invoke(self, context, event): self.report({"ERROR"}, "Render job can not be continued. Lockfile not found or corrupted.") # cancel the operator + print('canceled - 2') self.cancel(context) # don't execute operator @@ -1592,6 +1603,7 @@ def invoke(self, context, event): if self.discard_lockfile == True: # cancel the operator + print('canceled - 1') self.cancel(context) # notify user @@ -1605,11 +1617,11 @@ def invoke(self, context, event): if bpy.context.scene.render.use_compositing and not bpy.context.scene.render.use_sequencer: # notify user self.report({"WARNING"}, "The compositor is active. This might cause issues during quilt rendering.") - + elif not bpy.context.scene.render.use_compositing and bpy.context.scene.render.use_sequencer: # notify user self.report({"WARNING"}, "The sequencer is active. This might cause issues during quilt rendering.") - + elif bpy.context.scene.render.use_compositing and bpy.context.scene.render.use_sequencer: # notify user self.report({"WARNING"}, "The compositor and sequencer are active. This might cause issues during quilt rendering.") @@ -1768,40 +1780,46 @@ def modal(self, context, event): if self.render_settings.job.view == (self.render_settings.job.view_end - 1) or self.use_multiview: start = time.time() - # assemble the quilt from the view data - if not self.render_settings.job.assemble_quilt(): + #BookMark - # cancel the operator - self.render_settings.addon_settings.render_stop = True + print('about to make quilt') + if self.render_settings.addon_settings.render_output != '2': - # force the operator to keep the view Files - self.file_force_keep = True + # assemble the quilt from the view data + if not self.render_settings.job.assemble_quilt(): + print('failed to make quilt') - # notify user - self.cancel_sign = "ERROR" - self.cancel_message = "Render job can not be continued. Missing view file(s) of the previously failed render job." + # cancel the operator + self.render_settings.addon_settings.render_stop = True + + # force the operator to keep the view Files + self.file_force_keep = True + + # notify user + self.cancel_sign = "ERROR" + self.cancel_message = "Render job can not be continued. Missing view file(s) of the previously failed render job." - # QUILT DISPLAY AS RENDER RESULT - # ++++++++++++++++++++++++++++++++++++++++++++ - for window in context.window_manager.windows: - for area in window.screen.areas: + # QUILT DISPLAY AS RENDER RESULT + # ++++++++++++++++++++++++++++++++++++++++++++ + for window in context.window_manager.windows: + for area in window.screen.areas: - if area.type == 'IMAGE_EDITOR': + if area.type == 'IMAGE_EDITOR': - if area.spaces.active != None: + if area.spaces.active != None: - if area.spaces.active.image != None: + if area.spaces.active.image != None: - if area.spaces.active.image.name == "Render Result": + if area.spaces.active.image.name == "Render Result": - # and change the active image shown here to the quilt - area.spaces.active.image = self.render_settings.job._quilt_image + # and change the active image shown here to the quilt + area.spaces.active.image = self.render_settings.job._quilt_image - # fit the zoom factor in this window to show the complete quilt - # bpy.ops.image.view_all({'window': window, 'screen': window.screen, 'area': area}) + # fit the zoom factor in this window to show the complete quilt + # bpy.ops.image.view_all({'window': window, 'screen': window.screen, 'area': area}) - break + break # UPDATE LOCKFILE @@ -1866,10 +1884,12 @@ def modal(self, context, event): # if the view files shall not be kept if ((self.render_settings.addon_settings.render_output == '1') and self.render_settings.job.file_force_keep == False): - +# # delete views of the rendered frame self.render_settings.job.delete_files(self.render_settings.job.frame) + #BookMark + # delete the temporarily created camera self.render_settings.job.clean_up() @@ -1909,6 +1929,7 @@ def modal(self, context, event): if (self.render_settings.job._state == "INVOKE_RENDER" or self.render_settings.job._state == "COMPLETE_RENDER" or self.render_settings.job._state == "CANCEL_RENDER") and self.render_settings.addon_settings.render_stop: # cancel the operator + print('canceled - 0') self.cancel(context) # notify user diff --git a/ui.py b/ui.py index f7d8114..ae0c7d3 100644 --- a/ui.py +++ b/ui.py @@ -1022,8 +1022,9 @@ class LookingGlassAddonSettingsScene(bpy.types.PropertyGroup): # File handling render_output: bpy.props.EnumProperty( items = [('0', 'View and Quilt Files', 'Each view is rendered to a separate file in the output directory in addition to the quilt.'), - ('1', 'Only Quilt File', 'Each view is rendered to a temporary file in the output directory. These files are deleted after the quilt is complete.')], - default='1', + ('1', 'Only Quilt File', 'Each view is rendered to a temporary file in the output directory. These files are deleted after the quilt is complete.'), + ('2', 'Only View Files', 'Each view is rendered to a separate file in the output directory.')], + default='0', name="Output", ) From 242e20459254cfdbdc8c78120e5b42016408b329 Mon Sep 17 00:00:00 2001 From: Liciniuos Date: Fri, 15 Nov 2024 22:42:52 +0000 Subject: [PATCH 04/13] saftey --- __init__.py | 2 +- lightfield_render.py | 40 +++++++++++++++++++-------------- ui.py | 53 ++++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 77 insertions(+), 18 deletions(-) diff --git a/__init__.py b/__init__.py index 0960eda..099490b 100644 --- a/__init__.py +++ b/__init__.py @@ -21,7 +21,7 @@ bl_info = { "name": "Amber/LG/", "author": "Christian Stolze", - "version": (2, 3, 3), + "version": (2, 3, 0), "blender": (2, 93, 6), "location": "View3D > Looking Glass Tab", "description": "Amber/LG is Alice/LG which takes your artworks through the Looking Glass (light field displays) but it doesn't delete files", diff --git a/lightfield_render.py b/lightfield_render.py index 7c9e4bc..ef7ffda 100644 --- a/lightfield_render.py +++ b/lightfield_render.py @@ -262,7 +262,7 @@ def invoke(self): # setup the camera (system) for rendering def setup_camera(self): - # check, if there is an active camera marker in this frame + # check, if there is an active camera marker in this frame marker_camera_found = False marker_cameras = [marker for marker in bpy.context.scene.timeline_markers if marker.camera is not None] if marker_cameras: @@ -333,8 +333,8 @@ def setup_camera(self): # required for single cameras. Rendering still works, # which is nice, because the camera remains invisible. # Leave this here for debugging purposes. - # # add this camera to the master collection of the scene - # self.scene.collection.objects.link(self._camera_active) + # add this camera to the master collection of the scene + #self.scene.collection.objects.link(self._camera_active) # CAMERA SETTINGS: APPLY POSITION AND SHIFT @@ -469,7 +469,6 @@ def setup_camera(self): self.scene.camera = self._camera_active # assemble quilt - #BookMark def assemble_quilt(self): print("Assembling the quilt from the rendered views:") @@ -735,6 +734,8 @@ def init_render(self, Scene, depsgraph): # log info print("Rendering job initialized. (lockfile: %s, init: %s)" % (self._use_lockfile, self.init)) + #BookMark + # function that is called before rendering starts def pre_render(self, Scene, depsgraph): @@ -859,7 +860,7 @@ def __init__(self, BlenderScene, animation, use_lockfile, use_multiview, blockin # deactivate the "Add Metadata option" self.scene.addon_settings.render_add_suffix = False - # if an starting frame was specified + # if a starting frame was specified if "-s" in LookingGlassAddon.addon_arguments or "--frame-start" in LookingGlassAddon.addon_arguments: # get the file name position @@ -921,7 +922,7 @@ def __init__(self, BlenderScene, animation, use_lockfile, use_multiview, blockin # set the current frame self.scene.frame_current = int(LookingGlassAddon.addon_arguments[index]) - # if a rendering frame was specified + # if a rendering view was specified if "-v" in LookingGlassAddon.addon_arguments or "--render-view" in LookingGlassAddon.addon_arguments: # get the view index @@ -946,7 +947,6 @@ def __init__(self, BlenderScene, animation, use_lockfile, use_multiview, blockin # set the current frame self.view_end = int(LookingGlassAddon.addon_arguments[index + 1]) + 1 - # INITIALIZATION # ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ @@ -954,6 +954,15 @@ def __init__(self, BlenderScene, animation, use_lockfile, use_multiview, blockin # which can be accessed from methods that have no "context" parameter self.addon_settings = self.scene.addon_settings + #BookMark + print('view start',self.addon_settings.render_view_start) + print('view end',self.addon_settings.render_view_end) + self.view_start = int(self.addon_settings.render_view_start) + print('render output',self.addon_settings.render_output) + self.addon_settings.render_output = '2' + print('render output',self.addon_settings.render_output) + #if <= self.view_end = self._qs[int(self._quilt_preset)]["total_views"]: + # initialize the rendering job variables self.job = RenderJob(self.scene, self.animation, self._use_lockfile, self.use_multiview, self.blocking) @@ -1091,7 +1100,7 @@ def __init__(self, BlenderScene, animation, use_lockfile, use_multiview, blockin # NOTE: This function is largely taken from https://stackoverflow.com/a/1118038 def to_dict(self, obj, classkey=None): - # if this is an dictionary + # if this is a dictionary if isinstance(obj, dict): data = {} for (k, v) in obj.items(): @@ -1388,12 +1397,12 @@ def cancel(self, context): # CLEAN-UP FILES # +++++++++++++++++++++++++++++++++++++++++++ # if the view files shall not be kept OR (still was rendered AND no filename was specfied) OR the file keeping is forced OR the incomplete render job was discarded - print(f"{self.render_settings.addon_settings.render_output} - output type") #0 - print(self.render_settings.job.animation)# True - print(self.render_settings.job.file_use_temp)# False - print(self.animation)# True - print(self.render_settings.job.file_force_keep)# False - print(self.discard_lockfile)# False + #print(f"{self.render_settings.addon_settings.render_output} - output type") #0 + #print(self.render_settings.job.animation)# True + #print(self.render_settings.job.file_use_temp)# False + #print(self.animation)# True + #print(self.render_settings.job.file_force_keep)# False + #print(self.discard_lockfile)# False if ((self.render_settings.addon_settings.render_output == '1' or (not ((self.render_settings.job.animation == False and not self.render_settings.job.file_use_temp) or self.animation == True))) and self.render_settings.job.file_force_keep == False) or self.discard_lockfile == True: @@ -1782,7 +1791,6 @@ def modal(self, context, event): #BookMark - print('about to make quilt') if self.render_settings.addon_settings.render_output != '2': # assemble the quilt from the view data @@ -1888,8 +1896,6 @@ def modal(self, context, event): # delete views of the rendered frame self.render_settings.job.delete_files(self.render_settings.job.frame) - #BookMark - # delete the temporarily created camera self.render_settings.job.clean_up() diff --git a/ui.py b/ui.py index ae0c7d3..cf653a5 100644 --- a/ui.py +++ b/ui.py @@ -1027,6 +1027,27 @@ class LookingGlassAddonSettingsScene(bpy.types.PropertyGroup): default='0', name="Output", ) + + #View specification + render_view_start: bpy.props.FloatProperty( + name = "View Start", + default = 0, + min = 0, + precision = 1, + step = 5, + unit = "NONE", + description = "The starting viewing angle for the render.", + ) + + render_view_end: bpy.props.FloatProperty( + name = "View End", + default = 66, + min = 0, + precision = 1, + step = 5, + unit = "NONE", + description = "The last viewing angle for the render.", + ) # Progress bar render_progress: bpy.props.FloatProperty( @@ -1480,6 +1501,7 @@ def draw(self, context): # display the clipping settings camera = context.scene.addon_settings.lookingglassCamera if camera: + #bookmark column.separator() row_clip_start = column.row(align = True) @@ -1538,6 +1560,8 @@ def draw(self, context): row_metadata = row_general_options.row(align = True) render_add_suffix = row_metadata.prop(context.scene.addon_settings, "render_add_suffix") + #bookmark + # Render orientation row_orientation = layout.row(align = True) column_1 = row_orientation.row(align = True) @@ -1565,6 +1589,24 @@ def draw(self, context): column_2.prop(context.scene.addon_settings, "render_output", text="") column_2.scale_x = 0.7 + # Start view + row_view_start = layout.row(align = True) + column_1 = row_view_start.row(align = True) + column_1.label(text="Start View:") + column_1.scale_x = 0.3 + column_2 = row_view_start.row(align = True) + column_2.prop(context.scene.addon_settings, "render_view_start", text="") + column_2.scale_x = 0.7 + + # End view + row_view_end = layout.row(align = True) + column_1 = row_view_end.row(align = True) + column_1.label(text="End View:") + column_1.scale_x = 0.3 + column_2 = row_view_end.row(align = True) + column_2.prop(context.scene.addon_settings, "render_view_end", text="") + column_2.scale_x = 0.7 + # if no lockfile was detected on start-up OR the render job is running if not LookingGlassAddon.has_lockfile or LookingGlassAddon.RenderInvoked: @@ -1603,6 +1645,8 @@ def draw(self, context): row_orientation.enabled = False row_preset.enabled = False row_output.enabled = False + row_view_start.enabled = False + row_view_end.enabled = False # inform the user and provide options to continue or to discard row_render_still = layout.row(align = True) @@ -1627,6 +1671,8 @@ def draw(self, context): row_orientation.enabled = False row_preset.enabled = False row_output.enabled = False + row_view_start.enabled = False + row_view_end.enabled = False if LookingGlassAddon.RenderAnimation == True: row_render_still.enabled = False if LookingGlassAddon.RenderAnimation == False: row_render_animation.enabled = False @@ -1640,6 +1686,8 @@ def draw(self, context): row_orientation.enabled = False row_preset.enabled = False row_output.enabled = False + row_view_start.enabled = False + row_view_end.enabled = False row_render_still.enabled = False row_render_animation.enabled = False @@ -1649,6 +1697,8 @@ def draw(self, context): # disable all elements row_orientation.enabled = False row_preset.enabled = False + row_view_start.enabled = False + row_view_end.enabled = False # if no Looking Glass was detected AND debug mode is not activated if not pylio.DeviceManager.count() and not LookingGlassAddon.debugging_use_dummy_device: @@ -1726,6 +1776,7 @@ def draw(self, context): row_preset = column.row() row_preset.prop(context.window_manager.addon_settings, "lightfieldMode", text="") row_preset.operator("lookingglass.refresh_lightfield", text="", icon='FILE_REFRESH') + #WHAT # Preview settings row_output = column.row(align = True) @@ -2012,6 +2063,8 @@ def draw(self, context): column_2.prop(context.scene.addon_settings, "imageeditor_block_device_type", text="") column_2.scale_x = 0.7 + + #huh # Quilt settings row_preset = layout.row(align = True) row_preset.enabled = (not LookingGlassAddon.ImageBlockRenderer.is_imageeditor_detected()) From 29614f3185241268131ad1540e705b7c8b0de53b Mon Sep 17 00:00:00 2001 From: Liciniuos Date: Sat, 16 Nov 2024 00:24:31 +0000 Subject: [PATCH 05/13] Added view ranges into ui with checkbox to toggle use --- lightfield_render.py | 114 +++++++++++++++++++++---------------------- ui.py | 69 ++++++++++++++------------ 2 files changed, 96 insertions(+), 87 deletions(-) diff --git a/lightfield_render.py b/lightfield_render.py index ef7ffda..df430b5 100644 --- a/lightfield_render.py +++ b/lightfield_render.py @@ -471,7 +471,7 @@ def setup_camera(self): # assemble quilt def assemble_quilt(self): - print("Assembling the quilt from the rendered views:") + LookingGlassAddonLogger.info("Assembling the quilt from the rendered views:") # GET THE PIXEL DATA OF THE RENDERED VIEWS # ++++++++++++++++++++++++++++++++++++++++++++ @@ -510,7 +510,7 @@ def assemble_quilt(self): return None - print(" [#] Loaded all views into memory.") + LookingGlassAddonLogger.info(" [#] Loaded all views into memory.") # ASSEMBLE THE QUILT @@ -544,7 +544,7 @@ def assemble_quilt(self): quiltPixels = np.reshape(quiltPixels, (self.columns * self.rows * (self.scene.render.resolution_x * self.scene.render.resolution_y * 4))) # log info - print(" [#] Assembled quilt in memory.") + LookingGlassAddonLogger.info(" [#] Assembled quilt in memory.") # copy the viewfile # NOTE: We use copyfile() instead of copy(), because the latter failed @@ -563,7 +563,7 @@ def assemble_quilt(self): self._quilt_image = bpy.data.images.load(filepath=self.quilt_filepath()) # log debug info - print(" [#] Saved quilt file to: " + self._quilt_image.filepath) + LookingGlassAddonLogger.info(" [#] Saved quilt file to: " + self._quilt_image.filepath) # NOTE: Creating a new image via the dedicated operators and methods # didn't apply the correct image formats and settings @@ -571,7 +571,7 @@ def assemble_quilt(self): self._quilt_image.scale(self.scene.render.resolution_x * self.columns, self.scene.render.resolution_y * self.rows) # log info - print(" [#] Reading quilt pixel data into the image data block.") + LookingGlassAddonLogger.info(" [#] Reading quilt pixel data into the image data block.") # apply the assembled quilt pixel data self._quilt_image.pixels.foreach_set(quiltPixels) @@ -589,7 +589,7 @@ def assemble_quilt(self): self._quilt_image.name = self.file_temp_name # log info - print(" [#] Done.") + LookingGlassAddonLogger.info(" [#] Done.") # return the quilt image return self._quilt_image @@ -621,7 +621,7 @@ def delete_files(self, frame=None): # setup the camera system for rendering def clean_up(self): - print("Cleaning up camera setup.") + LookingGlassAddonLogger.info("Cleaning up camera setup.") # if there is an active camera marker in this frame marker_camera_found = False @@ -651,7 +651,7 @@ def clean_up(self): # delete the temporarily created camera data block if bpy.data.objects.find(self._camera_temp_basename) != -1: - print(" [#] Delete temporary camera: %s" % (bpy.data.objects[self._camera_temp_basename])) + LookingGlassAddonLogger.info(" [#] Delete temporary camera: %s" % (bpy.data.objects[self._camera_temp_basename])) # remove the data blocks bpy.data.cameras.remove(bpy.data.objects[self._camera_temp_basename].data, do_unlink=True, do_id_user=True, do_ui_user=True) @@ -659,7 +659,7 @@ def clean_up(self): # clear the list self._camera_temp.clear() - print(" [#] Setting scene camera to the original camera: %s" % (self._camera_original)) + LookingGlassAddonLogger.info(" [#] Setting scene camera to the original camera: %s" % (self._camera_original)) # MULTIVIEW CAMERA RENDERING # ++++++++++++++++++++++++++++++++++ @@ -675,19 +675,19 @@ def clean_up(self): for view, camera in enumerate(self._camera_temp): # delete the temporarily created camera data block - print(" [#] Delete temporary camera: %s" % (camera)) + LookingGlassAddonLogger.info(" [#] Delete temporary camera: %s" % (camera)) bpy.data.cameras.remove(camera.data, do_unlink=True, do_id_user=True, do_ui_user=True) # remove the corresponding temporary multiview data block if self.scene.render.views.find(self._multiview_view_basename + str(view).zfill(len(str(self.total_views - 1)))) != -1: - print(" [#] Delete render view: %s" % (self.scene.render.views[self._multiview_view_basename + str(view).zfill(len(str(self.total_views - 1)))])) + LookingGlassAddonLogger.info(" [#] Delete render view: %s" % (self.scene.render.views[self._multiview_view_basename + str(view).zfill(len(str(self.total_views - 1)))])) self.scene.render.views.remove(self.scene.render.views[self._multiview_view_basename + str(view).zfill(len(str(self.total_views - 1)))]) # clear the list self._camera_temp.clear() - print(" [#] Setting scene camera to the original camera: %s" % (self._camera_original)) - print(" [#] Remaining Cameras: %i" % len(self._camera_temp)) + LookingGlassAddonLogger.info(" [#] Setting scene camera to the original camera: %s" % (self._camera_original)) + LookingGlassAddonLogger.info(" [#] Remaining Cameras: %i" % len(self._camera_temp)) # set to view format to self.scene.render.views_format = 'STEREO_3D' @@ -732,7 +732,7 @@ def init_render(self, Scene, depsgraph): self._state = "INIT_RENDER" # log info - print("Rendering job initialized. (lockfile: %s, init: %s)" % (self._use_lockfile, self.init)) + LookingGlassAddonLogger.info("Rendering job initialized. (lockfile: %s, init: %s)" % (self._use_lockfile, self.init)) #BookMark @@ -747,26 +747,26 @@ def pre_render(self, Scene, depsgraph): if not self.use_multiview: # output current status - print("Rendering view is going to be prepared.") - print(" [#] active camera: %s" % self._camera_active) - print(" [#] current frame: %s" % self.frame) - print(" [#] current subframe: %s" % self.subframe) - print(" [#] current view: %s" % self.view) - print(" [#] current quilt file: %s" % self.quilt_filepath()) - print(" [#] current view file: %s" % self.view_filepath()) + LookingGlassAddonLogger.info("Rendering view is going to be prepared.") + LookingGlassAddonLogger.info(" [#] active camera: %s" % self._camera_active) + LookingGlassAddonLogger.info(" [#] current frame: %s" % self.frame) + LookingGlassAddonLogger.info(" [#] current subframe: %s" % self.subframe) + LookingGlassAddonLogger.info(" [#] current view: %s" % self.view) + LookingGlassAddonLogger.info(" [#] current quilt file: %s" % self.quilt_filepath()) + LookingGlassAddonLogger.info(" [#] current view file: %s" % self.view_filepath()) # MULTIVIEW CAMERA RENDERING # ++++++++++++++++++++++++++++++++++ elif self.use_multiview: # output current status - print("Rendering multiview is going to be prepared.") - print(" [#] active camera: %s" % self._camera_active) - print(" [#] current frame: %s" % self.frame) - print(" [#] current subframe: %s" % self.subframe) - print(" [#] current view: all (multiview)") - print(" [#] current quilt file: %s" % self.quilt_filepath()) - print(" [#] current view file: %s" % self.view_filepath()) + LookingGlassAddonLogger.info("Rendering multiview is going to be prepared.") + LookingGlassAddonLogger.info(" [#] active camera: %s" % self._camera_active) + LookingGlassAddonLogger.info(" [#] current frame: %s" % self.frame) + LookingGlassAddonLogger.info(" [#] current subframe: %s" % self.subframe) + LookingGlassAddonLogger.info(" [#] current view: all (multiview)") + LookingGlassAddonLogger.info(" [#] current quilt file: %s" % self.quilt_filepath()) + LookingGlassAddonLogger.info(" [#] current view file: %s" % self.view_filepath()) # function that is called after rendering finished def post_render(self, Scene, depsgraph): @@ -774,7 +774,7 @@ def post_render(self, Scene, depsgraph): # update operator state self._state = "POST_RENDER" - print("Saving view file: %s" % self.view_filepath()) + LookingGlassAddonLogger.info("Saving view file: %s" % self.view_filepath()) # save the rendered image in a file #bpy.data.images["Render Result"].save_render(filepath=self.view_filepath(), scene=self.scene) @@ -793,7 +793,7 @@ def cancel_render(self, Scene, depsgraph): self._state = "CANCEL_RENDER" self.scene.addon_settings.render_stop = True - print("Rendering job was cancelled.") + LookingGlassAddonLogger.info("Rendering job was cancelled.") # a class whose instances will store Blender's RenderSettings attribute class RenderSettings: @@ -954,15 +954,6 @@ def __init__(self, BlenderScene, animation, use_lockfile, use_multiview, blockin # which can be accessed from methods that have no "context" parameter self.addon_settings = self.scene.addon_settings - #BookMark - print('view start',self.addon_settings.render_view_start) - print('view end',self.addon_settings.render_view_end) - self.view_start = int(self.addon_settings.render_view_start) - print('render output',self.addon_settings.render_output) - self.addon_settings.render_output = '2' - print('render output',self.addon_settings.render_output) - #if <= self.view_end = self._qs[int(self._quilt_preset)]["total_views"]: - # initialize the rendering job variables self.job = RenderJob(self.scene, self.animation, self._use_lockfile, self.use_multiview, self.blocking) @@ -1001,10 +992,18 @@ def __init__(self, BlenderScene, animation, use_lockfile, use_multiview, blockin # get all quilt presets from pylio self._qs = pylio.LookingGlassQuilt.formats.get() - # set view range to default if None was given - if self.view_start is None: self.view_start = 0 - if self.view_end is None: self.view_end = self._qs[int(self._quilt_preset)]["total_views"] - + #BookMark + if self.addon_settings.render_use_view_range: + #The quilt will fail if all 66 veiws are not made + self.addon_settings.render_output = '2' + if self.addon_settings.render_view_start <= self._qs[int(self._quilt_preset)]["total_views"]: + self.view_start = self.addon_settings.render_view_start + if self.addon_settings.render_view_end + 1 <= self._qs[int(self._quilt_preset)]["total_views"]: + self.view_end = self.addon_settings.render_view_end + 1 + else: + # set view range to default if None was given + if self.view_start is None: self.view_start = 0 + if self.view_end is None: self.view_end = self._qs[int(self._quilt_preset)]["total_views"] # PATH SETTINGS # ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ @@ -1382,7 +1381,7 @@ def cancel(self, context): # remove event timer if self._handle_event_timer: context.window_manager.event_timer_remove(self._handle_event_timer) - print("Removing application handlers.") + LookingGlassAddonLogger.info("Removing application handlers.") @@ -1396,19 +1395,20 @@ def cancel(self, context): # CLEAN-UP FILES # +++++++++++++++++++++++++++++++++++++++++++ + #print example # if the view files shall not be kept OR (still was rendered AND no filename was specfied) OR the file keeping is forced OR the incomplete render job was discarded - #print(f"{self.render_settings.addon_settings.render_output} - output type") #0 - #print(self.render_settings.job.animation)# True - #print(self.render_settings.job.file_use_temp)# False - #print(self.animation)# True - #print(self.render_settings.job.file_force_keep)# False - #print(self.discard_lockfile)# False + #LookingGlassAddonLogger.info(f"{self.render_settings.addon_settings.render_output} - output type") #0 + #LookingGlassAddonLogger.info(self.render_settings.job.animation)# True + #LookingGlassAddonLogger.info(self.render_settings.job.file_use_temp)# False + #LookingGlassAddonLogger.info(self.animation)# True + #LookingGlassAddonLogger.info(self.render_settings.job.file_force_keep)# False + #LookingGlassAddonLogger.info(self.discard_lockfile)# False if ((self.render_settings.addon_settings.render_output == '1' or (not ((self.render_settings.job.animation == False and not self.render_settings.job.file_use_temp) or self.animation == True))) and self.render_settings.job.file_force_keep == False) or self.discard_lockfile == True: #BookMark - print("Cleaning up the disk files.") + LookingGlassAddonLogger.info("Cleaning up the disk files.") # if it was an animation if self.render_settings.job.animation: @@ -1492,7 +1492,7 @@ def invoke(self, context, event): self.report({"ERROR"}, "Render job can not be continued. Lockfile not found or corrupted.") # cancel the operator - print('canceled - 2') + LookingGlassAddonLogger.info('canceled - 2') self.cancel(context) # don't execute operator @@ -1612,7 +1612,7 @@ def invoke(self, context, event): if self.discard_lockfile == True: # cancel the operator - print('canceled - 1') + LookingGlassAddonLogger.info('canceled - 1') self.cancel(context) # notify user @@ -1764,13 +1764,13 @@ def modal(self, context, event): if self.render_settings.job.animation == False: # notify user - self.report({"INFO"},"Rendering view " + str(self.render_settings.job.view + 1) + "/" + str(self.render_settings.job.total_views) + " ..") + self.report({"INFO"},"Rendering view " + str(self.render_settings.job.view + 1) + "/" + str(self.render_settings.job.view_end) + " ..") # if an animation shall be rendered elif self.render_settings.job.animation == True: # notify user - self.report({"INFO"},"Rendering view " + str(self.render_settings.job.view + 1) + "/" + str(self.render_settings.job.total_views) + " of frame " + str(self.render_settings.job.frame) + " ..") + self.report({"INFO"},"Rendering view " + str(self.render_settings.job.view + 1) + "/" + str(self.render_settings.job.view_end) + " of frame " + str(self.render_settings.job.frame) + " ..") # pass event through return {'PASS_THROUGH'} @@ -1795,7 +1795,7 @@ def modal(self, context, event): # assemble the quilt from the view data if not self.render_settings.job.assemble_quilt(): - print('failed to make quilt') + LookingGlassAddonLogger.info('failed to make quilt') # cancel the operator self.render_settings.addon_settings.render_stop = True @@ -1935,7 +1935,7 @@ def modal(self, context, event): if (self.render_settings.job._state == "INVOKE_RENDER" or self.render_settings.job._state == "COMPLETE_RENDER" or self.render_settings.job._state == "CANCEL_RENDER") and self.render_settings.addon_settings.render_stop: # cancel the operator - print('canceled - 0') + LookingGlassAddonLogger.info('canceled - 0') self.cancel(context) # notify user diff --git a/ui.py b/ui.py index cf653a5..b466af0 100644 --- a/ui.py +++ b/ui.py @@ -284,7 +284,6 @@ def update_render_setting_with_preset(self, context): # update function for property updates concerning render settings (WITHOUT quilt preset) def update_render_setting_without_preset(self, context): - # if a device is selected by the user if int(context.window_manager.addon_settings.activeDisplay) != -1: pylio.DeviceManager.set_active(int(context.window_manager.addon_settings.activeDisplay)) else: pylio.DeviceManager.reset_active() @@ -349,7 +348,6 @@ def update_render_setting_without_preset(self, context): return None - # update settings for the viewport editor blocks def update_viewport_block_settings(self, context): @@ -1027,25 +1025,29 @@ class LookingGlassAddonSettingsScene(bpy.types.PropertyGroup): default='0', name="Output", ) - - #View specification - render_view_start: bpy.props.FloatProperty( + + #BookMark + # Use custom view range or not + render_use_view_range: bpy.props.BoolProperty( + name="Use View Range", + description="Enables and disables using custom view ranges", + default = False, + ) + + # View specification + render_view_start: bpy.props.IntProperty( name = "View Start", default = 0, min = 0, - precision = 1, - step = 5, - unit = "NONE", + step = 1, description = "The starting viewing angle for the render.", ) - - render_view_end: bpy.props.FloatProperty( + + render_view_end: bpy.props.IntProperty( name = "View End", default = 66, min = 0, - precision = 1, - step = 5, - unit = "NONE", + step = 1, description = "The last viewing angle for the render.", ) @@ -1501,8 +1503,6 @@ def draw(self, context): # display the clipping settings camera = context.scene.addon_settings.lookingglassCamera if camera: - #bookmark - column.separator() row_clip_start = column.row(align = True) row_clip_start.prop(context.scene.addon_settings, "clip_start") @@ -1538,6 +1538,8 @@ class LOOKINGGLASS_PT_panel_render(bpy.types.Panel): bl_region_type = "UI" bl_category = "Looking Glass" bl_parent_id = "LOOKINGGLASS_PT_panel_general" + row_view_start = False + row_view_end = False # define own poll method to be able to hide / show the panel on demand @@ -1560,7 +1562,11 @@ def draw(self, context): row_metadata = row_general_options.row(align = True) render_add_suffix = row_metadata.prop(context.scene.addon_settings, "render_add_suffix") - #bookmark + # Use custom view range or not + row_use_view_range = row_general_options.row(align = True) + render_use_view_range = row_use_view_range.prop(context.scene.addon_settings, "render_use_view_range") + + #BookMark # Render orientation row_orientation = layout.row(align = True) @@ -1590,23 +1596,26 @@ def draw(self, context): column_2.scale_x = 0.7 # Start view - row_view_start = layout.row(align = True) - column_1 = row_view_start.row(align = True) + LOOKINGGLASS_PT_panel_render.row_view_start = layout.row(align = True) + column_1 = LOOKINGGLASS_PT_panel_render.row_view_start.row(align = True) column_1.label(text="Start View:") column_1.scale_x = 0.3 - column_2 = row_view_start.row(align = True) + column_2 = LOOKINGGLASS_PT_panel_render.row_view_start.row(align = True) column_2.prop(context.scene.addon_settings, "render_view_start", text="") column_2.scale_x = 0.7 # End view - row_view_end = layout.row(align = True) - column_1 = row_view_end.row(align = True) + LOOKINGGLASS_PT_panel_render.row_view_end = layout.row(align = True) + column_1 = LOOKINGGLASS_PT_panel_render.row_view_end.row(align = True) column_1.label(text="End View:") column_1.scale_x = 0.3 - column_2 = row_view_end.row(align = True) + column_2 = LOOKINGGLASS_PT_panel_render.row_view_end.row(align = True) column_2.prop(context.scene.addon_settings, "render_view_end", text="") column_2.scale_x = 0.7 + LOOKINGGLASS_PT_panel_render.row_view_start.enabled = context.scene.addon_settings.render_use_view_range + LOOKINGGLASS_PT_panel_render.row_view_end.enabled = context.scene.addon_settings.render_use_view_range + # if no lockfile was detected on start-up OR the render job is running if not LookingGlassAddon.has_lockfile or LookingGlassAddon.RenderInvoked: @@ -1645,8 +1654,8 @@ def draw(self, context): row_orientation.enabled = False row_preset.enabled = False row_output.enabled = False - row_view_start.enabled = False - row_view_end.enabled = False + LOOKINGGLASS_PT_panel_render.row_view_start.enabled = False + LOOKINGGLASS_PT_panel_render.row_view_end.enabled = False # inform the user and provide options to continue or to discard row_render_still = layout.row(align = True) @@ -1671,8 +1680,8 @@ def draw(self, context): row_orientation.enabled = False row_preset.enabled = False row_output.enabled = False - row_view_start.enabled = False - row_view_end.enabled = False + LOOKINGGLASS_PT_panel_render.row_view_start.enabled = False + LOOKINGGLASS_PT_panel_render.row_view_end.enabled = False if LookingGlassAddon.RenderAnimation == True: row_render_still.enabled = False if LookingGlassAddon.RenderAnimation == False: row_render_animation.enabled = False @@ -1686,8 +1695,8 @@ def draw(self, context): row_orientation.enabled = False row_preset.enabled = False row_output.enabled = False - row_view_start.enabled = False - row_view_end.enabled = False + LOOKINGGLASS_PT_panel_render.row_view_start.enabled = False + LOOKINGGLASS_PT_panel_render.row_view_end.enabled = False row_render_still.enabled = False row_render_animation.enabled = False @@ -1697,8 +1706,8 @@ def draw(self, context): # disable all elements row_orientation.enabled = False row_preset.enabled = False - row_view_start.enabled = False - row_view_end.enabled = False + LOOKINGGLASS_PT_panel_render.row_view_start.enabled = False + LOOKINGGLASS_PT_panel_render.row_view_end.enabled = False # if no Looking Glass was detected AND debug mode is not activated if not pylio.DeviceManager.count() and not LookingGlassAddon.debugging_use_dummy_device: From 3ef1c617b2554e5355e8096753feff0b3c6de3f7 Mon Sep 17 00:00:00 2001 From: Liciniuos Date: Sat, 16 Nov 2024 00:35:56 +0000 Subject: [PATCH 06/13] output is disabled by use_view_range --- ui.py | 19 +++++++++---------- 1 file changed, 9 insertions(+), 10 deletions(-) diff --git a/ui.py b/ui.py index b466af0..d51ecdd 100644 --- a/ui.py +++ b/ui.py @@ -1538,8 +1538,6 @@ class LOOKINGGLASS_PT_panel_render(bpy.types.Panel): bl_region_type = "UI" bl_category = "Looking Glass" bl_parent_id = "LOOKINGGLASS_PT_panel_general" - row_view_start = False - row_view_end = False # define own poll method to be able to hide / show the panel on demand @@ -1596,25 +1594,26 @@ def draw(self, context): column_2.scale_x = 0.7 # Start view - LOOKINGGLASS_PT_panel_render.row_view_start = layout.row(align = True) - column_1 = LOOKINGGLASS_PT_panel_render.row_view_start.row(align = True) + row_view_start = layout.row(align = True) + column_1 = row_view_start.row(align = True) column_1.label(text="Start View:") column_1.scale_x = 0.3 - column_2 = LOOKINGGLASS_PT_panel_render.row_view_start.row(align = True) + column_2 = row_view_start.row(align = True) column_2.prop(context.scene.addon_settings, "render_view_start", text="") column_2.scale_x = 0.7 # End view - LOOKINGGLASS_PT_panel_render.row_view_end = layout.row(align = True) - column_1 = LOOKINGGLASS_PT_panel_render.row_view_end.row(align = True) + row_view_end = layout.row(align = True) + column_1 = row_view_end.row(align = True) column_1.label(text="End View:") column_1.scale_x = 0.3 - column_2 = LOOKINGGLASS_PT_panel_render.row_view_end.row(align = True) + column_2 = row_view_end.row(align = True) column_2.prop(context.scene.addon_settings, "render_view_end", text="") column_2.scale_x = 0.7 - LOOKINGGLASS_PT_panel_render.row_view_start.enabled = context.scene.addon_settings.render_use_view_range - LOOKINGGLASS_PT_panel_render.row_view_end.enabled = context.scene.addon_settings.render_use_view_range + row_output.enabled = context.scene.addon_settings.render_use_view_range + row_view_start.enabled = context.scene.addon_settings.render_use_view_range + row_view_end.enabled = context.scene.addon_settings.render_use_view_range # if no lockfile was detected on start-up OR the render job is running if not LookingGlassAddon.has_lockfile or LookingGlassAddon.RenderInvoked: From 211c52f6c6178350e3c88bfd5631a898d32c6831 Mon Sep 17 00:00:00 2001 From: Liciniuos Date: Sat, 16 Nov 2024 00:44:27 +0000 Subject: [PATCH 07/13] The boolean for disabling output was the wrong way around --- ui.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ui.py b/ui.py index d51ecdd..80eb281 100644 --- a/ui.py +++ b/ui.py @@ -1611,7 +1611,7 @@ def draw(self, context): column_2.prop(context.scene.addon_settings, "render_view_end", text="") column_2.scale_x = 0.7 - row_output.enabled = context.scene.addon_settings.render_use_view_range + row_output.enabled = not context.scene.addon_settings.render_use_view_range row_view_start.enabled = context.scene.addon_settings.render_use_view_range row_view_end.enabled = context.scene.addon_settings.render_use_view_range From f2685c7491ae3b71285d43b8a2c0e4e4c70304c0 Mon Sep 17 00:00:00 2001 From: Liciniuos Date: Thu, 21 Nov 2024 13:58:59 +0000 Subject: [PATCH 08/13] Everything works except for animation --- lightfield_render.py | 42 +++++++++++++++++++++++------------------- ui.py | 35 ++++++++++++++++++----------------- 2 files changed, 41 insertions(+), 36 deletions(-) diff --git a/lightfield_render.py b/lightfield_render.py index df430b5..c59b6ef 100644 --- a/lightfield_render.py +++ b/lightfield_render.py @@ -80,6 +80,7 @@ def __init__(self, scene, animation, use_lockfile, use_multiview, blocking): self.rows = None self.columns = None self.total_views = None + self.used_views = None self.quilt_aspect = None self.view_cone = None @@ -406,13 +407,13 @@ def setup_camera(self): self._view_matrix_inv = self._view_matrix.inverted_safe() # loop through all views - for view in range(self.view_start, self.view_end): + for view in range(self.view_start, self.view_end + 1): # COPY CAMERA # +++++++++++++++++++++++++++++++++++++++++++++++ # if the cameras not already exist - if not len(self._camera_temp) == self.total_views: + if not len(self._camera_temp) == self.used_views: # create a new, temporary camera using a copy of the original camera self._camera_temp.append(bpy.data.objects.new(self._camera_temp_basename + "_v" + str(view).zfill(len(str(self.total_views - 1))), self._camera_active.data.copy())) @@ -678,10 +679,11 @@ def clean_up(self): LookingGlassAddonLogger.info(" [#] Delete temporary camera: %s" % (camera)) bpy.data.cameras.remove(camera.data, do_unlink=True, do_id_user=True, do_ui_user=True) + #BookMark # remove the corresponding temporary multiview data block - if self.scene.render.views.find(self._multiview_view_basename + str(view).zfill(len(str(self.total_views - 1)))) != -1: - LookingGlassAddonLogger.info(" [#] Delete render view: %s" % (self.scene.render.views[self._multiview_view_basename + str(view).zfill(len(str(self.total_views - 1)))])) - self.scene.render.views.remove(self.scene.render.views[self._multiview_view_basename + str(view).zfill(len(str(self.total_views - 1)))]) + if self.scene.render.views.find(self._multiview_view_basename + str(view + self.view_start).zfill(len(str(self.total_views - 1)))) != -1: + LookingGlassAddonLogger.info(" [#] Delete render view: %s" % (self.scene.render.views[self._multiview_view_basename + str(view + self.view_start).zfill(len(str(self.total_views - 1)))])) + self.scene.render.views.remove(self.scene.render.views[self._multiview_view_basename + str(view + self.view_start).zfill(len(str(self.total_views - 1)))]) # clear the list self._camera_temp.clear() @@ -692,7 +694,7 @@ def clean_up(self): # set to view format to self.scene.render.views_format = 'STEREO_3D' - # deactivate 'left' and 'right' view + # re-activate 'left' and 'right' view self.scene.render.views['left'].use = True self.scene.render.views['right'].use = True @@ -706,11 +708,11 @@ def update_progress(self): # if a single frame shall be rendered if self.animation == False: - return int(self.view / ((self.total_views - 1)) * 100) + return int(self.view / ((self.used_views - 1)) * 100) # for animations else: - return int(((self.frame - self.scene.frame_start) * (self.total_views - 1) + self.view) / ((self.total_views - 1) * (self.scene.frame_end - self.scene.frame_start + 1)) * 100) + return int(((self.frame - self.scene.frame_start) * (self.used_views) + self.view) / ((self.used_views) * (self.scene.frame_end - self.scene.frame_start + 1)) * 100) # MULTIVIEW CAMERA RENDERING # ++++++++++++++++++++++++++++++++++ @@ -718,11 +720,11 @@ def update_progress(self): # if a single frame shall be rendered if self.animation == False: - return int(self.view / ((self.total_views - 1)) * 100) + return int(self.view / ((self.used_views)) * 100) # for animations else: - return int(((self.frame - self.scene.frame_start) * (self.total_views - 1) + self.view) / ((self.total_views - 1) * (self.scene.frame_end - self.scene.frame_start + 1)) * 100) + return int(((self.frame - self.scene.frame_start) * (self.used_views) + self.view) / ((self.used_views) * (self.scene.frame_end - self.scene.frame_start + 1)) * 100) # CALLBACK FUNCTIONS / APPLICATION HANDLERS # +++++++++++++++++++++++++++++++++++++++++++++++ @@ -998,12 +1000,13 @@ def __init__(self, BlenderScene, animation, use_lockfile, use_multiview, blockin self.addon_settings.render_output = '2' if self.addon_settings.render_view_start <= self._qs[int(self._quilt_preset)]["total_views"]: self.view_start = self.addon_settings.render_view_start - if self.addon_settings.render_view_end + 1 <= self._qs[int(self._quilt_preset)]["total_views"]: - self.view_end = self.addon_settings.render_view_end + 1 - else: - # set view range to default if None was given - if self.view_start is None: self.view_start = 0 - if self.view_end is None: self.view_end = self._qs[int(self._quilt_preset)]["total_views"] + if self.addon_settings.render_view_end <= self._qs[int(self._quilt_preset)]["total_views"] and self.view_start <= self.addon_settings.render_view_end: + self.view_end = self.addon_settings.render_view_end + + # set view range to default if None was given + if self.view_start is None: self.view_start = 0 + if self.view_end is None: self.view_end = self._qs[int(self._quilt_preset)]["total_views"]-1 + self.job.used_views = self.view_end - self.view_start # PATH SETTINGS # ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ @@ -1061,6 +1064,8 @@ def __init__(self, BlenderScene, animation, use_lockfile, use_multiview, blockin self.job.columns = self._qs[int(self._quilt_preset)]["columns"] self.job.total_views = self._qs[int(self._quilt_preset)]["total_views"] + + # set view range to render self.job.view_start = self.view_start self.job.view_end = self.view_end @@ -1860,8 +1865,7 @@ def modal(self, context, event): # notify user self.cancel_sign = "INFO" - self.cancel_message = "Complete quilt rendered." - + self.cancel_message = "Complete quilt rendered." if self.render_settings.addon_settings.render_output != '2' else "Render complete" # stop the operator self.render_settings.addon_settings.render_stop = True @@ -1919,7 +1923,7 @@ def modal(self, context, event): # notify user self.cancel_sign = "INFO" - self.cancel_message = "Complete animation quilt rendered." + self.cancel_message = "Complete animation quilt rendered." if self.render_settings.addon_settings.render_output != '2' else "animation render complete" # log debug info LookingGlassAddonLogger.debug("Render job completed.") diff --git a/ui.py b/ui.py index 80eb281..8097574 100644 --- a/ui.py +++ b/ui.py @@ -1045,7 +1045,7 @@ class LookingGlassAddonSettingsScene(bpy.types.PropertyGroup): render_view_end: bpy.props.IntProperty( name = "View End", - default = 66, + default = 65, min = 0, step = 1, description = "The last viewing angle for the render.", @@ -1565,7 +1565,6 @@ def draw(self, context): render_use_view_range = row_use_view_range.prop(context.scene.addon_settings, "render_use_view_range") #BookMark - # Render orientation row_orientation = layout.row(align = True) column_1 = row_orientation.row(align = True) @@ -1627,9 +1626,10 @@ def draw(self, context): else: # Button to start rendering a single quilt using the current render settings row_render_still = layout.row(align = True) - render_quilt = row_render_still.operator("render.quilt", text="Render Quilt", icon='RENDER_STILL') + render_quilt = row_render_still.operator("render.quilt", text="Start Render" if (context.scene.addon_settings.render_use_view_range or context.scene.addon_settings.render_output == "2") else "Render Quilt", icon='RENDER_STILL') render_quilt.animation = False - render_quilt.use_multiview = (context.preferences.addons[__package__].preferences.camera_mode == '1') + print(context.scene.addon_settings.render_view_start != context.scene.addon_settings.render_view_end) + render_quilt.use_multiview = (context.preferences.addons[__package__].preferences.camera_mode == '1' and context.scene.addon_settings.render_view_start != context.scene.addon_settings.render_view_end) if LookingGlassAddon.RenderInvoked == True and LookingGlassAddon.RenderAnimation == True: # Show the corresponding progress bar for the rendering process @@ -1639,9 +1639,9 @@ def draw(self, context): else: # Button to start rendering a animation quilt using the current render settings row_render_animation = layout.row(align = True) - render_quilt = row_render_animation.operator("render.quilt", text="Render Animation Quilt", icon='RENDER_ANIMATION') + render_quilt = row_render_animation.operator("render.quilt", text="Render Animation" if (context.scene.addon_settings.render_use_view_range or context.scene.addon_settings.render_output == "2") else"Render Animation Quilts", icon='RENDER_ANIMATION') render_quilt.animation = True - render_quilt.use_multiview = (context.preferences.addons[__package__].preferences.camera_mode == '1') + render_quilt.use_multiview = (context.preferences.addons[__package__].preferences.camera_mode == '1' and context.scene.addon_settings.render_view_start != context.scene.addon_settings.render_view_end) # if a lockfile was detected on start-up @@ -1651,10 +1651,11 @@ def draw(self, context): row_metadata.enabled = False row_use_device.enabled = False row_orientation.enabled = False + row_use_view_range.enabled = False row_preset.enabled = False row_output.enabled = False - LOOKINGGLASS_PT_panel_render.row_view_start.enabled = False - LOOKINGGLASS_PT_panel_render.row_view_end.enabled = False + row_view_start.enabled = False + row_view_end.enabled = False # inform the user and provide options to continue or to discard row_render_still = layout.row(align = True) @@ -1669,18 +1670,16 @@ def draw(self, context): render_quilt.use_multiview = (context.preferences.addons[__package__].preferences.camera_mode == '1') render_quilt.discard_lockfile = True - - - # disable the render settings, if a rendering process is running if LookingGlassAddon.RenderInvoked == True: row_metadata.enabled = False row_use_device.enabled = False row_orientation.enabled = False + row_use_view_range.enabled = False row_preset.enabled = False row_output.enabled = False - LOOKINGGLASS_PT_panel_render.row_view_start.enabled = False - LOOKINGGLASS_PT_panel_render.row_view_end.enabled = False + row_view_start.enabled = False + row_view_end.enabled = False if LookingGlassAddon.RenderAnimation == True: row_render_still.enabled = False if LookingGlassAddon.RenderAnimation == False: row_render_animation.enabled = False @@ -1692,10 +1691,11 @@ def draw(self, context): row_metadata.enabled = False row_use_device.enabled = False row_orientation.enabled = False + row_use_view_range.enabled = False row_preset.enabled = False row_output.enabled = False - LOOKINGGLASS_PT_panel_render.row_view_start.enabled = False - LOOKINGGLASS_PT_panel_render.row_view_end.enabled = False + row_view_start.enabled = False + row_view_end.enabled = False row_render_still.enabled = False row_render_animation.enabled = False @@ -1705,8 +1705,9 @@ def draw(self, context): # disable all elements row_orientation.enabled = False row_preset.enabled = False - LOOKINGGLASS_PT_panel_render.row_view_start.enabled = False - LOOKINGGLASS_PT_panel_render.row_view_end.enabled = False + row_use_view_range.enabled = False + row_view_start.enabled = False + row_view_end.enabled = False # if no Looking Glass was detected AND debug mode is not activated if not pylio.DeviceManager.count() and not LookingGlassAddon.debugging_use_dummy_device: From 9e4dbf098590dabe58b49944dcbdefdc4c4dcc75 Mon Sep 17 00:00:00 2001 From: Liciniuos Date: Thu, 21 Nov 2024 15:07:13 +0000 Subject: [PATCH 09/13] Everything works --- lightfield_render.py | 39 ++++++++++++++------------------------- ui.py | 7 +++---- 2 files changed, 17 insertions(+), 29 deletions(-) diff --git a/lightfield_render.py b/lightfield_render.py index c59b6ef..203e321 100644 --- a/lightfield_render.py +++ b/lightfield_render.py @@ -184,7 +184,7 @@ def view_filepath(self, view=None, frame=None): # if an animation is rendered if self.animation: - return os.path.join(self.file_dirname, self.file_basename + "_f" + str(frame).zfill(len(str(self.scene.frame_end))) + self.get_quilt_suffix() + "_v" + str(view).zfill(len(str(self.total_views - 1))) + self.file_extension) + return os.path.join(self.file_dirname, self.file_basename + "_f" + str(frame).zfill(len(str(self.scene.frame_end))) + self.get_quilt_suffix() + "_v" + str(view).zfill(len(str(self.used_views))) + self.file_extension) # if an animation is rendered elif not self.animation: @@ -679,7 +679,6 @@ def clean_up(self): LookingGlassAddonLogger.info(" [#] Delete temporary camera: %s" % (camera)) bpy.data.cameras.remove(camera.data, do_unlink=True, do_id_user=True, do_ui_user=True) - #BookMark # remove the corresponding temporary multiview data block if self.scene.render.views.find(self._multiview_view_basename + str(view + self.view_start).zfill(len(str(self.total_views - 1)))) != -1: LookingGlassAddonLogger.info(" [#] Delete render view: %s" % (self.scene.render.views[self._multiview_view_basename + str(view + self.view_start).zfill(len(str(self.total_views - 1)))])) @@ -708,7 +707,7 @@ def update_progress(self): # if a single frame shall be rendered if self.animation == False: - return int(self.view / ((self.used_views - 1)) * 100) + return int(self.view / ((self.used_views)) * 100) # for animations else: @@ -736,8 +735,6 @@ def init_render(self, Scene, depsgraph): # log info LookingGlassAddonLogger.info("Rendering job initialized. (lockfile: %s, init: %s)" % (self._use_lockfile, self.init)) - #BookMark - # function that is called before rendering starts def pre_render(self, Scene, depsgraph): @@ -994,19 +991,20 @@ def __init__(self, BlenderScene, animation, use_lockfile, use_multiview, blockin # get all quilt presets from pylio self._qs = pylio.LookingGlassQuilt.formats.get() - #BookMark if self.addon_settings.render_use_view_range: - #The quilt will fail if all 66 veiws are not made + #The quilt will fail if all needed views are not made so select 'views only' self.addon_settings.render_output = '2' - if self.addon_settings.render_view_start <= self._qs[int(self._quilt_preset)]["total_views"]: + + # -1 as we index from 0 and total_views is the number of images + if self.addon_settings.render_view_start < self._qs[int(self._quilt_preset)]["total_views"]: self.view_start = self.addon_settings.render_view_start - if self.addon_settings.render_view_end <= self._qs[int(self._quilt_preset)]["total_views"] and self.view_start <= self.addon_settings.render_view_end: + if self.addon_settings.render_view_end < self._qs[int(self._quilt_preset)]["total_views"] and self.view_start <= self.addon_settings.render_view_end + 1: self.view_end = self.addon_settings.render_view_end # set view range to default if None was given if self.view_start is None: self.view_start = 0 - if self.view_end is None: self.view_end = self._qs[int(self._quilt_preset)]["total_views"]-1 - self.job.used_views = self.view_end - self.view_start + if self.view_end is None: self.view_end = self._qs[int(self._quilt_preset)]["total_views"] -1 + self.job.used_views = self.view_end + 1 - self.view_start # PATH SETTINGS # ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ @@ -1402,17 +1400,9 @@ def cancel(self, context): # +++++++++++++++++++++++++++++++++++++++++++ #print example # if the view files shall not be kept OR (still was rendered AND no filename was specfied) OR the file keeping is forced OR the incomplete render job was discarded - #LookingGlassAddonLogger.info(f"{self.render_settings.addon_settings.render_output} - output type") #0 - #LookingGlassAddonLogger.info(self.render_settings.job.animation)# True - #LookingGlassAddonLogger.info(self.render_settings.job.file_use_temp)# False - #LookingGlassAddonLogger.info(self.animation)# True - #LookingGlassAddonLogger.info(self.render_settings.job.file_force_keep)# False - #LookingGlassAddonLogger.info(self.discard_lockfile)# False if ((self.render_settings.addon_settings.render_output == '1' or (not ((self.render_settings.job.animation == False and not self.render_settings.job.file_use_temp) or self.animation == True))) and self.render_settings.job.file_force_keep == False) or self.discard_lockfile == True: - #BookMark - LookingGlassAddonLogger.info("Cleaning up the disk files.") # if it was an animation @@ -1791,11 +1781,10 @@ def modal(self, context, event): # QUILT ASSEMBLY # ++++++++++++++++++++++++++++++++++++++++++++ # if this was the last view OR a multiview render - if self.render_settings.job.view == (self.render_settings.job.view_end - 1) or self.use_multiview: + if self.render_settings.job.view == (self.render_settings.job.view_end) or self.use_multiview: start = time.time() - #BookMark - + # if 'views only' is selected, don't render the quilt if self.render_settings.addon_settings.render_output != '2': # assemble the quilt from the view data @@ -1852,7 +1841,7 @@ def modal(self, context, event): if self.render_settings.job.animation == False: # if this was not the last view AND the multiview mechanism is NOT used - if self.render_settings.job.view < (self.render_settings.job.view_end - 1) and not self.use_multiview: + if self.render_settings.job.view < (self.render_settings.job.view_end) and not self.use_multiview: # increase view count self.render_settings.job.view += 1 @@ -1874,7 +1863,7 @@ def modal(self, context, event): elif self.render_settings.job.animation == True: # if this was not the last view AND the multiview mechanism is NOT used - if self.render_settings.job.view < (self.render_settings.job.view_end - 1) and not self.use_multiview: + if self.render_settings.job.view < (self.render_settings.job.view_end) and not self.use_multiview: # increase view count self.render_settings.job.view += 1 @@ -1883,7 +1872,7 @@ def modal(self, context, event): self.render_settings.job._state = "INVOKE_RENDER" # if this was the last view OR the multiview mechanism is used - elif self.render_settings.job.view == (self.render_settings.job.view_end - 1) or self.use_multiview: + elif self.render_settings.job.view == (self.render_settings.job.view_end) or self.use_multiview: # but if this was not the last frame if self.render_settings.job.frame < self.render_settings.job.scene.frame_end: diff --git a/ui.py b/ui.py index 8097574..e511271 100644 --- a/ui.py +++ b/ui.py @@ -1026,7 +1026,6 @@ class LookingGlassAddonSettingsScene(bpy.types.PropertyGroup): name="Output", ) - #BookMark # Use custom view range or not render_use_view_range: bpy.props.BoolProperty( name="Use View Range", @@ -1034,7 +1033,7 @@ class LookingGlassAddonSettingsScene(bpy.types.PropertyGroup): default = False, ) - # View specification + # View range start render_view_start: bpy.props.IntProperty( name = "View Start", default = 0, @@ -1043,6 +1042,7 @@ class LookingGlassAddonSettingsScene(bpy.types.PropertyGroup): description = "The starting viewing angle for the render.", ) + # View range end render_view_end: bpy.props.IntProperty( name = "View End", default = 65, @@ -1564,7 +1564,6 @@ def draw(self, context): row_use_view_range = row_general_options.row(align = True) render_use_view_range = row_use_view_range.prop(context.scene.addon_settings, "render_use_view_range") - #BookMark # Render orientation row_orientation = layout.row(align = True) column_1 = row_orientation.row(align = True) @@ -1610,6 +1609,7 @@ def draw(self, context): column_2.prop(context.scene.addon_settings, "render_view_end", text="") column_2.scale_x = 0.7 + # activate/deactivate menus based on 'use view range' row_output.enabled = not context.scene.addon_settings.render_use_view_range row_view_start.enabled = context.scene.addon_settings.render_use_view_range row_view_end.enabled = context.scene.addon_settings.render_use_view_range @@ -1628,7 +1628,6 @@ def draw(self, context): row_render_still = layout.row(align = True) render_quilt = row_render_still.operator("render.quilt", text="Start Render" if (context.scene.addon_settings.render_use_view_range or context.scene.addon_settings.render_output == "2") else "Render Quilt", icon='RENDER_STILL') render_quilt.animation = False - print(context.scene.addon_settings.render_view_start != context.scene.addon_settings.render_view_end) render_quilt.use_multiview = (context.preferences.addons[__package__].preferences.camera_mode == '1' and context.scene.addon_settings.render_view_start != context.scene.addon_settings.render_view_end) if LookingGlassAddon.RenderInvoked == True and LookingGlassAddon.RenderAnimation == True: From 4d13dd78d2aa6ee51253b4abb211defced90527f Mon Sep 17 00:00:00 2001 From: Liciniuos Date: Thu, 21 Nov 2024 15:34:40 +0000 Subject: [PATCH 10/13] yup --- lightfield_render.py | 3 ++- ui.py | 10 +++++----- 2 files changed, 7 insertions(+), 6 deletions(-) diff --git a/lightfield_render.py b/lightfield_render.py index 203e321..68d262c 100644 --- a/lightfield_render.py +++ b/lightfield_render.py @@ -998,7 +998,8 @@ def __init__(self, BlenderScene, animation, use_lockfile, use_multiview, blockin # -1 as we index from 0 and total_views is the number of images if self.addon_settings.render_view_start < self._qs[int(self._quilt_preset)]["total_views"]: self.view_start = self.addon_settings.render_view_start - if self.addon_settings.render_view_end < self._qs[int(self._quilt_preset)]["total_views"] and self.view_start <= self.addon_settings.render_view_end + 1: + + if self.addon_settings.render_view_end < self._qs[int(self._quilt_preset)]["total_views"] and self.view_start <= self.addon_settings.render_view_end: self.view_end = self.addon_settings.render_view_end # set view range to default if None was given diff --git a/ui.py b/ui.py index e511271..c1c8fdb 100644 --- a/ui.py +++ b/ui.py @@ -455,9 +455,7 @@ def update_camera_synchronization(self, context): if not LookingGlassAddonUI.synchronize_active_camera in bpy.app.handlers.depsgraph_update_post: bpy.app.handlers.depsgraph_update_post.append(LookingGlassAddonUI.synchronize_active_camera) if not LookingGlassAddonUI.synchronize_active_camera in bpy.app.handlers.frame_change_post: bpy.app.handlers.frame_change_post.append(LookingGlassAddonUI.synchronize_active_camera) - elif not context.scene.addon_settings.toggleCameraSync: - if LookingGlassAddonUI.synchronize_active_camera in bpy.app.handlers.depsgraph_update_post: bpy.app.handlers.depsgraph_update_post.remove(LookingGlassAddonUI.synchronize_active_camera) if LookingGlassAddonUI.synchronize_active_camera in bpy.app.handlers.frame_change_post: bpy.app.handlers.frame_change_post.remove(LookingGlassAddonUI.synchronize_active_camera) @@ -487,7 +485,7 @@ def update_camera_selection(self, context): if not (bpy.context.scene.addon_settings.clip_start < bpy.context.scene.addon_settings.focalPlane < bpy.context.scene.addon_settings.clip_end): bpy.context.scene.addon_settings.focalPlane = 5 - + # set flag context.scene.addon_settings.lookingglassCamera.data.is_lightfield = True @@ -582,7 +580,7 @@ def focal_plane_getter(self): if camera: if self.get('focalPlane', 5) != camera.data.dof.focus_distance: bpy.context.scene.addon_settings.focalPlane = camera.data.dof.focus_distance - + return self.get('focalPlane', 5) # setter for the focalPlane @@ -1600,6 +1598,8 @@ def draw(self, context): column_2.prop(context.scene.addon_settings, "render_view_start", text="") column_2.scale_x = 0.7 + + # End view row_view_end = layout.row(align = True) column_1 = row_view_end.row(align = True) @@ -1609,7 +1609,7 @@ def draw(self, context): column_2.prop(context.scene.addon_settings, "render_view_end", text="") column_2.scale_x = 0.7 - # activate/deactivate menus based on 'use view range' + # activate/deactivate menus based on 'use view range' row_output.enabled = not context.scene.addon_settings.render_use_view_range row_view_start.enabled = context.scene.addon_settings.render_use_view_range row_view_end.enabled = context.scene.addon_settings.render_use_view_range From 70f4b9185a1724992e2280f88bea263334aedc49 Mon Sep 17 00:00:00 2001 From: Liciniuos Date: Sat, 23 Nov 2024 10:47:55 +0000 Subject: [PATCH 11/13] Hides uneeded UI instead of just disableing it --- ui.py | 58 ++++++++++++++++++++++++++++------------------------------ 1 file changed, 28 insertions(+), 30 deletions(-) diff --git a/ui.py b/ui.py index c1c8fdb..cdb20b2 100644 --- a/ui.py +++ b/ui.py @@ -1581,38 +1581,36 @@ def draw(self, context): column_2.scale_x = 0.7 # Output file handling - row_output = layout.row(align = True) - column_1 = row_output.row(align = True) - column_1.label(text="Output:") - column_1.scale_x = 0.3 - column_2 = row_output.row(align = True) - column_2.prop(context.scene.addon_settings, "render_output", text="") - column_2.scale_x = 0.7 + # If the user wants to specify the view range, the program cannot create a quilt with incomplete data + # so 'veiws only' will be selected by the program + if not context.scene.addon_settings.render_use_view_range: + row_output = layout.row(align = True) + column_1 = row_output.row(align = True) + column_1.label(text="Output:") + column_1.scale_x = 0.3 + column_2 = row_output.row(align = True) + column_2.prop(context.scene.addon_settings, "render_output", text="") + column_2.scale_x = 0.7 # Start view - row_view_start = layout.row(align = True) - column_1 = row_view_start.row(align = True) - column_1.label(text="Start View:") - column_1.scale_x = 0.3 - column_2 = row_view_start.row(align = True) - column_2.prop(context.scene.addon_settings, "render_view_start", text="") - column_2.scale_x = 0.7 - - - - # End view - row_view_end = layout.row(align = True) - column_1 = row_view_end.row(align = True) - column_1.label(text="End View:") - column_1.scale_x = 0.3 - column_2 = row_view_end.row(align = True) - column_2.prop(context.scene.addon_settings, "render_view_end", text="") - column_2.scale_x = 0.7 - - # activate/deactivate menus based on 'use view range' - row_output.enabled = not context.scene.addon_settings.render_use_view_range - row_view_start.enabled = context.scene.addon_settings.render_use_view_range - row_view_end.enabled = context.scene.addon_settings.render_use_view_range + # If the user has selected to use a view range + if context.scene.addon_settings.render_use_view_range: + row_view_start = layout.row(align = True) + column_1 = row_view_start.row(align = True) + column_1.label(text="Start View:") + column_1.scale_x = 0.3 + column_2 = row_view_start.row(align = True) + column_2.prop(context.scene.addon_settings, "render_view_start", text="") + column_2.scale_x = 0.7 + + # End view + row_view_end = layout.row(align = True) + column_1 = row_view_end.row(align = True) + column_1.label(text="End View:") + column_1.scale_x = 0.3 + column_2 = row_view_end.row(align = True) + column_2.prop(context.scene.addon_settings, "render_view_end", text="") + column_2.scale_x = 0.7 # if no lockfile was detected on start-up OR the render job is running if not LookingGlassAddon.has_lockfile or LookingGlassAddon.RenderInvoked: From 34f425e6e06cf2631d2c6c1fb9d64c4a45b58bb2 Mon Sep 17 00:00:00 2001 From: Liciniuos Date: Sun, 24 Nov 2024 08:21:08 +0000 Subject: [PATCH 12/13] Removed debugging logs and added comments --- __init__.py | 6 +++--- lightfield_render.py | 24 +++++++++++++----------- ui.py | 34 +++++++++++++++++++++++----------- 3 files changed, 39 insertions(+), 25 deletions(-) diff --git a/__init__.py b/__init__.py index 099490b..d742f95 100644 --- a/__init__.py +++ b/__init__.py @@ -19,12 +19,12 @@ # -------------------- DEFINE ADDON ---------------------- bl_info = { - "name": "Amber/LG/", + "name": "Alice/LG", "author": "Christian Stolze", "version": (2, 3, 0), "blender": (2, 93, 6), "location": "View3D > Looking Glass Tab", - "description": "Amber/LG is Alice/LG which takes your artworks through the Looking Glass (light field displays) but it doesn't delete files", + "description": "Alice/LG takes your artworks through the Looking Glass (light field displays)", "category": "View", "warning": "", "doc_url": "https://github.com/regcs/AliceLG/blob/master/README.md", @@ -76,7 +76,7 @@ def log_exhook(exc_type, exc_value, exc_traceback): # log that an unhandled exception occured in Alice/LG's log file LookingGlassAddonLogger.critical("An unhandled error occured. Here is the traceback:\n", exc_info=(exc_type, exc_value, exc_traceback)) - + # then continue with the system behavior sys.__excepthook__(exc_type, exc_value, exc_traceback) diff --git a/lightfield_render.py b/lightfield_render.py index 68d262c..c2c8954 100644 --- a/lightfield_render.py +++ b/lightfield_render.py @@ -992,17 +992,24 @@ def __init__(self, BlenderScene, animation, use_lockfile, use_multiview, blockin self._qs = pylio.LookingGlassQuilt.formats.get() if self.addon_settings.render_use_view_range: - #The quilt will fail if all needed views are not made so select 'views only' + # The quilt will fail if all needed views are not made so select 'views only' self.addon_settings.render_output = '2' - # -1 as we index from 0 and total_views is the number of images + # check start and end are within range if self.addon_settings.render_view_start < self._qs[int(self._quilt_preset)]["total_views"]: self.view_start = self.addon_settings.render_view_start + else: + LookingGlassAddonLogger.warning(f"View start is greater than total number of views supported by selected device ({self._qs[int(self._quilt_preset)]["total_views"]-1})") if self.addon_settings.render_view_end < self._qs[int(self._quilt_preset)]["total_views"] and self.view_start <= self.addon_settings.render_view_end: self.view_end = self.addon_settings.render_view_end + else: + if self.view_start <= self.addon_settings.render_view_end: + LookingGlassAddonLogger.warning(f"View end is greater than total number of views supported by selected device ({self._qs[int(self._quilt_preset)]["total_views"]-1})") + else: + LookingGlassAddonLogger.warning(f"View end is greater than view start") - # set view range to default if None was given + # set view range to default if None was given or was invalid if self.view_start is None: self.view_start = 0 if self.view_end is None: self.view_end = self._qs[int(self._quilt_preset)]["total_views"] -1 self.job.used_views = self.view_end + 1 - self.view_start @@ -1017,7 +1024,6 @@ def __init__(self, BlenderScene, animation, use_lockfile, use_multiview, blockin self.job.lockfile_path = bpy.path.abspath(LookingGlassAddon.tmp_path + os.path.basename(bpy.data.filepath) + ".lock") - # ORIGINAL SETTINGS # ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ @@ -1026,7 +1032,6 @@ def __init__(self, BlenderScene, animation, use_lockfile, use_multiview, blockin self.original = self.copy() - # RENDER JOB SETTINGS # ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ # if the lockfile shall be used @@ -1389,6 +1394,7 @@ def cancel(self, context): + # CLEAR IMAGE & PIXEL DATA # +++++++++++++++++++++++++ self.render_settings.job._view_image = None @@ -1397,11 +1403,10 @@ def cancel(self, context): + # CLEAN-UP FILES # +++++++++++++++++++++++++++++++++++++++++++ - #print example # if the view files shall not be kept OR (still was rendered AND no filename was specfied) OR the file keeping is forced OR the incomplete render job was discarded - if ((self.render_settings.addon_settings.render_output == '1' or (not ((self.render_settings.job.animation == False and not self.render_settings.job.file_use_temp) or self.animation == True))) and self.render_settings.job.file_force_keep == False) or self.discard_lockfile == True: LookingGlassAddonLogger.info("Cleaning up the disk files.") @@ -1423,6 +1428,7 @@ def cancel(self, context): + # RESTORE USER SETTINGS # +++++++++++++++++++++++++ # if this call was not just invoked to discard an incomplete render job @@ -1488,7 +1494,6 @@ def invoke(self, context, event): self.report({"ERROR"}, "Render job can not be continued. Lockfile not found or corrupted.") # cancel the operator - LookingGlassAddonLogger.info('canceled - 2') self.cancel(context) # don't execute operator @@ -1608,7 +1613,6 @@ def invoke(self, context, event): if self.discard_lockfile == True: # cancel the operator - LookingGlassAddonLogger.info('canceled - 1') self.cancel(context) # notify user @@ -1790,7 +1794,6 @@ def modal(self, context, event): # assemble the quilt from the view data if not self.render_settings.job.assemble_quilt(): - LookingGlassAddonLogger.info('failed to make quilt') # cancel the operator self.render_settings.addon_settings.render_stop = True @@ -1929,7 +1932,6 @@ def modal(self, context, event): if (self.render_settings.job._state == "INVOKE_RENDER" or self.render_settings.job._state == "COMPLETE_RENDER" or self.render_settings.job._state == "CANCEL_RENDER") and self.render_settings.addon_settings.render_stop: # cancel the operator - LookingGlassAddonLogger.info('canceled - 0') self.cancel(context) # notify user diff --git a/ui.py b/ui.py index cdb20b2..e3bc103 100644 --- a/ui.py +++ b/ui.py @@ -1650,9 +1650,12 @@ def draw(self, context): row_orientation.enabled = False row_use_view_range.enabled = False row_preset.enabled = False - row_output.enabled = False - row_view_start.enabled = False - row_view_end.enabled = False + # can't disable if not drawn + if not context.scene.addon_settings.render_use_view_range: + row_output.enabled = False + else: + row_view_start.enabled = False + row_view_end.enabled = False # inform the user and provide options to continue or to discard row_render_still = layout.row(align = True) @@ -1674,9 +1677,12 @@ def draw(self, context): row_orientation.enabled = False row_use_view_range.enabled = False row_preset.enabled = False - row_output.enabled = False - row_view_start.enabled = False - row_view_end.enabled = False + # can't disable if not drawn + if not context.scene.addon_settings.render_use_view_range: + row_output.enabled = False + else: + row_view_start.enabled = False + row_view_end.enabled = False if LookingGlassAddon.RenderAnimation == True: row_render_still.enabled = False if LookingGlassAddon.RenderAnimation == False: row_render_animation.enabled = False @@ -1690,9 +1696,12 @@ def draw(self, context): row_orientation.enabled = False row_use_view_range.enabled = False row_preset.enabled = False - row_output.enabled = False - row_view_start.enabled = False - row_view_end.enabled = False + # can't disable if not drawn + if not context.scene.addon_settings.render_use_view_range: + row_output.enabled = False + else: + row_view_start.enabled = False + row_view_end.enabled = False row_render_still.enabled = False row_render_animation.enabled = False @@ -1703,8 +1712,11 @@ def draw(self, context): row_orientation.enabled = False row_preset.enabled = False row_use_view_range.enabled = False - row_view_start.enabled = False - row_view_end.enabled = False + # can't disable if not drawn + if context.scene.addon_settings.render_use_view_range: + row_view_start.enabled = False + row_view_end.enabled = False + # if no Looking Glass was detected AND debug mode is not activated if not pylio.DeviceManager.count() and not LookingGlassAddon.debugging_use_dummy_device: From 0ff777828575cfaeee4404f4bbd0707ac58fa01a Mon Sep 17 00:00:00 2001 From: Amber Date: Fri, 29 Nov 2024 14:51:26 +0000 Subject: [PATCH 13/13] update f-strings to use single quotes --- lightfield_render.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/lightfield_render.py b/lightfield_render.py index c2c8954..0eb63ab 100644 --- a/lightfield_render.py +++ b/lightfield_render.py @@ -999,13 +999,13 @@ def __init__(self, BlenderScene, animation, use_lockfile, use_multiview, blockin if self.addon_settings.render_view_start < self._qs[int(self._quilt_preset)]["total_views"]: self.view_start = self.addon_settings.render_view_start else: - LookingGlassAddonLogger.warning(f"View start is greater than total number of views supported by selected device ({self._qs[int(self._quilt_preset)]["total_views"]-1})") + LookingGlassAddonLogger.warning(f"View start is greater than total number of views supported by selected device ({self._qs[int(self._quilt_preset)]['total_views']-1})") if self.addon_settings.render_view_end < self._qs[int(self._quilt_preset)]["total_views"] and self.view_start <= self.addon_settings.render_view_end: self.view_end = self.addon_settings.render_view_end else: if self.view_start <= self.addon_settings.render_view_end: - LookingGlassAddonLogger.warning(f"View end is greater than total number of views supported by selected device ({self._qs[int(self._quilt_preset)]["total_views"]-1})") + LookingGlassAddonLogger.warning(f"View end is greater than total number of views supported by selected device ({self._qs[int(self._quilt_preset)]['total_views']-1})") else: LookingGlassAddonLogger.warning(f"View end is greater than view start")