Merge branch 'master' into blender2.8
[blender.git] / release / scripts / startup / bl_ui / properties_render.py
index 06e3afcf5be89989d792d64b1e26f5c3cce7a953..ce58dcd74992afef649d0f3c0f1bd012a8c5b9bb 100644 (file)
 
 # <pep8 compliant>
 import bpy
-from bpy.types import Menu, Panel
+from bpy.types import Menu, Panel, UIList
+from bl_operators.presets import PresetMenu
+from .space_view3d import (
+    VIEW3D_PT_shading_lighting,
+    VIEW3D_PT_shading_color,
+    VIEW3D_PT_shading_options,
+)
 
 
-class RENDER_MT_presets(Menu):
+class RENDER_PT_presets(PresetMenu):
     bl_label = "Render Presets"
     preset_subdir = "render"
     preset_operator = "script.execute_preset"
-    draw = Menu.draw_preset
+    preset_add_operator = "render.preset_add"
 
 
-class RENDER_MT_ffmpeg_presets(Menu):
+class RENDER_PT_ffmpeg_presets(PresetMenu):
     bl_label = "FFMPEG Presets"
     preset_subdir = "ffmpeg"
     preset_operator = "script.python_file_run"
-    draw = Menu.draw_preset
 
 
 class RENDER_MT_framerate_presets(Menu):
@@ -51,39 +56,42 @@ class RenderButtonsPanel:
 
     @classmethod
     def poll(cls, context):
-        scene = context.scene
-        return scene and (scene.render.engine in cls.COMPAT_ENGINES)
+        return (context.engine in cls.COMPAT_ENGINES)
 
 
-class RENDER_PT_render(RenderButtonsPanel, Panel):
-    bl_label = "Render"
-    COMPAT_ENGINES = {'BLENDER_RENDER'}
+class RENDER_PT_context(Panel):
+    bl_space_type = 'PROPERTIES'
+    bl_region_type = 'WINDOW'
+    bl_context = "render"
+    bl_options = {'HIDE_HEADER'}
+    bl_label = ""
+
+    @classmethod
+    def poll(cls, context):
+        return context.scene
 
     def draw(self, context):
         layout = self.layout
+        layout.use_property_split = True
+        layout.use_property_decorate = False
 
-        rd = context.scene.render
-
-        row = layout.row(align=True)
-        row.operator("render.render", text="Render", icon='RENDER_STILL')
-        row.operator("render.render", text="Animation", icon='RENDER_ANIMATION').animation = True
-        row.operator("sound.mixdown", text="Audio", icon='PLAY_AUDIO')
-
-        split = layout.split(percentage=0.33)
+        scene = context.scene
+        rd = scene.render
 
-        split.label(text="Display:")
-        row = split.row(align=True)
-        row.prop(rd, "display_mode", text="")
-        row.prop(rd, "use_lock_interface", icon_only=True)
+        if rd.has_multiple_engines:
+            layout.prop(rd, "engine", text="Render Engine")
 
 
 class RENDER_PT_dimensions(RenderButtonsPanel, Panel):
     bl_label = "Dimensions"
-    COMPAT_ENGINES = {'BLENDER_RENDER'}
+    COMPAT_ENGINES = {'BLENDER_RENDER', 'BLENDER_EEVEE', 'BLENDER_OPENGL'}
 
     _frame_rate_args_prev = None
     _preset_class = None
 
+    def draw_header_preset(self, context):
+        RENDER_PT_presets.draw_panel_header(self.layout)
+
     @staticmethod
     def _draw_framerate_label(*args):
         # avoids re-creating text string each draw
@@ -112,7 +120,7 @@ class RENDER_PT_dimensions(RenderButtonsPanel, Panel):
         return args
 
     @staticmethod
-    def draw_framerate(sub, rd):
+    def draw_framerate(layout, sub, rd):
         if RENDER_PT_dimensions._preset_class is None:
             RENDER_PT_dimensions._preset_class = bpy.types.RENDER_MT_framerate_presets
 
@@ -122,299 +130,220 @@ class RENDER_PT_dimensions(RenderButtonsPanel, Panel):
         sub.menu("RENDER_MT_framerate_presets", text=fps_label_text)
 
         if show_framerate:
-            sub.prop(rd, "fps")
-            sub.prop(rd, "fps_base", text="/")
+            col = layout.column(align=True)
+            col.prop(rd, "fps")
+            col.prop(rd, "fps_base", text="Base")
 
     def draw(self, context):
         layout = self.layout
+        layout.use_property_split = True
+        layout.use_property_decorate = False  # No animation.
 
         scene = context.scene
         rd = scene.render
 
-        row = layout.row(align=True)
-        row.menu("RENDER_MT_presets", text=bpy.types.RENDER_MT_presets.bl_label)
-        row.operator("render.preset_add", text="", icon='ZOOMIN')
-        row.operator("render.preset_add", text="", icon='ZOOMOUT').remove_active = True
+        col = layout.column(align=True)
+        col.prop(rd, "resolution_x", text="Resolution X")
+        col.prop(rd, "resolution_y", text="Y")
+        col.prop(rd, "resolution_percentage", text="%")
 
-        split = layout.split()
+        col = layout.column(align=True)
+        col.prop(rd, "pixel_aspect_x", text="Aspect X")
+        col.prop(rd, "pixel_aspect_y", text="Y")
 
-        col = split.column()
+        col = layout.column(align=True)
+        col.prop(rd, "use_border", text="Border")
         sub = col.column(align=True)
-        sub.label(text="Resolution:")
-        sub.prop(rd, "resolution_x", text="X")
-        sub.prop(rd, "resolution_y", text="Y")
-        sub.prop(rd, "resolution_percentage", text="")
-
-        sub.label(text="Aspect Ratio:")
-        sub.prop(rd, "pixel_aspect_x", text="X")
-        sub.prop(rd, "pixel_aspect_y", text="Y")
-
-        row = col.row()
-        row.prop(rd, "use_border", text="Border")
-        sub = row.row()
         sub.active = rd.use_border
         sub.prop(rd, "use_crop_to_border", text="Crop")
 
-        col = split.column()
-        sub = col.column(align=True)
-        sub.label(text="Frame Range:")
-        sub.prop(scene, "frame_start")
-        sub.prop(scene, "frame_end")
-        sub.prop(scene, "frame_step")
-
-        sub.label(text="Frame Rate:")
-
-        self.draw_framerate(sub, rd)
-
-        subrow = sub.row(align=True)
-        subrow.label(text="Time Remapping:")
-        subrow = sub.row(align=True)
-        subrow.prop(rd, "frame_map_old", text="Old")
-        subrow.prop(rd, "frame_map_new", text="New")
-
-
-class RENDER_PT_antialiasing(RenderButtonsPanel, Panel):
-    bl_label = "Anti-Aliasing"
-    COMPAT_ENGINES = {'BLENDER_RENDER'}
+        col = layout.column(align=True)
+        col.prop(scene, "frame_start", text="Frame Start")
+        col.prop(scene, "frame_end", text="End")
+        col.prop(scene, "frame_step", text="Step")
 
-    def draw_header(self, context):
-        rd = context.scene.render
+        col = layout.split()
+        col.alignment = 'RIGHT'
+        col.label(text="Frame Rate")
+        self.draw_framerate(layout, col, rd)
 
-        self.layout.prop(rd, "use_antialiasing", text="")
-
-    def draw(self, context):
-        layout = self.layout
-
-        rd = context.scene.render
-        layout.active = rd.use_antialiasing
 
-        split = layout.split()
-
-        col = split.column()
-        col.row().prop(rd, "antialiasing_samples", expand=True)
-        sub = col.row()
-        sub.prop(rd, "use_full_sample")
-
-        col = split.column()
-        col.prop(rd, "pixel_filter_type", text="")
-        col.prop(rd, "filter_size", text="Size")
-
-
-class RENDER_PT_motion_blur(RenderButtonsPanel, Panel):
-    bl_label = "Sampled Motion Blur"
+class RENDER_PT_frame_remapping(RenderButtonsPanel, Panel):
+    bl_label = "Time Remapping"
+    bl_parent_id = "RENDER_PT_dimensions"
     bl_options = {'DEFAULT_CLOSED'}
-    COMPAT_ENGINES = {'BLENDER_RENDER'}
-
-    @classmethod
-    def poll(cls, context):
-        rd = context.scene.render
-        return not rd.use_full_sample and (rd.engine in cls.COMPAT_ENGINES)
-
-    def draw_header(self, context):
-        rd = context.scene.render
-
-        self.layout.prop(rd, "use_motion_blur", text="")
+    COMPAT_ENGINES = {'BLENDER_RENDER', 'BLENDER_EEVEE', 'BLENDER_OPENGL'}
 
     def draw(self, context):
         layout = self.layout
+        layout.use_property_split = True
+        layout.use_property_decorate = False  # No animation.
 
         rd = context.scene.render
-        layout.active = rd.use_motion_blur
 
-        row = layout.row()
-        row.prop(rd, "motion_blur_samples")
-        row.prop(rd, "motion_blur_shutter")
+        col = layout.column(align=True)
+        col.prop(rd, "frame_map_old", text="Old")
+        col.prop(rd, "frame_map_new", text="New")
 
 
-class RENDER_PT_shading(RenderButtonsPanel, Panel):
-    bl_label = "Shading"
+class RENDER_PT_post_processing(RenderButtonsPanel, Panel):
+    bl_label = "Post Processing"
     bl_options = {'DEFAULT_CLOSED'}
-    COMPAT_ENGINES = {'BLENDER_RENDER'}
+    COMPAT_ENGINES = {'BLENDER_RENDER', 'BLENDER_EEVEE', 'BLENDER_OPENGL'}
 
     def draw(self, context):
         layout = self.layout
+        layout.use_property_split = True
 
         rd = context.scene.render
 
-        split = layout.split()
-
-        col = split.column()
-        col.prop(rd, "use_textures", text="Textures")
-        col.prop(rd, "use_shadows", text="Shadows")
-        col.prop(rd, "use_sss", text="Subsurface Scattering")
-        col.prop(rd, "use_envmaps", text="Environment Map")
+        col = layout.column(align=True)
+        col.prop(rd, "use_compositing")
+        col.prop(rd, "use_sequencer")
 
-        col = split.column()
-        col.prop(rd, "use_raytrace", text="Ray Tracing")
-        col.prop(rd, "alpha_mode", text="Alpha")
-        col.prop(rd, "use_world_space_shading", text="World Space Shading")
+        col.prop(rd, "dither_intensity", text="Dither", slider=True)
 
 
-class RENDER_PT_performance(RenderButtonsPanel, Panel):
-    bl_label = "Performance"
+class RENDER_PT_stamp(RenderButtonsPanel, Panel):
+    bl_label = "Metadata"
     bl_options = {'DEFAULT_CLOSED'}
-    COMPAT_ENGINES = {'BLENDER_RENDER'}
+    COMPAT_ENGINES = {'BLENDER_RENDER', 'BLENDER_EEVEE', 'BLENDER_OPENGL'}
 
     def draw(self, context):
         layout = self.layout
+        layout.use_property_split = True
+        layout.use_property_decorate = False  # No animation.
 
         rd = context.scene.render
 
-        split = layout.split()
-
-        col = split.column(align=True)
-        col.label(text="Threads:")
-        col.row(align=True).prop(rd, "threads_mode", expand=True)
-        sub = col.column(align=True)
-        sub.enabled = rd.threads_mode == 'FIXED'
-        sub.prop(rd, "threads")
-
-        col.label(text="Tile Size:")
-        col.prop(rd, "tile_x", text="X")
-        col.prop(rd, "tile_y", text="Y")
-
-        col.separator()
-        col.prop(rd, "preview_start_resolution")
-        col.prop(rd, "preview_pixel_size", text="")
-
-        col = split.column()
-        col.label(text="Memory:")
-        sub = col.column()
-        sub.enabled = not rd.use_full_sample
-        sub.prop(rd, "use_save_buffers")
-        sub = col.column()
-        sub.active = rd.use_compositing
-        sub.prop(rd, "use_free_image_textures")
-        sub = col.column()
-        sub.active = rd.use_raytrace
-        sub.label(text="Acceleration Structure:")
-        sub.prop(rd, "raytrace_method", text="")
-        if rd.raytrace_method == 'OCTREE':
-            sub.prop(rd, "octree_resolution", text="Resolution")
-        else:
-            sub.prop(rd, "use_instances", text="Instances")
-        sub.prop(rd, "use_local_coords", text="Local Coordinates")
+        flow = layout.grid_flow(row_major=True, columns=0, even_columns=True, even_rows=False, align=False)
 
+        col = flow.column()
+        col.prop(rd, "use_stamp_date", text="Date")
+        col = flow.column()
+        col.prop(rd, "use_stamp_time", text="Time")
 
-class RENDER_PT_post_processing(RenderButtonsPanel, Panel):
-    bl_label = "Post Processing"
-    bl_options = {'DEFAULT_CLOSED'}
-    COMPAT_ENGINES = {'BLENDER_RENDER'}
-
-    def draw(self, context):
-        layout = self.layout
+        col = flow.column()
+        col.prop(rd, "use_stamp_render_time", text="Render Time")
+        col = flow.column()
+        col.prop(rd, "use_stamp_frame", text="Frame")
+        col = flow.column()
+        col.prop(rd, "use_stamp_frame_range", text="Frame Range")
+        col = flow.column()
+        col.prop(rd, "use_stamp_memory", text="Memory")
 
-        rd = context.scene.render
+        col = flow.column()
+        col.prop(rd, "use_stamp_camera", text="Camera")
+        col = flow.column()
+        col.prop(rd, "use_stamp_lens", text="Lens")
 
-        split = layout.split()
+        col = flow.column()
+        col.prop(rd, "use_stamp_scene", text="Scene")
+        col = flow.column()
+        col.prop(rd, "use_stamp_marker", text="Marker")
 
-        col = split.column()
-        col.prop(rd, "use_compositing")
-        col.prop(rd, "use_sequencer")
+        col = flow.column()
+        col.prop(rd, "use_stamp_filename", text="Filename")
 
-        split.prop(rd, "dither_intensity", text="Dither", slider=True)
+        col = flow.column()
+        col.prop(rd, "use_stamp_sequencer_strip", text="Strip Name")
 
-        layout.separator()
+        if rd.use_sequencer:
+            col = flow.column()
+            col.prop(rd, "use_stamp_strip_meta", text="Use Strip Metadata")
 
-        split = layout.split()
+        row = layout.split(factor=0.3)
+        row.prop(rd, "use_stamp_note", text="Note")
+        sub = row.row()
+        sub.active = rd.use_stamp_note
+        sub.prop(rd, "stamp_note_text", text="")
 
-        col = split.column()
-        col.prop(rd, "use_fields", text="Fields")
-        sub = col.column()
-        sub.active = rd.use_fields
-        sub.row().prop(rd, "field_order", expand=True)
-        sub.prop(rd, "use_fields_still", text="Still")
 
-        col = split.column()
-        col.prop(rd, "use_edge_enhance")
-        sub = col.column()
-        sub.active = rd.use_edge_enhance
-        sub.prop(rd, "edge_threshold", text="Threshold", slider=True)
-        sub.prop(rd, "edge_color", text="")
+class RENDER_PT_stamp_burn(RenderButtonsPanel, Panel):
+    bl_label = "Burn Into Image"
+    bl_parent_id = "RENDER_PT_stamp"
+    bl_options = {'DEFAULT_CLOSED'}
+    COMPAT_ENGINES = {'BLENDER_RENDER', 'BLENDER_EEVEE', 'BLENDER_OPENGL'}
 
+    def draw_header(self, context):
+        rd = context.scene.render
 
-class RENDER_PT_stamp(RenderButtonsPanel, Panel):
-    bl_label = "Metadata"
-    bl_options = {'DEFAULT_CLOSED'}
-    COMPAT_ENGINES = {'BLENDER_RENDER'}
+        self.layout.prop(rd, "use_stamp", text="")
 
     def draw(self, context):
         layout = self.layout
 
         rd = context.scene.render
 
-        layout.prop(rd, "use_stamp")
+        layout.use_property_split = True
+
         col = layout.column()
         col.active = rd.use_stamp
-        row = col.row()
-        row.prop(rd, "stamp_font_size", text="Font Size")
-        row.prop(rd, "use_stamp_labels", text="Draw Labels")
-
-        row = col.row()
-        row.column().prop(rd, "stamp_foreground", slider=True)
-        row.column().prop(rd, "stamp_background", slider=True)
-
-        layout.label("Enabled Metadata")
-        split = layout.split()
-
-        col = split.column()
-        col.prop(rd, "use_stamp_time", text="Time")
-        col.prop(rd, "use_stamp_date", text="Date")
-        col.prop(rd, "use_stamp_render_time", text="RenderTime")
-        col.prop(rd, "use_stamp_frame", text="Frame")
-        col.prop(rd, "use_stamp_scene", text="Scene")
-        col.prop(rd, "use_stamp_memory", text="Memory")
-
-        col = split.column()
-        col.prop(rd, "use_stamp_camera", text="Camera")
-        col.prop(rd, "use_stamp_lens", text="Lens")
-        col.prop(rd, "use_stamp_filename", text="Filename")
-        col.prop(rd, "use_stamp_frame_range", text="Frame range")
-        col.prop(rd, "use_stamp_marker", text="Marker")
-        col.prop(rd, "use_stamp_sequencer_strip", text="Seq. Strip")
-
-        row = layout.split(percentage=0.2)
-        row.prop(rd, "use_stamp_note", text="Note")
-        sub = row.row()
-        sub.active = rd.use_stamp_note
-        sub.prop(rd, "stamp_note_text", text="")
-        if rd.use_sequencer:
-            layout.label("Sequencer:")
-            layout.prop(rd, "use_stamp_strip_meta")
+        col.prop(rd, "stamp_font_size", text="Font Size")
+        col.prop(rd, "use_stamp_labels", text="Draw Labels")
+        col.column().prop(rd, "stamp_foreground", slider=True)
+        col.column().prop(rd, "stamp_background", slider=True)
 
 
 class RENDER_PT_output(RenderButtonsPanel, Panel):
     bl_label = "Output"
-    COMPAT_ENGINES = {'BLENDER_RENDER'}
+    COMPAT_ENGINES = {'BLENDER_RENDER', 'BLENDER_EEVEE', 'BLENDER_OPENGL'}
 
     def draw(self, context):
         layout = self.layout
+        layout.use_property_split = False
+        layout.use_property_decorate = False  # No animation.
 
         rd = context.scene.render
         image_settings = rd.image_settings
 
         layout.prop(rd, "filepath", text="")
 
-        split = layout.split()
+        layout.use_property_split = True
+
+        flow = layout.grid_flow(row_major=True, columns=0, even_columns=True, even_rows=False, align=False)
 
-        col = split.column()
+        col = flow.column()
         col.active = not rd.is_movie_format
         col.prop(rd, "use_overwrite")
+        col = flow.column()
+        col.active = not rd.is_movie_format
         col.prop(rd, "use_placeholder")
-
-        col = split.column()
+        col = flow.column()
         col.prop(rd, "use_file_extension")
+        col = flow.column()
         col.prop(rd, "use_render_cache")
 
         layout.template_image_settings(image_settings, color_management=False)
-        if rd.use_multiview:
-            layout.template_image_views(image_settings)
+
+
+class RENDER_PT_output_views(RenderButtonsPanel, Panel):
+    bl_label = "Views"
+    bl_parent_id = "RENDER_PT_output"
+    COMPAT_ENGINES = {'BLENDER_RENDER', 'BLENDER_EEVEE', 'BLENDER_OPENGL'}
+
+    @classmethod
+    def poll(self, context):
+        rd = context.scene.render
+        return rd.use_multiview
+
+    def draw(self, context):
+        layout = self.layout
+        layout.use_property_split = False
+        layout.use_property_decorate = False  # No animation.
+
+        rd = context.scene.render
+        layout.template_image_views(rd.image_settings)
 
 
 class RENDER_PT_encoding(RenderButtonsPanel, Panel):
     bl_label = "Encoding"
+    bl_parent_id = "RENDER_PT_output"
     bl_options = {'DEFAULT_CLOSED'}
-    COMPAT_ENGINES = {'BLENDER_RENDER'}
+    COMPAT_ENGINES = {'BLENDER_RENDER', 'BLENDER_EEVEE', 'BLENDER_OPENGL'}
+
+    def draw_header_preset(self, context):
+        RENDER_PT_ffmpeg_presets.draw_panel_header(self.layout)
 
     @classmethod
     def poll(cls, context):
@@ -423,29 +352,35 @@ class RENDER_PT_encoding(RenderButtonsPanel, Panel):
 
     def draw(self, context):
         layout = self.layout
+        layout.use_property_split = True
+        layout.use_property_decorate = False
 
         rd = context.scene.render
         ffmpeg = rd.ffmpeg
 
-        layout.menu("RENDER_MT_ffmpeg_presets", text="Presets")
+        layout.prop(rd.ffmpeg, "format")
+        layout.prop(ffmpeg, "use_autosplit")
 
-        split = layout.split()
-        split.prop(rd.ffmpeg, "format")
-        split.prop(ffmpeg, "use_autosplit")
 
-        # Video:
-        layout.separator()
-        self.draw_vcodec(context)
+class RENDER_PT_encoding_video(RenderButtonsPanel, Panel):
+    bl_label = "Video"
+    bl_parent_id = "RENDER_PT_encoding"
+    COMPAT_ENGINES = {'BLENDER_RENDER', 'BLENDER_EEVEE', 'BLENDER_OPENGL'}
 
-        # Audio:
-        layout.separator()
-        if ffmpeg.format != 'MP3':
-            layout.prop(ffmpeg, "audio_codec", text="Audio Codec")
+    @classmethod
+    def poll(cls, context):
+        rd = context.scene.render
+        return rd.image_settings.file_format in {'FFMPEG', 'XVID', 'H264', 'THEORA'}
 
-        if ffmpeg.audio_codec != 'NONE':
-            row = layout.row()
-            row.prop(ffmpeg, "audio_bitrate")
-            row.prop(ffmpeg, "audio_volume", slider=True)
+    def draw(self, context):
+        layout = self.layout
+        layout.use_property_split = True
+        layout.use_property_decorate = False
+
+        rd = context.scene.render
+        ffmpeg = rd.ffmpeg
+
+        self.draw_vcodec(context)
 
     def draw_vcodec(self, context):
         """Video codec options."""
@@ -472,113 +407,559 @@ class RENDER_PT_encoding(RenderButtonsPanel, Panel):
         # I-frames
         layout.prop(ffmpeg, "gopsize")
         # B-Frames
-        row = layout.row()
-        row.prop(ffmpeg, "use_max_b_frames", text="Max B-frames")
-        pbox = row.split()
+        split = layout.split(factor=0.5)
+        split.prop(ffmpeg, "use_max_b_frames", text="Max B-frames")
+        pbox = split.column()
         pbox.prop(ffmpeg, "max_b_frames", text="")
         pbox.enabled = ffmpeg.use_max_b_frames
 
         if not use_crf or ffmpeg.constant_rate_factor == 'NONE':
-            split = layout.split()
-            col = split.column()
-            col.label(text="Rate:")
-            col.prop(ffmpeg, "video_bitrate")
-            col.prop(ffmpeg, "minrate", text="Minimum")
-            col.prop(ffmpeg, "maxrate", text="Maximum")
+            col = layout.column()
+
+            sub = col.column(align=True)
+            sub.prop(ffmpeg, "video_bitrate")
+            sub.prop(ffmpeg, "minrate", text="Minimum")
+            sub.prop(ffmpeg, "maxrate", text="Maximum")
+
             col.prop(ffmpeg, "buffersize", text="Buffer")
 
-            col = split.column()
-            col.label(text="Mux:")
-            col.prop(ffmpeg, "muxrate", text="Rate")
-            col.prop(ffmpeg, "packetsize", text="Packet Size")
+            col.separator()
 
+            col.prop(ffmpeg, "muxrate", text="Mux Rate")
+            col.prop(ffmpeg, "packetsize", text="Mux Packet Size")
 
-class RENDER_PT_bake(RenderButtonsPanel, Panel):
-    bl_label = "Bake"
-    bl_options = {'DEFAULT_CLOSED'}
-    COMPAT_ENGINES = {'BLENDER_RENDER', 'BLENDER_GAME'}
+
+class RENDER_PT_encoding_audio(RenderButtonsPanel, Panel):
+    bl_label = "Audio"
+    bl_parent_id = "RENDER_PT_encoding"
+    COMPAT_ENGINES = {'BLENDER_RENDER', 'BLENDER_EEVEE', 'BLENDER_OPENGL'}
+
+    @classmethod
+    def poll(cls, context):
+        rd = context.scene.render
+        return rd.image_settings.file_format in {'FFMPEG', 'XVID', 'H264', 'THEORA'}
 
     def draw(self, context):
         layout = self.layout
+        layout.use_property_split = True
+        layout.use_property_decorate = False
 
         rd = context.scene.render
+        ffmpeg = rd.ffmpeg
 
-        layout.operator("object.bake_image", icon='RENDER_STILL')
+        if ffmpeg.format != 'MP3':
+            layout.prop(ffmpeg, "audio_codec", text="Audio Codec")
 
-        layout.prop(rd, "bake_type")
+        if ffmpeg.audio_codec != 'NONE':
+            layout.prop(ffmpeg, "audio_bitrate")
+            layout.prop(ffmpeg, "audio_volume", slider=True)
 
-        multires_bake = False
-        if rd.bake_type in ['NORMALS', 'DISPLACEMENT', 'DERIVATIVE', 'AO']:
-            layout.prop(rd, "use_bake_multires")
-            multires_bake = rd.use_bake_multires
 
-        if not multires_bake:
-            if rd.bake_type == 'NORMALS':
-                layout.prop(rd, "bake_normal_space")
-            elif rd.bake_type in {'DISPLACEMENT', 'AO'}:
-                layout.prop(rd, "use_bake_normalize")
+class RENDER_UL_renderviews(UIList):
+    def draw_item(self, context, layout, data, item, icon, active_data, active_propname, index):
+        view = item
+        if self.layout_type in {'DEFAULT', 'COMPACT'}:
+            if view.name in {"left", "right"}:
+                layout.label(text=view.name, icon_value=icon + (not view.use))
+            else:
+                layout.prop(view, "name", text="", index=index, icon_value=icon, emboss=False)
+            layout.prop(view, "use", text="", index=index)
 
-            # col.prop(rd, "bake_aa_mode")
-            # col.prop(rd, "use_bake_antialiasing")
+        elif self.layout_type == 'GRID':
+            layout.alignment = 'CENTER'
+            layout.label(text="", icon_value=icon + (not view.use))
 
-            layout.separator()
 
-            split = layout.split()
+class RENDER_PT_stereoscopy(RenderButtonsPanel, Panel):
+    bl_label = "Stereoscopy"
+    COMPAT_ENGINES = {'BLENDER_RENDER', 'BLENDER_EEVEE', 'BLENDER_OPENGL'}
+    bl_options = {'DEFAULT_CLOSED'}
 
-            col = split.column()
-            col.prop(rd, "use_bake_to_vertex_color")
-            sub = col.column()
-            sub.active = not rd.use_bake_to_vertex_color
-            sub.prop(rd, "use_bake_clear")
-            sub.prop(rd, "bake_margin")
-            sub.prop(rd, "bake_quad_split", text="Split")
+    def draw_header(self, context):
+        rd = context.scene.render
+        self.layout.prop(rd, "use_multiview", text="")
 
-            col = split.column()
-            col.prop(rd, "use_bake_selected_to_active")
-            sub = col.column()
-            sub.active = rd.use_bake_selected_to_active
-            sub.prop(rd, "bake_distance")
-            sub.prop(rd, "bake_bias")
-        else:
-            split = layout.split()
+    def draw(self, context):
+        layout = self.layout
+
+        scene = context.scene
+        rd = scene.render
+        rv = rd.views.active
+
+        layout.active = rd.use_multiview
+        basic_stereo = rd.views_format == 'STEREO_3D'
+
+        row = layout.row()
+        row.prop(rd, "views_format", expand=True)
+
+        if basic_stereo:
+            row = layout.row()
+            row.template_list("RENDER_UL_renderviews", "name", rd, "stereo_views", rd.views, "active_index", rows=2)
 
-            col = split.column()
-            col.prop(rd, "use_bake_clear")
-            col.prop(rd, "bake_margin")
+            row = layout.row()
+            row.label(text="File Suffix:")
+            row.prop(rv, "file_suffix", text="")
 
-            if rd.bake_type == 'DISPLACEMENT':
-                col = split.column()
-                col.prop(rd, "use_bake_lores_mesh")
+        else:
+            row = layout.row()
+            row.template_list("RENDER_UL_renderviews", "name", rd, "views", rd.views, "active_index", rows=2)
 
-            if rd.bake_type == 'AO':
-                col = split.column()
-                col.prop(rd, "bake_bias")
-                col.prop(rd, "bake_samples")
+            col = row.column(align=True)
+            col.operator("scene.render_view_add", icon='ZOOMIN', text="")
+            col.operator("scene.render_view_remove", icon='ZOOMOUT', text="")
 
-        if rd.bake_type == 'DERIVATIVE':
             row = layout.row()
-            row.prop(rd, "use_bake_user_scale", text="")
+            row.label(text="Camera Suffix:")
+            row.prop(rv, "camera_suffix", text="")
 
-            sub = row.column()
-            sub.active = rd.use_bake_user_scale
-            sub.prop(rd, "bake_user_scale", text="User Scale")
+
+class RENDER_PT_eevee_ambient_occlusion(RenderButtonsPanel, Panel):
+    bl_label = "Ambient Occlusion"
+    bl_options = {'DEFAULT_CLOSED'}
+    COMPAT_ENGINES = {'BLENDER_EEVEE'}
+
+    @classmethod
+    def poll(cls, context):
+        return (context.engine in cls.COMPAT_ENGINES)
+
+    def draw_header(self, context):
+        scene = context.scene
+        props = scene.eevee
+        self.layout.prop(props, "use_gtao", text="")
+
+    def draw(self, context):
+        layout = self.layout
+        layout.use_property_split = True
+        scene = context.scene
+        props = scene.eevee
+
+        layout.active = props.use_gtao
+        col = layout.column()
+        col.prop(props, "use_gtao_bent_normals")
+        col.prop(props, "use_gtao_bounce")
+        col.prop(props, "gtao_distance")
+        col.prop(props, "gtao_factor")
+        col.prop(props, "gtao_quality")
+
+
+class RENDER_PT_eevee_motion_blur(RenderButtonsPanel, Panel):
+    bl_label = "Motion Blur"
+    bl_options = {'DEFAULT_CLOSED'}
+    COMPAT_ENGINES = {'BLENDER_EEVEE'}
+
+    @classmethod
+    def poll(cls, context):
+        return (context.engine in cls.COMPAT_ENGINES)
+
+    def draw_header(self, context):
+        scene = context.scene
+        props = scene.eevee
+        self.layout.prop(props, "use_motion_blur", text="")
+
+    def draw(self, context):
+        layout = self.layout
+        layout.use_property_split = True
+        scene = context.scene
+        props = scene.eevee
+
+        layout.active = props.use_motion_blur
+        col = layout.column()
+        col.prop(props, "motion_blur_samples")
+        col.prop(props, "motion_blur_shutter")
+
+
+class RENDER_PT_eevee_depth_of_field(RenderButtonsPanel, Panel):
+    bl_label = "Depth of Field"
+    bl_options = {'DEFAULT_CLOSED'}
+    COMPAT_ENGINES = {'BLENDER_EEVEE'}
+
+    @classmethod
+    def poll(cls, context):
+        return (context.engine in cls.COMPAT_ENGINES)
+
+    def draw_header(self, context):
+        scene = context.scene
+        props = scene.eevee
+        self.layout.prop(props, "use_dof", text="")
+
+    def draw(self, context):
+        layout = self.layout
+        layout.use_property_split = True
+        scene = context.scene
+        props = scene.eevee
+
+        layout.active = props.use_dof
+        col = layout.column()
+        col.prop(props, "bokeh_max_size")
+        col.prop(props, "bokeh_threshold")
+
+
+class RENDER_PT_eevee_bloom(RenderButtonsPanel, Panel):
+    bl_label = "Bloom"
+    bl_options = {'DEFAULT_CLOSED'}
+    COMPAT_ENGINES = {'BLENDER_EEVEE'}
+
+    @classmethod
+    def poll(cls, context):
+        return (context.engine in cls.COMPAT_ENGINES)
+
+    def draw_header(self, context):
+        scene = context.scene
+        props = scene.eevee
+        self.layout.prop(props, "use_bloom", text="")
+
+    def draw(self, context):
+        layout = self.layout
+        layout.use_property_split = True
+
+        scene = context.scene
+        props = scene.eevee
+
+        layout.active = props.use_bloom
+        col = layout.column()
+        col.prop(props, "bloom_threshold")
+        col.prop(props, "bloom_knee")
+        col.prop(props, "bloom_radius")
+        col.prop(props, "bloom_color")
+        col.prop(props, "bloom_intensity")
+        col.prop(props, "bloom_clamp")
+
+
+class RENDER_PT_eevee_volumetric(RenderButtonsPanel, Panel):
+    bl_label = "Volumetric"
+    bl_options = {'DEFAULT_CLOSED'}
+    COMPAT_ENGINES = {'BLENDER_EEVEE'}
+
+    @classmethod
+    def poll(cls, context):
+        return (context.engine in cls.COMPAT_ENGINES)
+
+    def draw_header(self, context):
+        scene = context.scene
+        props = scene.eevee
+        self.layout.prop(props, "use_volumetric", text="")
+
+    def draw(self, context):
+        layout = self.layout
+        layout.use_property_split = True
+
+        scene = context.scene
+        props = scene.eevee
+
+        layout.active = props.use_volumetric
+        col = layout.column()
+        sub = col.column(align=True)
+        sub.prop(props, "volumetric_start")
+        sub.prop(props, "volumetric_end")
+        col.prop(props, "volumetric_tile_size")
+        col.separator()
+        col.prop(props, "volumetric_samples")
+        sub.prop(props, "volumetric_sample_distribution")
+        col.separator()
+        col.prop(props, "use_volumetric_lights")
+
+        sub = col.column()
+        sub.active = props.use_volumetric_lights
+        sub.prop(props, "volumetric_light_clamp", text="Light Clamping")
+        col.separator()
+        col.prop(props, "use_volumetric_shadows")
+        sub = col.column()
+        sub.active = props.use_volumetric_shadows
+        sub.prop(props, "volumetric_shadow_samples", text="Shadow Samples")
+
+
+class RENDER_PT_eevee_subsurface_scattering(RenderButtonsPanel, Panel):
+    bl_label = "Subsurface Scattering"
+    bl_options = {'DEFAULT_CLOSED'}
+    COMPAT_ENGINES = {'BLENDER_EEVEE'}
+
+    @classmethod
+    def poll(cls, context):
+        return (context.engine in cls.COMPAT_ENGINES)
+
+    def draw_header(self, context):
+        scene = context.scene
+        props = scene.eevee
+        self.layout.prop(props, "use_sss", text="")
+
+    def draw(self, context):
+        layout = self.layout
+        layout.use_property_split = True
+
+        scene = context.scene
+        props = scene.eevee
+
+        layout.active = props.use_sss
+
+        col = layout.column()
+        col.prop(props, "sss_samples")
+        col.prop(props, "sss_jitter_threshold")
+        col.prop(props, "use_sss_separate_albedo")
+
+
+class RENDER_PT_eevee_screen_space_reflections(RenderButtonsPanel, Panel):
+    bl_label = "Screen Space Reflections"
+    bl_options = {'DEFAULT_CLOSED'}
+    COMPAT_ENGINES = {'BLENDER_EEVEE'}
+
+    @classmethod
+    def poll(cls, context):
+        return (context.engine in cls.COMPAT_ENGINES)
+
+    def draw_header(self, context):
+        scene = context.scene
+        props = scene.eevee
+        self.layout.prop(props, "use_ssr", text="")
+
+    def draw(self, context):
+        layout = self.layout
+        layout.use_property_split = True
+
+        scene = context.scene
+        props = scene.eevee
+
+        col = layout.column()
+        col.active = props.use_ssr
+        col.prop(props, "use_ssr_refraction", text="Refraction")
+        col.prop(props, "use_ssr_halfres")
+        col.prop(props, "ssr_quality")
+        col.prop(props, "ssr_max_roughness")
+        col.prop(props, "ssr_thickness")
+        col.prop(props, "ssr_border_fade")
+        col.prop(props, "ssr_firefly_fac")
+
+
+class RENDER_PT_eevee_shadows(RenderButtonsPanel, Panel):
+    bl_label = "Shadows"
+    bl_options = {'DEFAULT_CLOSED'}
+    COMPAT_ENGINES = {'BLENDER_EEVEE'}
+
+    @classmethod
+    def poll(cls, context):
+        return (context.engine in cls.COMPAT_ENGINES)
+
+    def draw(self, context):
+        layout = self.layout
+        layout.use_property_split = True
+
+        scene = context.scene
+        props = scene.eevee
+
+        col = layout.column()
+        col.prop(props, "shadow_method")
+        col.prop(props, "shadow_cube_size", text="Cube Size")
+        col.prop(props, "shadow_cascade_size", text="Cascade Size")
+        col.prop(props, "use_shadow_high_bitdepth")
+
+
+class RENDER_PT_eevee_sampling(RenderButtonsPanel, Panel):
+    bl_label = "Sampling"
+    bl_options = {'DEFAULT_CLOSED'}
+    COMPAT_ENGINES = {'BLENDER_EEVEE'}
+
+    @classmethod
+    def poll(cls, context):
+        return (context.engine in cls.COMPAT_ENGINES)
+
+    def draw(self, context):
+        layout = self.layout
+        layout.use_property_split = True
+        layout.use_property_decorate = False  # No animation.
+
+        scene = context.scene
+        props = scene.eevee
+
+        col = layout.column()
+        col.prop(props, "taa_samples")
+        col.prop(props, "taa_render_samples")
+        col.prop(props, "use_taa_reprojection")
+
+
+class RENDER_PT_eevee_indirect_lighting(RenderButtonsPanel, Panel):
+    bl_label = "Indirect Lighting"
+    bl_options = {'DEFAULT_CLOSED'}
+    COMPAT_ENGINES = {'BLENDER_EEVEE'}
+
+    @classmethod
+    def poll(cls, context):
+        return (context.engine in cls.COMPAT_ENGINES)
+
+    def draw(self, context):
+        layout = self.layout
+        layout.use_property_split = True
+        layout.use_property_decorate = False  # No animation.
+
+        scene = context.scene
+        props = scene.eevee
+
+        col = layout.column()
+        col.operator("scene.light_cache_bake", text="Bake Indirect Lighting", icon='RENDER_STILL')
+        col.operator("scene.light_cache_bake", text="Bake Cubemap Only", icon='LIGHTPROBE_CUBEMAP').subset = 'CUBEMAPS'
+        col.operator("scene.light_cache_free", text="Free Lighting Cache")
+
+        cache_info = scene.eevee.gi_cache_info
+        if cache_info:
+            col.label(text=cache_info)
+
+        col.prop(props, "gi_auto_bake")
+
+        col.prop(props, "gi_diffuse_bounces")
+        col.prop(props, "gi_cubemap_resolution")
+        col.prop(props, "gi_visibility_resolution", text="Diffuse Occlusion")
+
+        layout.use_property_split = False
+        row = layout.split(factor=0.5)
+        row.alignment = 'RIGHT'
+        row.label(text="Cubemap Display")
+
+        sub = row.row(align=True)
+        sub.prop(props, "gi_cubemap_display_size", text="Size")
+        if props.gi_show_cubemaps:
+            sub.prop(props, "gi_show_cubemaps", text="", toggle=True, icon='HIDE_OFF')
+        else:
+            sub.prop(props, "gi_show_cubemaps", text="", toggle=True, icon='HIDE_ON')
+
+        row = layout.split(factor=0.5)
+        row.alignment = 'RIGHT'
+        row.label(text="Irradiance Display")
+
+        sub = row.row(align=True)
+        sub.prop(props, "gi_irradiance_display_size", text="Size")
+        if props.gi_show_irradiance:
+            sub.prop(props, "gi_show_irradiance", text="", toggle=True, icon='HIDE_OFF')
+        else:
+            sub.prop(props, "gi_show_irradiance", text="", toggle=True, icon='HIDE_ON')
+
+
+class RENDER_PT_eevee_film(RenderButtonsPanel, Panel):
+    bl_label = "Film"
+    bl_options = {'DEFAULT_CLOSED'}
+    COMPAT_ENGINES = {'BLENDER_EEVEE'}
+
+    @classmethod
+    def poll(cls, context):
+        return (context.engine in cls.COMPAT_ENGINES)
+
+    def draw(self, context):
+        layout = self.layout
+        layout.use_property_split = True
+
+        scene = context.scene
+        rd = scene.render
+
+        col = layout.column()
+        col.prop(rd, "filter_size")
+        col.prop(rd, "alpha_mode", text="Alpha")
+
+
+class RENDER_PT_eevee_hair(RenderButtonsPanel, Panel):
+    bl_label = "Hair"
+    bl_options = {'DEFAULT_CLOSED'}
+    COMPAT_ENGINES = {'BLENDER_EEVEE'}
+
+    @classmethod
+    def poll(cls, context):
+        return (context.engine in cls.COMPAT_ENGINES)
+
+    def draw(self, context):
+        layout = self.layout
+        scene = context.scene
+        rd = scene.render
+
+        row = layout.row()
+        row.prop(rd, "hair_type", expand=True)
+
+        layout.use_property_split = True
+        layout.prop(rd, "hair_subdiv")
+
+
+class RENDER_PT_opengl_film(RenderButtonsPanel, Panel):
+    bl_label = "Film"
+    bl_options = {'DEFAULT_CLOSED'}
+    COMPAT_ENGINES = {'BLENDER_OPENGL'}
+
+    def draw(self, context):
+        layout = self.layout
+        layout.use_property_split = True
+        layout.use_property_decorate = False  # No animation.
+
+        rd = context.scene.render
+
+        layout.prop(rd, "use_antialiasing")
+
+        layout.prop(rd, "antialiasing_samples")
+        layout.prop(rd, "alpha_mode")
+
+
+class RENDER_PT_opengl_lighting(RenderButtonsPanel, Panel):
+    bl_label = "Lighting"
+    COMPAT_ENGINES = {'BLENDER_OPENGL'}
+
+    @classmethod
+    def poll(cls, context):
+        return (context.engine in cls.COMPAT_ENGINES)
+
+    def draw(self, context):
+        VIEW3D_PT_shading_lighting.draw(self, context)
+
+
+class RENDER_PT_opengl_color(RenderButtonsPanel, Panel):
+    bl_label = "Color"
+    COMPAT_ENGINES = {'BLENDER_OPENGL'}
+
+    @classmethod
+    def poll(cls, context):
+        return (context.engine in cls.COMPAT_ENGINES)
+
+    def draw(self, context):
+        VIEW3D_PT_shading_color._draw_color_type(self, context)
+
+
+class RENDER_PT_opengl_options(RenderButtonsPanel, Panel):
+    bl_label = "Options"
+    COMPAT_ENGINES = {'BLENDER_OPENGL'}
+
+    @classmethod
+    def poll(cls, context):
+        return (context.engine in cls.COMPAT_ENGINES)
+
+    def draw(self, context):
+        VIEW3D_PT_shading_options.draw(self, context)
 
 
 classes = (
-    RENDER_MT_presets,
-    RENDER_MT_ffmpeg_presets,
+    RENDER_PT_presets,
+    RENDER_PT_ffmpeg_presets,
     RENDER_MT_framerate_presets,
-    RENDER_PT_render,
+    RENDER_PT_context,
     RENDER_PT_dimensions,
-    RENDER_PT_antialiasing,
-    RENDER_PT_motion_blur,
-    RENDER_PT_shading,
-    RENDER_PT_performance,
+    RENDER_PT_frame_remapping,
     RENDER_PT_post_processing,
-    RENDER_PT_stamp,
     RENDER_PT_output,
+    RENDER_PT_output_views,
     RENDER_PT_encoding,
-    RENDER_PT_bake,
+    RENDER_PT_encoding_video,
+    RENDER_PT_encoding_audio,
+    RENDER_PT_stamp,
+    RENDER_PT_stamp_burn,
+    RENDER_UL_renderviews,
+    RENDER_PT_stereoscopy,
+    RENDER_PT_eevee_hair,
+    RENDER_PT_eevee_sampling,
+    RENDER_PT_eevee_film,
+    RENDER_PT_eevee_shadows,
+    RENDER_PT_eevee_indirect_lighting,
+    RENDER_PT_eevee_subsurface_scattering,
+    RENDER_PT_eevee_screen_space_reflections,
+    RENDER_PT_eevee_ambient_occlusion,
+    RENDER_PT_eevee_volumetric,
+    RENDER_PT_eevee_motion_blur,
+    RENDER_PT_eevee_depth_of_field,
+    RENDER_PT_eevee_bloom,
+    RENDER_PT_opengl_film,
+    RENDER_PT_opengl_lighting,
+    RENDER_PT_opengl_color,
+    RENDER_PT_opengl_options,
 )
 
 if __name__ == "__main__":  # only for live edit.