2.5: Render
authorBrecht Van Lommel <brechtvanlommel@pandora.be>
Mon, 13 Jul 2009 19:09:13 +0000 (19:09 +0000)
committerBrecht Van Lommel <brechtvanlommel@pandora.be>
Mon, 13 Jul 2009 19:09:13 +0000 (19:09 +0000)
* UI layout for scene buttons has quite some changes, I tried to
  better organize things according to the pipeline, and also showing
  important properties by default, and collapsing less important ones.

Some changes compared to 2.4x:
* Panorama is now a Camera property.
* Sequence and Compositing are now enabled by default, but will only
  do something when there is a node tree using nodes, or a strip in the
  sequence editor.
* Enabling Full Sample now automatically enables Save Buffers too.
* Stamp option to include info in file is removed, it now simply always
  does this if one of the stamp infos is enabled.
* Xvid, H.264 and Ogg Theora are now directly in the file format menu,
  but still using FFMPEG. Unfortunately Ogg is broken at the moment
  (also in 2.4x), so that's disabled. And Xvid crashes on 64bit linux,
  maybe solvable by upgrading extern/xvidcore/, using ubuntu libs makes
  it work.
* Organized file format menu by image/movie types.

Added:
* Render layers RNA wrapped, operatorized, layouted.
* FFMPEG format/codec options are now working.

Defaults changed:
* Compositing & Sequencer enabled.
* Tiles set to 8x8.
* Time/Date/Frame/Scene/Camera/Filename enabled for stamp.

26 files changed:
release/ui/buttons_data_camera.py
release/ui/buttons_scene.py
source/blender/blenkernel/BKE_writeffmpeg.h
source/blender/blenkernel/intern/image.c
source/blender/blenkernel/intern/scene.c
source/blender/blenkernel/intern/sequence.c
source/blender/blenkernel/intern/writeavi.c
source/blender/blenkernel/intern/writeffmpeg.c
source/blender/blenloader/intern/readfile.c
source/blender/editors/interface/interface_layout.c
source/blender/editors/interface/interface_regions.c
source/blender/editors/screen/screen_ops.c
source/blender/editors/space_buttons/buttons_intern.h
source/blender/editors/space_buttons/buttons_ops.c
source/blender/editors/space_buttons/space_buttons.c
source/blender/editors/space_file/writeimage.c
source/blender/makesdna/DNA_camera_types.h
source/blender/makesdna/DNA_scene_types.h
source/blender/makesrna/SConscript
source/blender/makesrna/intern/CMakeLists.txt
source/blender/makesrna/intern/Makefile
source/blender/makesrna/intern/SConscript
source/blender/makesrna/intern/rna_camera.c
source/blender/makesrna/intern/rna_scene.c
source/blender/render/intern/source/initrender.c
source/blender/render/intern/source/pipeline.c

index f583f96..7ca7002 100644 (file)
@@ -38,7 +38,6 @@ class DATA_PT_camera(DataButtonsPanel):
                
                cam = context.camera
 
-               layout.itemS()
                layout.itemR(cam, "type", expand=True)
                        
                row = layout.row(align=True)
@@ -51,6 +50,10 @@ class DATA_PT_camera(DataButtonsPanel):
 
                elif cam.type == 'ORTHO':
                        row.itemR(cam, "ortho_scale")
+
+               split = layout.split()
+               split.itemR(cam, "panorama");
+               split.itemL()
                                
                split = layout.split()
                        
@@ -64,9 +67,13 @@ class DATA_PT_camera(DataButtonsPanel):
                sub.itemR(cam, "clip_start", text="Start")
                sub.itemR(cam, "clip_end", text="End")
                        
-               row = layout.row()
-               row.itemR(cam, "dof_object")
-               row.itemR(cam, "dof_distance")
+               split = layout.split()
+               col = split.column()
+               col.itemL(text="Depth of Field:")
+               col.itemR(cam, "dof_object", text="")
+               col = split.column()
+               col.itemL()
+               col.itemR(cam, "dof_distance", text="Distance")
                
 class DATA_PT_camera_display(DataButtonsPanel):
        __idname__ = "DATA_PT_camera_display"
index a774b88..50cb8f7 100644 (file)
@@ -6,6 +6,103 @@ class RenderButtonsPanel(bpy.types.Panel):
        __region_type__ = "WINDOW"
        __context__ = "scene"
 
+class RENDER_PT_render(RenderButtonsPanel):
+       __label__ = "Render"
+
+       def draw(self, context):
+               layout = self.layout
+               rd = context.scene.render_data
+
+               row = layout.row()
+               row.itemO("SCREEN_OT_render", text="Image", icon='ICON_IMAGE_COL')
+               row.item_booleanO("SCREEN_OT_render", "anim", True, text="Animation", icon='ICON_SEQUENCE')
+
+               layout.itemR(rd, "display_mode", text="Display")
+
+class RENDER_PT_layers(RenderButtonsPanel):
+       __label__ = "Layers"
+       __default_closed__ = True
+
+       def draw(self, context):
+               layout = self.layout
+               scene = context.scene
+               rd = scene.render_data
+
+               split = layout.split()
+               split.itemL(text="Scene:")
+               split.column().itemR(scene, "visible_layers", text="")
+
+               row = layout.row()
+               row.template_list(rd, "layers", rd, "active_layer_index", rows=2)
+
+               col = row.column(align=True)
+               col.itemO("SCENE_OT_render_layer_add", icon="ICON_ZOOMIN", text="")
+               col.itemO("SCENE_OT_render_layer_remove", icon="ICON_ZOOMOUT", text="")
+
+               rl = rd.layers[rd.active_layer_index]
+
+               split = layout.split()
+               split.itemL(text="Layers:")
+               split.column().itemR(rl, "visible_layers", text="")
+
+               layout.itemR(rl, "light_override", text="Light")
+               layout.itemR(rl, "material_override", text="Material")
+
+               split = layout.split()
+
+               col = split.column()
+               col.itemR(rl, "zmask")
+               row = col.row()
+               row.itemR(rl, "zmask_negate", text="Negate")
+               row.active = rl.zmask
+               col.itemR(rl, "all_z")
+
+               col = split.column()
+               col.itemR(rl, "solid")
+               col.itemR(rl, "halo")
+               col.itemR(rl, "ztransp")
+
+               col = split.column()
+               col.itemR(rl, "sky")
+               col.itemR(rl, "edge")
+               col.itemR(rl, "strand")
+
+               if rl.zmask:
+                       split = layout.split()
+                       split.itemL(text="Zmask Layers:")
+                       split.column().itemR(rl, "zmask_layers", text="")
+
+               split = layout.split()
+               col = split.column()
+               col.itemL(text="Passes:")
+               col.itemR(rl, "pass_combined")
+               col.itemR(rl, "pass_z")
+               col.itemR(rl, "pass_vector")
+               col.itemR(rl, "pass_normal")
+               col.itemR(rl, "pass_uv")
+               col.itemR(rl, "pass_mist")
+               col.itemR(rl, "pass_object_index")
+
+               col = split.column()
+               col.itemL()
+               col.itemR(rl, "pass_color")
+               col.itemR(rl, "pass_diffuse")
+               row = col.row()
+               row.itemR(rl, "pass_specular")
+               row.itemR(rl, "pass_specular_exclude", text="", icon="ICON_DOT")
+               row = col.row()
+               row.itemR(rl, "pass_shadow")
+               row.itemR(rl, "pass_shadow_exclude", text="", icon="ICON_DOT")
+               row = col.row()
+               row.itemR(rl, "pass_ao")
+               row.itemR(rl, "pass_ao_exclude", text="", icon="ICON_DOT")
+               row = col.row()
+               row.itemR(rl, "pass_reflection")
+               row.itemR(rl, "pass_reflection_exclude", text="", icon="ICON_DOT")
+               row = col.row()
+               row.itemR(rl, "pass_refraction")
+               row.itemR(rl, "pass_refraction_exclude", text="", icon="ICON_DOT")
+
 class RENDER_PT_shading(RenderButtonsPanel):
        __label__ = "Shading"
 
@@ -15,18 +112,82 @@ class RENDER_PT_shading(RenderButtonsPanel):
                
                split = layout.split()
                
-               sub = split.column()
-               sub.itemR(rd, "render_shadows", text="Shadows")
-               sub.itemR(rd, "render_sss", text="Subsurface Scattering")
-               sub.itemR(rd, "render_envmaps", text="Environment Map")
-               #       sub.itemR(rd, "render_radiosity", text="Radio")
+               col = split.column()
+               col.itemR(rd, "render_shadows", text="Shadows")
+               col.itemR(rd, "render_sss", text="Subsurface Scattering")
+               col.itemR(rd, "render_envmaps", text="Environment Map")
                
                col = split.column()
                col.itemR(rd, "render_raytracing", text="Ray Tracing")
+               row = col.row()
+               row.active = rd.render_raytracing
+               row.itemR(rd, "octree_resolution", text="Octree")
+               col.itemR(rd, "alpha_mode", text="Alpha")
+
+class RENDER_PT_performance(RenderButtonsPanel):
+       __label__ = "Performance"
+       __default_closed__ = True
+
+       def draw(self, context):
+               layout = self.layout
+               rd = context.scene.render_data
+
+               split = layout.split()
+               
+               col = split.column(align=True)
+               col.itemL(text="Threads:")
+               col.row().itemR(rd, "threads_mode", expand=True)
                colsub = col.column()
-               colsub.active = rd.render_raytracing
-               colsub.itemR(rd, "octree_resolution", text="Octree")
-               col.itemR(rd, "dither_intensity", text="Dither", slider=True)
+               colsub.enabled = rd.threads_mode == 'THREADS_FIXED'
+               colsub.itemR(rd, "threads")
+
+               col = split.column()
+               
+               sub = col.column(align=True)
+               sub.itemL(text="Tiles:")
+               sub.itemR(rd, "parts_x", text="X")
+               sub.itemR(rd, "parts_y", text="Y")
+
+               split = layout.split()
+
+               col = split.column()
+               col.itemL(text="Memory:")
+               row = col.row()
+               row.itemR(rd, "save_buffers")
+               row.enabled = not rd.full_sample
+
+               col = split.column()
+               col.itemL()
+               col.itemR(rd, "free_image_textures")
+               col.active = rd.use_compositing
+
+class RENDER_PT_post_processing(RenderButtonsPanel):
+       __label__ = "Post Processing"
+       __default_closed__ = True
+
+       def draw(self, context):
+               layout = self.layout
+               rd = context.scene.render_data
+
+               split = layout.split()
+
+               col = split.column()
+               col.itemR(rd, "use_compositing")
+               col.itemR(rd, "use_sequencer")
+
+               col = split.column()
+               row = col.row()
+               row.itemR(rd, "fields", text="Fields")
+               rowsub = row.row()
+               rowsub.active = rd.fields
+               rowsub.itemR(rd, "fields_still", text="Still")
+               rowsub = col.row()
+               rowsub.active = rd.fields
+               rowsub.itemR(rd, "field_order", expand=True)
+
+               split = layout.split()
+               split.itemL()
+               split.itemR(rd, "dither_intensity", text="Dither", slider=True)
                
 class RENDER_PT_output(RenderButtonsPanel):
        __label__ = "Output"
@@ -35,96 +196,115 @@ class RENDER_PT_output(RenderButtonsPanel):
                layout = self.layout
                rd = context.scene.render_data
                
-               layout.itemR(rd, "display_mode", text="Display")
-               
-               layout.itemR(rd, "output_path")
-               
+               layout.itemR(rd, "output_path", text="")
+
                split = layout.split()
-               
-               col = split.column()
-               col.itemR(rd, "file_extensions")                
-               col.itemR(rd, "fields", text="Fields")
-               colsub = col.column()
-               colsub.active = rd.fields
-               colsub.itemR(rd, "fields_still", text="Still")
-               colsub.row().itemR(rd, "field_order", expand=True)
-               
                col = split.column()
-               col.itemR(rd, "color_mode")
-               col.itemR(rd, "alpha_mode")
-               col.itemL(text="Distributed Rendering:")
                col.itemR(rd, "placeholders")
                col.itemR(rd, "no_overwrite")
-               
-               layout.itemR(rd, "file_format", text="Format")
-               
-               split = layout.split()
-               
+
                col = split.column()
-               
+               col.itemR(rd, "file_format", text="")
+               col.itemR(rd, "file_extensions")                
+
                if rd.file_format in ('AVIJPEG', 'JPEG'):
-                       col.itemR(rd, "quality", slider=True)
+                       split = layout.split()
+                       split.itemR(rd, "color_mode", text="Color")
+                       split.itemR(rd, "quality", slider=True)
                        
                elif rd.file_format == 'OPENEXR':
+                       split = layout.split()
+                       col = split.column()
+                       col.itemR(rd, "color_mode", text="Color")
                        col.itemR(rd, "exr_codec")
+
+                       subsplit = split.split()
+                       col = subsplit.column()
                        col.itemR(rd, "exr_half")
-                       col = split.column()
                        col.itemR(rd, "exr_zbuf")
+                       col = subsplit.column()
                        col.itemR(rd, "exr_preview")
                
                elif rd.file_format == 'JPEG2000':
-                       row = layout.row()
-                       row.itemR(rd, "jpeg_preset")
                        split = layout.split()
                        col = split.column()
+                       col.itemR(rd, "color_mode", text="Color")
                        col.itemL(text="Depth:")
                        col.row().itemR(rd, "jpeg_depth", expand=True)
+
                        col = split.column()
+                       col.itemR(rd, "jpeg_preset", text="")
                        col.itemR(rd, "jpeg_ycc")
                        col.itemR(rd, "exr_preview")
                        
                elif rd.file_format in ('CINEON', 'DPX'):
+                       split = layout.split()
+                       col = split.column()
+                       col.itemR(rd, "color_mode", text="Color")
                        col.itemR(rd, "cineon_log", text="Convert to Log")
-                       colsub = col.column()
-                       colsub.active = rd.cineon_log
-                       colsub.itemR(rd, "cineon_black", text="Black")
-                       colsub.itemR(rd, "cineon_white", text="White")
-                       colsub.itemR(rd, "cineon_gamma", text="Gamma")
+
+                       col = split.column(align=True)
+                       col.active = rd.cineon_log
+                       col.itemR(rd, "cineon_black", text="Black")
+                       col.itemR(rd, "cineon_white", text="White")
+                       col.itemR(rd, "cineon_gamma", text="Gamma")
                        
                elif rd.file_format == 'TIFF':
-                       col.itemR(rd, "tiff_bit")
-               
-               elif rd.file_format == 'FFMPEG':
-                       #row = layout.row()
-                       #row.itemR(rd, "ffmpeg_format")
-                       #row.itemR(rd, "ffmpeg_codec")
                        split = layout.split()
+                       split.itemR(rd, "color_mode", text="Color")
+                       split.itemR(rd, "tiff_bit")
                
-                       col = split.column()
-                       col.itemR(rd, "ffmpeg_video_bitrate")
-                       col.itemL(text="Rate:")
-                       col.itemR(rd, "ffmpeg_minrate", text="Minimum")
-                       col.itemR(rd, "ffmpeg_maxrate", text="Maximum")
-                       col.itemR(rd, "ffmpeg_buffersize", text="Buffer")
-                       
-                       col = split.column()
-                       col.itemR(rd, "ffmpeg_gopsize")
-                       col.itemR(rd, "ffmpeg_autosplit")
-                       col.itemL(text="Mux:")
-                       col.itemR(rd, "ffmpeg_muxrate", text="Rate")
-                       col.itemR(rd, "ffmpeg_packetsize", text="Packet Size")
-                       
-                       row = layout.row()
-                       row.itemL(text="Audio:")
-                       row = layout.row()
-                       #row.itemR(rd, "ffmpeg_audio_codec")
-                       
+               else:
                        split = layout.split()
+                       split.itemR(rd, "color_mode", text="Color")
+                       split.itemL()
+
+class RENDER_PT_encoding(RenderButtonsPanel):
+       __label__ = "Encoding"
+       __default_closed__ = True
        
-                       col = split.column()
-                       col.itemR(rd, "ffmpeg_audio_bitrate")
-                       col = split.column()
-                       col.itemR(rd, "ffmpeg_multiplex_audio")
+       def poll(self, context):
+               rd = context.scene.render_data
+               return rd.file_format in ('FFMPEG', 'XVID', 'H264', 'THEORA')
+
+       def draw(self, context):
+               layout = self.layout
+               rd = context.scene.render_data
+
+               split = layout.split()
+               split.itemR(rd, "ffmpeg_format")
+               if rd.ffmpeg_format in ('AVI', 'QUICKTIME', 'MKV', 'OGG'):
+                       split.itemR(rd, "ffmpeg_codec")
+               else:
+                       split.itemL()
+
+               split = layout.split()
+       
+               col = split.column()
+               col.itemR(rd, "ffmpeg_video_bitrate")
+               col.itemL(text="Rate:")
+               col.itemR(rd, "ffmpeg_minrate", text="Minimum")
+               col.itemR(rd, "ffmpeg_maxrate", text="Maximum")
+               col.itemR(rd, "ffmpeg_buffersize", text="Buffer")
+               
+               col = split.column()
+               col.itemR(rd, "ffmpeg_gopsize")
+               col.itemR(rd, "ffmpeg_autosplit")
+               col.itemL(text="Mux:")
+               col.itemR(rd, "ffmpeg_muxrate", text="Rate")
+               col.itemR(rd, "ffmpeg_packetsize", text="Packet Size")
+               
+               row = layout.row()
+               row.itemL(text="Audio:")
+               row = layout.row()
+               row.itemR(rd, "ffmpeg_audio_codec")
+               
+               split = layout.split()
+
+               col = split.column()
+               col.itemR(rd, "ffmpeg_audio_bitrate")
+               col = split.column()
+               col.itemR(rd, "ffmpeg_multiplex_audio")
 
 class RENDER_PT_antialiasing(RenderButtonsPanel):
        __label__ = "Anti-Aliasing"
@@ -143,57 +323,14 @@ class RENDER_PT_antialiasing(RenderButtonsPanel):
 
                split = layout.split()
                
-               sub = split.column()
-               sub.itemL(text="Samples:")
-               sub.row().itemR(rd, "antialiasing_samples", expand=True)
-               sub.itemR(rd, "pixel_filter")
+               col = split.column()
+               col.row().itemR(rd, "antialiasing_samples", expand=True)
+               col.itemR(rd, "full_sample")
 
                col = split.column()
+               col.itemR(rd, "pixel_filter", text="Filter")
                col.itemR(rd, "filter_size", text="Size", slider=True)
-               col.itemR(rd, "save_buffers")
-               colsub = col.column()
-               colsub.active = rd.save_buffers
-               colsub.itemR(rd, "full_sample")
-
-class RENDER_PT_render(RenderButtonsPanel):
-       __label__ = "Render"
-
-       def draw(self, context):
-               layout = self.layout
-               rd = context.scene.render_data
-
-               row = layout.row()
-               row.itemO("SCREEN_OT_render", text="Render Still", icon='ICON_IMAGE_COL')
-               row.item_booleanO("SCREEN_OT_render", "anim", True, text="Render Animation", icon='ICON_SEQUENCE')
-               
-               row = layout.row()
-               row.itemR(rd, "do_composite")
-               row.itemR(rd, "do_sequence")
-               rowsub = layout.row()
-               rowsub.active = rd.do_composite
-               rowsub.itemR(rd, "free_image_textures")
-
-               split = layout.split()
-               
-               col = split.column(align=True)
-               col.itemL(text="Threads:")
-               col.row().itemR(rd, "threads_mode", expand=True)
-               colsub = col.column()
-               colsub.active = rd.threads_mode == 'THREADS_FIXED'
-               colsub.itemR(rd, "threads")
-               
-               sub = split.column(align=True)
-               sub.itemL(text="Tiles:")
-               sub.itemR(rd, "parts_x", text="X")
-               sub.itemR(rd, "parts_y", text="Y")
-               
-               split = layout.split()
-               sub = split.column()
-               sub = split.column()
-               sub.itemR(rd, "panorama")
-               
-               #       row.itemR(rd, "backbuf")
-                       
+       
 class RENDER_PT_dimensions(RenderButtonsPanel):
        __label__ = "Dimensions"
 
@@ -215,13 +352,13 @@ class RENDER_PT_dimensions(RenderButtonsPanel):
                sub.itemL(text="Aspect Ratio:")
                sub.itemR(rd, "pixel_aspect_x", text="X")
                sub.itemR(rd, "pixel_aspect_y", text="Y")
-               
-               col = col.column(align=False)
-               col.itemR(rd, "border", text="Border")
-               colsub = col.column()
-               colsub.active = rd.border
-               colsub.itemR(rd, "crop_to_border")
 
+               row = col.row()
+               row.itemR(rd, "border", text="Border")
+               rowsub = row.row()
+               rowsub.active = rd.border
+               rowsub.itemR(rd, "crop_to_border", text="Crop")
+               
                col = split.column(align=True)
                col.itemL(text="Frame Range:")
                col.itemR(scene, "start_frame", text="Start")
@@ -239,13 +376,13 @@ class RENDER_PT_stamp(RenderButtonsPanel):
                rd = context.scene.render_data
 
                layout = self.layout
-               layout.itemR(rd, "stamp", text="")
+               layout.itemR(rd, "render_stamp", text="")
 
        def draw(self, context):
                layout = self.layout
                rd = context.scene.render_data
 
-               layout.active = rd.stamp
+               layout.active = rd.render_stamp
 
                split = layout.split()
                
@@ -253,26 +390,32 @@ class RENDER_PT_stamp(RenderButtonsPanel):
                col.itemR(rd, "stamp_time", text="Time")
                col.itemR(rd, "stamp_date", text="Date")
                col.itemR(rd, "stamp_frame", text="Frame")
-               col.itemR(rd, "stamp_camera", text="Scene")
-               col.itemR(rd, "stamp_marker", text="Marker")
+               col.itemR(rd, "stamp_scene", text="Scene")
+               col.itemR(rd, "stamp_camera", text="Camera")
                col.itemR(rd, "stamp_filename", text="Filename")
+               col.itemR(rd, "stamp_marker", text="Marker")
                col.itemR(rd, "stamp_sequence_strip", text="Seq. Strip")
-               col.itemR(rd, "stamp_note", text="Note")
-               colsub = col.column()
-               colsub.active = rd.stamp_note
-               colsub.itemR(rd, "stamp_note_text", text="")
-               
+
                sub = split.column()
-               sub.itemR(rd, "render_stamp")
-               colsub = sub.column()
-               colsub.active = rd.render_stamp
-               colsub.itemR(rd, "stamp_foreground", slider=True)
-               colsub.itemR(rd, "stamp_background", slider=True)
-               colsub.itemR(rd, "stamp_font_size", text="Font Size")
+               sub.active = rd.render_stamp
+               sub.itemR(rd, "stamp_foreground", slider=True)
+               sub.itemR(rd, "stamp_background", slider=True)
+               sub.itemR(rd, "stamp_font_size", text="Font Size")
+
+               row = layout.split(percentage=0.2)
+               row.itemR(rd, "stamp_note", text="Note")
+               rowsub = row.row()
+               rowsub.active = rd.stamp_note
+               rowsub.itemR(rd, "stamp_note_text", text="")
 
 bpy.types.register(RENDER_PT_render)
 bpy.types.register(RENDER_PT_dimensions)
 bpy.types.register(RENDER_PT_antialiasing)
+bpy.types.register(RENDER_PT_layers)
 bpy.types.register(RENDER_PT_shading)
+bpy.types.register(RENDER_PT_post_processing)
+bpy.types.register(RENDER_PT_performance)
 bpy.types.register(RENDER_PT_output)
+bpy.types.register(RENDER_PT_encoding)
 bpy.types.register(RENDER_PT_stamp)
+
index dba3944..be136bd 100644 (file)
@@ -46,19 +46,29 @@ extern "C" {
 #define FFMPEG_MKV      9
 #define FFMPEG_OGG      10
 
-#define FFMPEG_PRESET_NONE 0
-#define FFMPEG_PRESET_DVD  1
-#define FFMPEG_PRESET_SVCD 2
-#define FFMPEG_PRESET_VCD  3
-#define FFMPEG_PRESET_DV   4
-#define FFMPEG_PRESET_H264 5
+#define FFMPEG_PRESET_NONE             0
+#define FFMPEG_PRESET_DVD              1
+#define FFMPEG_PRESET_SVCD             2
+#define FFMPEG_PRESET_VCD              3
+#define FFMPEG_PRESET_DV               4
+#define FFMPEG_PRESET_H264             5
+#define FFMPEG_PRESET_THEORA   6
+#define FFMPEG_PRESET_XVID             7
 
+struct IDProperty;
 struct RenderData;     
 
 extern void start_ffmpeg(struct RenderData *rd, int rectx, int recty);
 extern void end_ffmpeg(void);
 extern void append_ffmpeg(struct RenderData *rd, int frame, int *pixels, int rectx, int recty);
 
+extern void ffmpeg_set_preset(struct RenderData *rd, int preset);
+extern void ffmpeg_verify_image_type(struct RenderData *rd);
+
+extern struct IDProperty *ffmpeg_property_add(struct RenderData *Rd, char *type, int opt_index, int parent_index);
+extern int ffmpeg_property_add_string(struct RenderData *rd, const char *type, const char *str);
+extern void ffmpeg_property_del(struct RenderData *rd, void *type, void *prop_);
+
 #ifdef __cplusplus
 }
 #endif
index 754ec06..93924d1 100644 (file)
@@ -860,6 +860,9 @@ int BKE_imtype_is_movie(int imtype)
        case R_AVICODEC:
        case R_QUICKTIME:
        case R_FFMPEG:
+       case R_H264:
+       case R_THEORA:
+       case R_XVID:
        case R_FRAMESERVER:
                        return 1;
        }
@@ -870,7 +873,7 @@ void BKE_add_image_extension(Scene *scene, char *string, int imtype)
 {
        char *extension="";
        
-       if(scene->r.imtype== R_IRIS) {
+       if(imtype== R_IRIS) {
                if(!BLI_testextensie(string, ".rgb"))
                        extension= ".rgb";
        }
@@ -882,7 +885,7 @@ void BKE_add_image_extension(Scene *scene, char *string, int imtype)
                if(!BLI_testextensie(string, ".hdr"))
                        extension= ".hdr";
        }
-       else if(imtype==R_PNG || imtype==R_FFMPEG) {
+       else if (ELEM5(imtype, R_PNG, R_FFMPEG, R_H264, R_THEORA, R_XVID)) {
                if(!BLI_testextensie(string, ".png"))
                        extension= ".png";
        }
@@ -1230,7 +1233,7 @@ int BKE_write_ibuf(Scene *scene, ImBuf *ibuf, char *name, int imtype, int subimt
        else if ((imtype==R_RADHDR)) {
                ibuf->ftype= RADHDR;
        }
-       else if (imtype==R_PNG || imtype==R_FFMPEG) {
+       else if (ELEM5(imtype, R_PNG, R_FFMPEG, R_H264, R_THEORA, R_XVID)) {
                ibuf->ftype= PNG;
        }
 #ifdef WITH_DDS
@@ -1305,7 +1308,7 @@ int BKE_write_ibuf(Scene *scene, ImBuf *ibuf, char *name, int imtype, int subimt
        
        BLI_make_existing_file(name);
 
-       if(scene->r.scemode & R_STAMP_INFO)
+       if(scene->r.stamp & R_STAMP_ALL)
                BKE_stamp_info(scene, ibuf);
        
        ok = IMB_saveiff(ibuf, name, IB_rect | IB_zbuf | IB_zbuffloat);
index 23da5c6..5983368 100644 (file)
@@ -204,17 +204,17 @@ Scene *add_scene(char *name)
        sce= alloc_libblock(&G.main->scene, ID_SCE, name);
        sce->lay= 1;
        
-       sce->r.mode= R_GAMMA;
+       sce->r.mode= R_GAMMA|R_OSA|R_SHADOW|R_SSS|R_ENVMAP|R_RAYTRACE;
        sce->r.cfra= 1;
        sce->r.sfra= 1;
        sce->r.efra= 250;
-       sce->r.xsch= 320;
-       sce->r.ysch= 256;
+       sce->r.xsch= 1920;
+       sce->r.ysch= 1080;
        sce->r.xasp= 1;
        sce->r.yasp= 1;
-       sce->r.xparts= 4;
-       sce->r.yparts= 4;
-       sce->r.size= 100;
+       sce->r.xparts= 8;
+       sce->r.yparts= 8;
+       sce->r.size= 25;
        sce->r.planes= 24;
        sce->r.quality= 90;
        sce->r.framapto= 100;
@@ -225,7 +225,7 @@ Scene *add_scene(char *name)
        sce->r.ocres = 128;
        
        sce->r.bake_mode= 1;    /* prevent to include render stuff here */
-       sce->r.bake_filter= 2;
+       sce->r.bake_filter= 8;
        sce->r.bake_osa= 5;
        sce->r.bake_flag= R_BAKE_CLEAR;
        sce->r.bake_normal_space= R_BAKE_SPACE_TANGENT;
@@ -234,6 +234,9 @@ Scene *add_scene(char *name)
        sce->r.yplay= 480;
        sce->r.freqplay= 60;
        sce->r.depth= 32;
+
+       sce->r.scemode= R_DOCOMP|R_DOSEQ|R_EXTENSION;
+       sce->r.stamp= R_STAMP_TIME|R_STAMP_FRAME|R_STAMP_DATE|R_STAMP_SCENE|R_STAMP_CAMERA;
        
        sce->r.threads= 1;
        
index c8d9592..3eeecd9 100644 (file)
@@ -2017,7 +2017,8 @@ static void do_build_seq_ibuf(Scene *scene, Sequence * seq, TStripElem *se, int
                RenderResult rres;
                int doseq, rendering= G.rendering;
                char scenename[64];
-               int sce_valid =sce&& (sce->camera || sce->r.scemode & R_DOSEQ);
+               int have_seq= (sce->r.scemode & R_DOSEQ) && sce->ed && sce->ed->seqbase.first;
+               int sce_valid =sce && (sce->camera || have_seq);
                        
                if (se->ibuf == NULL && sce_valid && !build_proxy_run) {
                        se->ibuf = seq_proxy_fetch(scene, seq, cfra, render_size);
@@ -2038,7 +2039,7 @@ static void do_build_seq_ibuf(Scene *scene, Sequence * seq, TStripElem *se, int
                } else if (se->ibuf==NULL && sce_valid) {
                        /* no need to display a waitcursor on sequencer
                           scene strips */
-                       if (!(sce->r.scemode & R_DOSEQ)) 
+                       if (!have_seq)
                                waitcursor(1);
                        
                        /* Hack! This function can be called from do_render_seq(), in that case
@@ -2093,7 +2094,7 @@ static void do_build_seq_ibuf(Scene *scene, Sequence * seq, TStripElem *se, int
                        // XXX
 #if 0
                        if((G.f & G_PLAYANIM)==0 /* bad, is set on do_render_seq */
-                          && !(sce->r.scemode & R_DOSEQ)
+                          && !have_seq
                           && !build_proxy_run) 
 #endif
                        
index f84bd69..cfbe3f6 100644 (file)
@@ -40,6 +40,7 @@
 #include "BLI_blenlib.h"
 
 #include "BKE_global.h"
+#include "BKE_utildefines.h"
 #include "BKE_writeavi.h"
 #include "AVI_avi.h"
 
@@ -87,7 +88,7 @@ bMovieHandle *BKE_get_movie_handle(int imtype)
        }
 #endif
 #ifdef WITH_FFMPEG
-       if (imtype == R_FFMPEG) {
+       if (ELEM4(imtype, R_FFMPEG, R_H264, R_XVID, R_THEORA)) {
                mh.start_movie = start_ffmpeg;
                mh.append_movie = append_ffmpeg;
                mh.end_movie = end_ffmpeg;
index 25dc6fa..5e3c802 100644 (file)
@@ -937,5 +937,322 @@ void end_ffmpeg(void)
                img_convert_ctx = 0;
        }
 }
+
+/* properties */
+
+void ffmpeg_property_del(RenderData *rd, void *type, void *prop_)
+{
+       struct IDProperty *prop = (struct IDProperty *) prop_;
+       IDProperty * group;
+       
+       if (!rd->ffcodecdata.properties) {
+               return;
+       }
+
+       group = IDP_GetPropertyFromGroup(
+               rd->ffcodecdata.properties, (char*) type);
+       if (group && prop) {
+               IDP_RemFromGroup(group, prop);
+               IDP_FreeProperty(prop);
+               MEM_freeN(prop);
+       }
+}
+
+IDProperty *ffmpeg_property_add(RenderData *rd, char * type, int opt_index, int parent_index)
+{
+       AVCodecContext c;
+       const AVOption * o;
+       const AVOption * parent;
+       IDProperty * group;
+       IDProperty * prop;
+       IDPropertyTemplate val;
+       int idp_type;
+       char name[256];
+
+       avcodec_get_context_defaults(&c);
+
+       o = c.av_class->option + opt_index;
+       parent = c.av_class->option + parent_index;
+
+       if (!rd->ffcodecdata.properties) {
+               IDPropertyTemplate val;
+
+               rd->ffcodecdata.properties 
+                       = IDP_New(IDP_GROUP, val, "ffmpeg"); 
+       }
+
+       group = IDP_GetPropertyFromGroup(
+               rd->ffcodecdata.properties, (char*) type);
+       
+       if (!group) {
+               IDPropertyTemplate val;
+               
+               group = IDP_New(IDP_GROUP, val, (char*) type); 
+               IDP_AddToGroup(rd->ffcodecdata.properties, group);
+       }
+
+       if (parent_index) {
+               sprintf(name, "%s:%s", parent->name, o->name);
+       } else {
+               strcpy(name, o->name);
+       }
+
+       fprintf(stderr, "ffmpeg_property_add: %s %d %d %s\n",
+               type, parent_index, opt_index, name);
+
+       prop = IDP_GetPropertyFromGroup(group, name);
+       if (prop) {
+               return prop;
+       }
+
+       switch (o->type) {
+       case FF_OPT_TYPE_INT:
+       case FF_OPT_TYPE_INT64:
+               val.i = o->default_val;
+               idp_type = IDP_INT;
+               break;
+       case FF_OPT_TYPE_DOUBLE:
+       case FF_OPT_TYPE_FLOAT:
+               val.f = o->default_val;
+               idp_type = IDP_FLOAT;
+               break;
+       case FF_OPT_TYPE_STRING:
+               val.str = "                                                                               ";
+               idp_type = IDP_STRING;
+               break;
+       case FF_OPT_TYPE_CONST:
+               val.i = 1;
+               idp_type = IDP_INT;
+               break;
+       default:
+               return NULL;
+       }
+       prop = IDP_New(idp_type, val, name);
+       IDP_AddToGroup(group, prop);
+       return prop;
+}
+
+/* not all versions of ffmpeg include that, so here we go ... */
+
+static const AVOption *my_av_find_opt(void *v, const char *name, 
+                                     const char *unit, int mask, int flags){
+       AVClass *c= *(AVClass**)v; 
+       const AVOption *o= c->option;
+
+       for(;o && o->name; o++){
+               if(!strcmp(o->name, name) && 
+                  (!unit || (o->unit && !strcmp(o->unit, unit))) && 
+                  (o->flags & mask) == flags )
+                       return o;
+       }
+       return NULL;
+}
+
+int ffmpeg_property_add_string(RenderData *rd, const char * type, const char * str)
+{
+       AVCodecContext c;
+       const AVOption * o = 0;
+       const AVOption * p = 0;
+       char name_[128];
+       char * name;
+       char * param;
+       IDProperty * prop;
+       
+       avcodec_get_context_defaults(&c);
+
+       strncpy(name_, str, 128);
+
+       name = name_;
+       while (*name == ' ') name++;
+
+       param = strchr(name, ':');
+
+       if (!param) {
+               param = strchr(name, ' ');
+       }
+       if (param) {
+               *param++ = 0;
+               while (*param == ' ') param++;
+       }
+       
+       o = my_av_find_opt(&c, name, NULL, 0, 0);       
+       if (!o) {
+               return 0;
+       }
+       if (param && o->type == FF_OPT_TYPE_CONST) {
+               return 0;
+       }
+       if (param && o->type != FF_OPT_TYPE_CONST && o->unit) {
+               p = my_av_find_opt(&c, param, o->unit, 0, 0);   
+               prop = ffmpeg_property_add(rd,
+                       (char*) type, p - c.av_class->option, 
+                       o - c.av_class->option);
+       } else {
+               prop = ffmpeg_property_add(rd,
+                       (char*) type, o - c.av_class->option, 0);
+       }
+               
+
+       if (!prop) {
+               return 0;
+       }
+
+       if (param && !p) {
+               switch (prop->type) {
+               case IDP_INT:
+                       IDP_Int(prop) = atoi(param);
+                       break;
+               case IDP_FLOAT:
+                       IDP_Float(prop) = atof(param);
+                       break;
+               case IDP_STRING:
+                       strncpy(IDP_String(prop), param, prop->len);
+                       break;
+               }
+       }
+       return 1;
+}
+
+void ffmpeg_set_preset(RenderData *rd, int preset)
+{
+       int isntsc = (rd->frs_sec != 25);
+
+       switch (preset) {
+       case FFMPEG_PRESET_VCD:
+               rd->ffcodecdata.type = FFMPEG_MPEG1;
+               rd->ffcodecdata.video_bitrate = 1150;
+               rd->xsch = 352;
+               rd->ysch = isntsc ? 240 : 288;
+               rd->ffcodecdata.gop_size = isntsc ? 18 : 15;
+               rd->ffcodecdata.rc_max_rate = 1150;
+               rd->ffcodecdata.rc_min_rate = 1150;
+               rd->ffcodecdata.rc_buffer_size = 40*8;
+               rd->ffcodecdata.mux_packet_size = 2324;
+               rd->ffcodecdata.mux_rate = 2352 * 75 * 8;
+               break;
+
+       case FFMPEG_PRESET_SVCD:
+               rd->ffcodecdata.type = FFMPEG_MPEG2;
+               rd->ffcodecdata.video_bitrate = 2040;
+               rd->xsch = 480;
+               rd->ysch = isntsc ? 480 : 576;
+               rd->ffcodecdata.gop_size = isntsc ? 18 : 15;
+               rd->ffcodecdata.rc_max_rate = 2516;
+               rd->ffcodecdata.rc_min_rate = 0;
+               rd->ffcodecdata.rc_buffer_size = 224*8;
+               rd->ffcodecdata.mux_packet_size = 2324;
+               rd->ffcodecdata.mux_rate = 0;
+               break;
+
+       case FFMPEG_PRESET_DVD:
+               rd->ffcodecdata.type = FFMPEG_MPEG2;
+               rd->ffcodecdata.video_bitrate = 6000;
+               rd->xsch = 720;
+               rd->ysch = isntsc ? 480 : 576;
+               rd->ffcodecdata.gop_size = isntsc ? 18 : 15;
+               rd->ffcodecdata.rc_max_rate = 9000;
+               rd->ffcodecdata.rc_min_rate = 0;
+               rd->ffcodecdata.rc_buffer_size = 224*8;
+               rd->ffcodecdata.mux_packet_size = 2048;
+               rd->ffcodecdata.mux_rate = 10080000;
+               break;
+
+       case FFMPEG_PRESET_DV:
+               rd->ffcodecdata.type = FFMPEG_DV;
+               rd->xsch = 720;
+               rd->ysch = isntsc ? 480 : 576;
+               break;
+
+       case FFMPEG_PRESET_H264:
+               rd->ffcodecdata.type = FFMPEG_AVI;
+               rd->ffcodecdata.codec = CODEC_ID_H264;
+               rd->ffcodecdata.video_bitrate = 6000;
+               rd->ffcodecdata.gop_size = isntsc ? 18 : 15;
+               rd->ffcodecdata.rc_max_rate = 9000;
+               rd->ffcodecdata.rc_min_rate = 0;
+               rd->ffcodecdata.rc_buffer_size = 224*8;
+               rd->ffcodecdata.mux_packet_size = 2048;
+               rd->ffcodecdata.mux_rate = 10080000;
+
+               ffmpeg_property_add_string(rd, "video", "coder:vlc");
+               ffmpeg_property_add_string(rd, "video", "flags:loop");
+               ffmpeg_property_add_string(rd, "video", "cmp:chroma");
+               ffmpeg_property_add_string(rd, "video", "partitions:parti4x4");
+               ffmpeg_property_add_string(rd, "video", "partitions:partp8x8");
+               ffmpeg_property_add_string(rd, "video", "partitions:partb8x8");
+               ffmpeg_property_add_string(rd, "video", "me:hex");
+               ffmpeg_property_add_string(rd, "video", "subq:5");
+               ffmpeg_property_add_string(rd, "video", "me_range:16");
+               ffmpeg_property_add_string(rd, "video", "keyint_min:25");
+               ffmpeg_property_add_string(rd, "video", "sc_threshold:40");
+               ffmpeg_property_add_string(rd, "video", "i_qfactor:0.71");
+               ffmpeg_property_add_string(rd, "video", "b_strategy:1");
+
+               break;
+
+       case FFMPEG_PRESET_THEORA:
+       case FFMPEG_PRESET_XVID:
+               if(preset == FFMPEG_PRESET_XVID) {
+                       rd->ffcodecdata.type = FFMPEG_AVI;
+                       rd->ffcodecdata.codec = CODEC_ID_XVID;
+               }
+               else if(preset == FFMPEG_PRESET_THEORA) {
+                       rd->ffcodecdata.type = FFMPEG_OGG; // XXX broken
+                       rd->ffcodecdata.codec = CODEC_ID_THEORA;
+               }
+
+               rd->ffcodecdata.video_bitrate = 6000;
+               rd->ffcodecdata.gop_size = isntsc ? 18 : 15;
+               rd->ffcodecdata.rc_max_rate = 9000;
+               rd->ffcodecdata.rc_min_rate = 0;
+               rd->ffcodecdata.rc_buffer_size = 224*8;
+               rd->ffcodecdata.mux_packet_size = 2048;
+               rd->ffcodecdata.mux_rate = 10080000;
+               break;
+
+       }
+}
+
+void ffmpeg_verify_image_type(RenderData *rd)
+{
+       int audio= 0;
+
+       if(rd->imtype == R_FFMPEG) {
+               if(rd->ffcodecdata.type <= 0 ||
+                  rd->ffcodecdata.codec <= 0 ||
+                  rd->ffcodecdata.audio_codec <= 0 ||
+                  rd->ffcodecdata.video_bitrate <= 1) {
+
+                       rd->ffcodecdata.codec = CODEC_ID_MPEG2VIDEO;
+                       ffmpeg_set_preset(rd, FFMPEG_PRESET_DVD);
+               }
+
+               audio= 1;
+       }
+       else if(rd->imtype == R_H264) {
+               if(rd->ffcodecdata.codec != CODEC_ID_H264) {
+                       ffmpeg_set_preset(rd, FFMPEG_PRESET_H264);
+                       audio= 1;
+               }
+       }
+       else if(rd->imtype == R_XVID) {
+               if(rd->ffcodecdata.codec != CODEC_ID_XVID) {
+                       ffmpeg_set_preset(rd, FFMPEG_PRESET_XVID);
+                       audio= 1;
+               }
+       }
+       else if(rd->imtype == R_THEORA) {
+               if(rd->ffcodecdata.codec != CODEC_ID_THEORA) {
+                       ffmpeg_set_preset(rd, FFMPEG_PRESET_THEORA);
+                       audio= 1;
+               }
+       }
+
+       if(audio && rd->ffcodecdata.audio_codec <= 0) {
+               rd->ffcodecdata.audio_codec = CODEC_ID_MP2;
+               rd->ffcodecdata.audio_bitrate = 128;
+       }
+}
+
 #endif
 
index 21e173b..06092cc 100644 (file)
@@ -9098,7 +9098,9 @@ static void do_versions(FileData *fd, Library *lib, Main *main)
        if (main->versionfile < 250) {
                bScreen *screen;
                Scene *scene;
+               Base *base;
                Material *ma;
+               Camera *cam;
                Mesh *me;
                Scene *sce;
                Tex *tx;
@@ -9132,6 +9134,20 @@ static void do_versions(FileData *fd, Library *lib, Main *main)
                for(sce= main->scene.first; sce; sce= sce->id.next) {
                        if(sce->nodetree && strlen(sce->nodetree->id.name)==0)
                                strcpy(sce->nodetree->id.name, "NTComposit Nodetree");
+
+                       /* move to cameras */
+                       if(sce->r.scemode & R_PANORAMA) {
+                               for(base=scene->base.first; base; base=base->next) {
+                                       ob= newlibadr(fd, lib, base->object);
+
+                                       if(ob->type == OB_CAMERA && !ob->id.lib) {
+                                               cam= newlibadr(fd, lib, ob->data);
+                                               cam->flag |= CAM_PANORAMA;
+                                       }
+                               }
+
+                               sce->r.scemode &= ~R_PANORAMA;
+                       }
                }
                /* and texture trees */
                for(tx= main->tex.first; tx; tx= tx->id.next) {
index 7fa0bf6..284da29 100644 (file)
@@ -466,13 +466,18 @@ static uiBut *ui_item_with_label(uiLayout *layout, uiBlock *block, char *name, i
        uiLayout *sub;
        uiBut *but;
        PropertySubType subtype;
+       int labelw;
 
        sub= uiLayoutRow(layout, 0);
        uiBlockSetCurLayout(block, sub);
 
        if(strcmp(name, "") != 0) {
-               w= w/2;
-               uiDefBut(block, LABEL, 0, name, x, y, w, h, NULL, 0.0, 0.0, 0, 0, "");
+               /* XXX UI_GetStringWidth is not accurate
+               labelw= UI_GetStringWidth(name);
+               CLAMP(labelw, w/4, 3*w/4);*/
+               labelw= w/2;
+               uiDefBut(block, LABEL, 0, name, x, y, labelw, h, NULL, 0.0, 0.0, 0, 0, "");
+               w= w-labelw;
        }
 
        subtype= RNA_property_subtype(prop);
index edde575..c1129db 100644 (file)
@@ -374,8 +374,10 @@ ARegion *ui_tooltip_create(bContext *C, ARegion *butregion, uiBut *but)
        if(ELEM3(but->type, TEX, IDPOIN, SEARCH_MENU)) {
                /* full string */
                ui_get_but_string(but, buf, sizeof(buf));
-               BLI_snprintf(data->lines[data->totline], sizeof(data->lines[0]), "Value: %s", buf);
-               data->totline++;
+               if(buf[0]) {
+                       BLI_snprintf(data->lines[data->totline], sizeof(data->lines[0]), "Value: %s", buf);
+                       data->totline++;
+               }
        }
 
        if(but->rnaprop) {
index c3b68eb..113e724 100644 (file)
@@ -2320,6 +2320,40 @@ static ScrArea *find_area_showing_r_result(bContext *C)
        return sa;
 }
 
+static ScrArea *find_area_image_empty(bContext *C)
+{
+       bScreen *sc= CTX_wm_screen(C);
+       ScrArea *sa;
+       SpaceImage *sima;
+       
+       /* find an imagewindow showing render result */
+       for(sa=sc->areabase.first; sa; sa= sa->next) {
+               if(sa->spacetype==SPACE_IMAGE) {
+                       sima= sa->spacedata.first;
+                       if(!sima->image)
+                               break;
+               }
+       }
+       return sa;
+}
+
+static ScrArea *find_empty_image_area(bContext *C)
+{
+       bScreen *sc= CTX_wm_screen(C);
+       ScrArea *sa;
+       SpaceImage *sima;
+       
+       /* find an imagewindow showing render result */
+       for(sa=sc->areabase.first; sa; sa= sa->next) {
+               if(sa->spacetype==SPACE_IMAGE) {
+                       sima= sa->spacedata.first;
+                       if(!sima->image)
+                               break;
+               }
+       }
+       return sa;
+}
+
 static void screen_set_image_output(bContext *C)
 {
        Scene *scene= CTX_data_scene(C);
@@ -2334,6 +2368,8 @@ static void screen_set_image_output(bContext *C)
        else {
        
                sa= find_area_showing_r_result(C);
+               if(sa==NULL)
+                       sa= find_area_image_empty(C);
                
                if(sa==NULL) {
                        /* find largest open non-image area */
index f16a232..f09f355 100644 (file)
@@ -80,5 +80,8 @@ void PARTICLE_OT_remove_keyed_target(struct wmOperatorType *ot);
 void PARTICLE_OT_keyed_target_move_up(struct wmOperatorType *ot);
 void PARTICLE_OT_keyed_target_move_down(struct wmOperatorType *ot);
 
+void SCENE_OT_render_layer_add(struct wmOperatorType *ot);
+void SCENE_OT_render_layer_remove(struct wmOperatorType *ot);
+
 #endif /* ED_BUTTONS_INTERN_H */
 
index 6fb52c6..fb1e9d1 100644 (file)
@@ -33,6 +33,7 @@
 #include "DNA_curve_types.h"
 #include "DNA_object_types.h"
 #include "DNA_material_types.h"
+#include "DNA_node_types.h"
 #include "DNA_texture_types.h"
 #include "DNA_scene_types.h"
 #include "DNA_world_types.h"
@@ -43,7 +44,9 @@
 #include "BKE_library.h"
 #include "BKE_main.h"
 #include "BKE_material.h"
+#include "BKE_node.h"
 #include "BKE_particle.h"
+#include "BKE_scene.h"
 #include "BKE_texture.h"
 #include "BKE_utildefines.h"
 #include "BKE_world.h"
@@ -689,3 +692,74 @@ void PARTICLE_OT_keyed_target_move_down(wmOperatorType *ot)
        ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
 }
 
+/********************** render layer operators *********************/
+
+static int render_layer_add_exec(bContext *C, wmOperator *op)
+{
+       Scene *scene= CTX_data_scene(C);
+
+       scene_add_render_layer(scene);
+       scene->r.actlay= BLI_countlist(&scene->r.layers) - 1;
+
+       WM_event_add_notifier(C, NC_SCENE|ND_RENDER_OPTIONS, scene);
+       
+       return OPERATOR_FINISHED;
+}
+
+void SCENE_OT_render_layer_add(wmOperatorType *ot)
+{
+       /* identifiers */
+       ot->name= "Add Render Layer";
+       ot->idname= "SCENE_OT_render_layer_add";
+       
+       /* api callbacks */
+       ot->exec= render_layer_add_exec;
+
+       /* flags */
+       ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
+}
+
+static int render_layer_remove_exec(bContext *C, wmOperator *op)
+{
+       Scene *scene= CTX_data_scene(C);
+       SceneRenderLayer *rl;
+       int act= scene->r.actlay;
+
+       if(BLI_countlist(&scene->r.layers) <= 1)
+               return OPERATOR_CANCELLED;
+       
+       rl= BLI_findlink(&scene->r.layers, scene->r.actlay);
+       BLI_remlink(&scene->r.layers, rl);
+       MEM_freeN(rl);
+
+       scene->r.actlay= 0;
+       
+       if(scene->nodetree) {
+               bNode *node;
+               for(node= scene->nodetree->nodes.first; node; node= node->next) {
+                       if(node->type==CMP_NODE_R_LAYERS && node->id==NULL) {
+                               if(node->custom1==act)
+                                       node->custom1= 0;
+                               else if(node->custom1>act)
+                                       node->custom1--;
+                       }
+               }
+       }
+
+       WM_event_add_notifier(C, NC_SCENE|ND_RENDER_OPTIONS, scene);
+       
+       return OPERATOR_FINISHED;
+}
+
+void SCENE_OT_render_layer_remove(wmOperatorType *ot)
+{
+       /* identifiers */
+       ot->name= "Remove Render Layer";
+       ot->idname= "SCENE_OT_render_layer_remove";
+       
+       /* api callbacks */
+       ot->exec= render_layer_remove_exec;
+
+       /* flags */
+       ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
+}
index 6cdb4db..17f55c9 100644 (file)
@@ -228,6 +228,9 @@ void buttons_operatortypes(void)
        WM_operatortype_append(PARTICLE_OT_remove_keyed_target);
        WM_operatortype_append(PARTICLE_OT_keyed_target_move_up);
        WM_operatortype_append(PARTICLE_OT_keyed_target_move_down);
+
+       WM_operatortype_append(SCENE_OT_render_layer_add);
+       WM_operatortype_append(SCENE_OT_render_layer_remove);
 }
 
 void buttons_keymap(struct wmWindowManager *wm)
index 2589095..ac15ed9 100644 (file)
@@ -153,6 +153,9 @@ void save_image_filesel_str(Scene *scene, char *str)
                        strcpy(str, "Save Radiance HDR");
                        break;
                case R_FFMPEG:
+               case R_H264:
+               case R_XVID:
+               case R_THEORA:
                case R_PNG:
                        strcpy(str, "Save PNG");
                        break;
index 7a504ef..8ba7fa8 100644 (file)
@@ -79,6 +79,7 @@ typedef struct Camera {
 #define CAM_SHOWNAME           16
 #define CAM_ANGLETOGGLE                32
 #define CAM_DS_EXPAND          64
+#define CAM_PANORAMA           128
 
 /* yafray: dof sampling switch */
 #define CAM_YF_NO_QMC  512
index c71aa81..7a6cbce 100644 (file)
@@ -635,7 +635,7 @@ typedef struct Scene {
 #define R_FIELDSTILL   0x0080
 #define R_RADIO                        0x0100
 #define R_BORDER               0x0200
-#define R_PANORAMA             0x0400
+#define R_PANORAMA             0x0400  /* deprecated as scene option, still used in renderer */
 #define R_CROP                 0x0800
 #define R_COSMO                        0x1000
 #define R_ODDFIELD             0x2000
@@ -694,7 +694,7 @@ typedef struct Scene {
 #define R_COMP_FREE                    0x0800
 #define R_NO_IMAGE_LOAD                0x1000
 #define R_NO_TEX                       0x2000
-#define R_STAMP_INFO           0x4000
+#define R_STAMP_INFO           0x4000  /* deprecated */
 #define R_FULL_SAMPLE          0x8000
 #define R_COMP_RERENDER                0x10000
 #define R_RECURS_PROTECTION     0x20000
@@ -710,6 +710,7 @@ typedef struct Scene {
 #define R_STAMP_MARKER 0x0080
 #define R_STAMP_FILENAME       0x0100
 #define R_STAMP_SEQSTRIP       0x0200
+#define R_STAMP_ALL            (R_STAMP_TIME|R_STAMP_FRAME|R_STAMP_DATE|R_STAMP_CAMERA|R_STAMP_SCENE|R_STAMP_NOTE|R_STAMP_MARKER|R_STAMP_FILENAME|R_STAMP_SEQSTRIP)
 
 /* alphamode */
 #define R_ADDSKY               0
@@ -746,6 +747,9 @@ typedef struct Scene {
 #define R_MULTILAYER   28
 #define R_DDS                  29
 #define R_JP2                  30
+#define R_H264         31
+#define R_XVID         32
+#define R_THEORA               33
 
 /* subimtype, flag options for imtype */
 #define R_OPENEXR_HALF 1
index 967636f..8911885 100644 (file)
@@ -9,4 +9,28 @@ objs += o
 incs = '#/intern/guardedalloc ../blenkernel ../blenlib ../makesdna intern .'
 incs += ' ../windowmanager ../editors/include ../imbuf'
 
-env.BlenderLib ( 'bf_rna', objs, Split(incs), [], libtype=['core'], priority = [195] )
+defs = []
+
+if env['WITH_BF_OPENEXR']:
+       defs.append('WITH_OPENEXR')
+
+if env['WITH_BF_OPENJPEG']:
+       defs.append('WITH_OPENJPEG')
+
+if env['WITH_BF_DDS']:
+       defs.append('WITH_DDS')
+
+if env['WITH_BF_FFMPEG']:
+       defs.append('WITH_FFMPEG')
+       incs += ' ' + env['BF_FFMPEG_INC']
+
+if env['WITH_BF_OGG']:
+       defs.append('WITH_OGG')
+
+if env['WITH_BF_QUICKTIME']:
+       defs.append('WITH_QUICKTIME')
+
+if env['WITH_BF_LCMS']:
+       defs.append('WITH_LCMS')
+
+env.BlenderLib ( 'bf_rna', objs, Split(incs), defines=defs, libtype=['core'], priority = [195] )
index 3400b69..85505d5 100644 (file)
@@ -59,6 +59,7 @@ IF(WITH_QUICKTIME)
 ENDIF(WITH_QUICKTIME)
 
 IF(WITH_FFMPEG)
+  SET(INC ${INC} ${FFMPEG_INC})
   ADD_DEFINITIONS(-DWITH_FFMPEG)
 ENDIF(WITH_FFMPEG)
 
index 1694e55..7f9bfbf 100644 (file)
@@ -57,6 +57,7 @@ CPPFLAGS += -I.
 
 ifeq ($(WITH_FFMPEG),true)
     CPPFLAGS += -DWITH_FFMPEG
+    CPPFLAGS += $(NAN_FFMPEGCFLAGS)
 endif
 
 ifeq ($(WITH_OPENEXR), true)
index 03f0afd..7cd3fde 100644 (file)
@@ -29,6 +29,10 @@ makesrna_tool.Append(CCFLAGS = '-DBASE_HEADER="\\"source/blender/makesrna/\\"" '
 
 defs = []
 
+incs = '#/intern/guardedalloc ../../blenlib ../../blenkernel'
+incs += ' ../../imbuf ../../makesdna ../../makesrna'
+incs += ' ../../windowmanager ../../editors/include'
+
 if env['WITH_BF_OPENEXR']:
        defs.append('WITH_OPENEXR')
 
@@ -40,6 +44,10 @@ if env['WITH_BF_DDS']:
 
 if env['WITH_BF_FFMPEG']:
        defs.append('WITH_FFMPEG')
+       incs += ' ' + env['BF_FFMPEG_INC']
+
+if env['WITH_BF_OGG']:
+       defs.append('WITH_OGG')
 
 if env['WITH_BF_QUICKTIME']:
        defs.append('WITH_QUICKTIME')
@@ -49,14 +57,7 @@ if env['WITH_BF_LCMS']:
 
 makesrna_tool.Append(CPPDEFINES=defs)
 
-makesrna_tool.Append (CPPPATH = ['#/intern/guardedalloc',
-                                                                '../../blenlib',
-                                                                '../../blenkernel',
-                                                                '../../imbuf',
-                                                                '../../makesdna',
-                                                                '../../makesrna',
-                                                                '../../windowmanager',
-                                                                '../../editors/include'])
+makesrna_tool.Append (CPPPATH = Split(incs))
 
 if env['OURPLATFORM'] == 'linuxcross':
        USE_WINE = True # when cross compiling on linux 64bit this is useful
index 4814f95..9c33b0a 100644 (file)
@@ -153,6 +153,11 @@ void RNA_def_camera(BlenderRNA *brna)
        RNA_def_property_enum_items(prop, prop_lens_unit_items);
        RNA_def_property_ui_text(prop, "Lens Unit", "Unit to edit lens in for the user interface.");
 
+       prop= RNA_def_property(srna, "panorama", PROP_BOOLEAN, PROP_NONE);
+       RNA_def_property_boolean_sdna(prop, NULL, "flag", CAM_PANORAMA);
+       RNA_def_property_ui_text(prop, "Panorama", "Render the scene with a cylindrical camera for pseudo-fisheye lens effects.");
+       RNA_def_property_update(prop, NC_OBJECT|ND_DRAW, NULL);
+
        /* pointers */
        rna_def_animdata_common(srna);
 
index 6e2a6e2..9c9fbf0 100644 (file)
 
 #include "DNA_scene_types.h"
 
-/*
+#ifdef WITH_FFMPEG
 #include "BKE_writeffmpeg.h"
 #include <libavcodec/avcodec.h> 
 #include <libavformat/avformat.h>
-*/
+#endif
 
 #include "WM_types.h"
 
@@ -52,8 +52,13 @@ EnumPropertyItem prop_mode_items[] ={
 
 #ifdef RNA_RUNTIME
 
+#include "DNA_node_types.h"
+
 #include "BKE_context.h"
 #include "BKE_global.h"
+#include "BKE_node.h"
+
+#include "BLI_threads.h"
 
 PointerRNA rna_Scene_objects_get(CollectionPropertyIterator *iter)
 {
@@ -63,9 +68,8 @@ PointerRNA rna_Scene_objects_get(CollectionPropertyIterator *iter)
        return rna_pointer_inherit_refine(&iter->parent, &RNA_Object, ((Base*)internal->link)->object);
 }
 
-static void rna_Scene_layer_set(PointerRNA *ptr, const int *values)
+static int layer_set(int lay, const int *values)
 {
-       Scene *scene= (Scene*)ptr->data;
        int i, tot= 0;
 
        /* ensure we always have some layer selected */
@@ -74,12 +78,21 @@ static void rna_Scene_layer_set(PointerRNA *ptr, const int *values)
                        tot++;
        
        if(tot==0)
-               return;
+               return lay;
 
        for(i=0; i<20; i++) {
-               if(values[i]) scene->lay |= (1<<i);
-               else scene->lay &= ~(1<<i);
+               if(values[i]) lay |= (1<<i);
+               else lay &= ~(1<<i);
        }
+
+       return lay;
+}
+
+static void rna_Scene_layer_set(PointerRNA *ptr, const int *values)
+{
+       Scene *scene= (Scene*)ptr->data;
+
+       scene->lay= layer_set(scene->lay, values);
 }
 
 static void rna_Scene_start_frame_set(PointerRNA *ptr, int value)
@@ -102,6 +115,92 @@ static void rna_Scene_frame_update(bContext *C, PointerRNA *ptr)
        //update_for_newframe();
 }
 
+static int rna_SceneRenderData_threads_get(PointerRNA *ptr)
+{
+       RenderData *rd= (RenderData*)ptr->data;
+
+       if(rd->mode & R_FIXED_THREADS)
+               return rd->threads;
+       else
+               return BLI_system_thread_count();
+}
+
+static int rna_SceneRenderData_save_buffers_get(PointerRNA *ptr)
+{
+       RenderData *rd= (RenderData*)ptr->data;
+
+       return (rd->scemode & (R_EXR_TILE_FILE|R_FULL_SAMPLE)) != 0;
+}
+
+static void rna_SceneRenderData_file_format_set(PointerRNA *ptr, int value)
+{
+       RenderData *rd= (RenderData*)ptr->data;
+
+       rd->imtype= value;
+       ffmpeg_verify_image_type(rd);
+}
+
+static int rna_SceneRenderData_active_layer_index_get(PointerRNA *ptr)
+{
+       RenderData *rd= (RenderData*)ptr->data;
+       return rd->actlay;
+}
+
+static void rna_SceneRenderData_active_layer_index_set(PointerRNA *ptr, int value)
+{
+       RenderData *rd= (RenderData*)ptr->data;
+       rd->actlay= value;
+}
+
+static void rna_SceneRenderData_active_layer_index_range(PointerRNA *ptr, int *min, int *max)
+{
+       RenderData *rd= (RenderData*)ptr->data;
+
+       *min= 0;
+       *max= BLI_countlist(&rd->layers)-1;
+       *max= MAX2(0, *max);
+}
+
+static void rna_SceneRenderLayer_name_set(PointerRNA *ptr, const char *value)
+{
+       Scene *scene= (Scene*)ptr->id.data;
+       SceneRenderLayer *rl= (SceneRenderLayer*)ptr->data;
+
+    BLI_strncpy(rl->name, value, sizeof(rl->name));
+
+       if(scene->nodetree) {
+               bNode *node;
+               int index= BLI_findindex(&scene->r.layers, rl);
+
+               for(node= scene->nodetree->nodes.first; node; node= node->next) {
+                       if(node->type==CMP_NODE_R_LAYERS && node->id==NULL) {
+                               if(node->custom1==index)
+                                       BLI_strncpy(node->name, rl->name, NODE_MAXSTR);
+                       }
+               }
+       }
+}
+
+static void rna_SceneRenderLayer_layer_set(PointerRNA *ptr, const int *values)
+{
+       SceneRenderLayer *rl= (SceneRenderLayer*)ptr->data;
+       rl->lay= layer_set(rl->lay, values);
+}
+
+static void rna_SceneRenderLayer_zmask_layer_set(PointerRNA *ptr, const int *values)
+{
+       SceneRenderLayer *rl= (SceneRenderLayer*)ptr->data;
+       rl->lay_zmask= layer_set(rl->lay_zmask, values);
+}
+
+static void rna_SceneRenderLayer_pass_update(bContext *C, PointerRNA *ptr)
+{
+       Scene *scene= (Scene*)ptr->id.data;
+
+       if(scene->nodetree)
+               ntreeCompositForceHidden(scene->nodetree, scene);
+}
+
 #else
 
 void rna_def_sculpt(BlenderRNA  *brna)
@@ -257,6 +356,194 @@ void rna_def_tool_settings(BlenderRNA  *brna)
        rna_def_sculpt(brna);
 }
 
+void rna_def_scene_render_layer(BlenderRNA *brna)
+{
+       StructRNA *srna;
+       PropertyRNA *prop;
+
+       srna= RNA_def_struct(brna, "SceneRenderLayer", NULL);
+       RNA_def_struct_ui_text(srna, "Scene Render Layer", "Render layer.");
+
+       prop= RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
+       RNA_def_property_ui_text(prop, "Name", "Render layer name.");
+       RNA_def_property_string_funcs(prop, NULL, NULL, "rna_SceneRenderLayer_name_set");
+       RNA_def_property_update(prop, NC_SCENE|ND_RENDER_OPTIONS, NULL);
+       RNA_def_struct_name_property(srna, prop);
+
+       prop= RNA_def_property(srna, "material_override", PROP_POINTER, PROP_NONE);
+       RNA_def_property_pointer_sdna(prop, NULL, "mat_override");
+       RNA_def_property_struct_type(prop, "Material");
+       RNA_def_property_flag(prop, PROP_EDITABLE);
+       RNA_def_property_ui_text(prop, "Material Override", "Material to override all other materials in this render layer.");
+       RNA_def_property_update(prop, NC_SCENE|ND_RENDER_OPTIONS, "rna_SceneRenderLayer_pass_update");
+
+       prop= RNA_def_property(srna, "light_override", PROP_POINTER, PROP_NONE);
+       RNA_def_property_struct_type(prop, "Group");
+       RNA_def_property_flag(prop, PROP_EDITABLE);
+       RNA_def_property_ui_text(prop, "Light Override", "Group to override all other lights in this render layer.");
+       RNA_def_property_update(prop, NC_SCENE|ND_RENDER_OPTIONS, "rna_SceneRenderLayer_pass_update");
+
+       /* layers */
+       prop= RNA_def_property(srna, "visible_layers", PROP_BOOLEAN, PROP_NONE);
+       RNA_def_property_boolean_sdna(prop, NULL, "lay", 1);
+       RNA_def_property_array(prop, 20);
+       RNA_def_property_ui_text(prop, "Visible Layers", "Scene layers included in this render layer.");
+       RNA_def_property_boolean_funcs(prop, NULL, "rna_SceneRenderLayer_layer_set");
+
+       prop= RNA_def_property(srna, "zmask_layers", PROP_BOOLEAN, PROP_NONE);
+       RNA_def_property_boolean_sdna(prop, NULL, "lay_zmask", 1);
+       RNA_def_property_array(prop, 20);
+       RNA_def_property_ui_text(prop, "Zmask Layers", "Zmask scene layers.");
+       RNA_def_property_boolean_funcs(prop, NULL, "rna_SceneRenderLayer_zmask_layer_set");
+
+       /* layer options */
+       prop= RNA_def_property(srna, "enabled", PROP_BOOLEAN, PROP_NONE);
+       RNA_def_property_boolean_negative_sdna(prop, NULL, "layflag", SCE_LAY_DISABLE);
+       RNA_def_property_ui_text(prop, "Enabled", "Disable or enable the render layer.");
+       RNA_def_property_update(prop, NC_SCENE|ND_RENDER_OPTIONS, NULL);
+
+       prop= RNA_def_property(srna, "zmask", PROP_BOOLEAN, PROP_NONE);
+       RNA_def_property_boolean_sdna(prop, NULL, "layflag", SCE_LAY_ZMASK);
+       RNA_def_property_ui_text(prop, "Zmask", "Only render what's in front of the solid z values.");
+       RNA_def_property_update(prop, NC_SCENE|ND_RENDER_OPTIONS, NULL);
+
+       prop= RNA_def_property(srna, "zmask_negate", PROP_BOOLEAN, PROP_NONE);
+       RNA_def_property_boolean_sdna(prop, NULL, "layflag", SCE_LAY_NEG_ZMASK);
+       RNA_def_property_ui_text(prop, "Zmask Negate", "For Zmask, only render what is behind solid z values instead of in front.");
+       RNA_def_property_update(prop, NC_SCENE|ND_RENDER_OPTIONS, NULL);
+
+       prop= RNA_def_property(srna, "all_z", PROP_BOOLEAN, PROP_NONE);
+       RNA_def_property_boolean_sdna(prop, NULL, "layflag", SCE_LAY_ALL_Z);
+       RNA_def_property_ui_text(prop, "All Z", "Fill in Z values for solid faces in invisible layers, for masking.");
+       RNA_def_property_update(prop, NC_SCENE|ND_RENDER_OPTIONS, NULL);
+
+       prop= RNA_def_property(srna, "solid", PROP_BOOLEAN, PROP_NONE);
+       RNA_def_property_boolean_sdna(prop, NULL, "layflag", SCE_LAY_SOLID);
+       RNA_def_property_ui_text(prop, "Solid", "Render Solid faces in this Layer.");
+       RNA_def_property_update(prop, NC_SCENE|ND_RENDER_OPTIONS, NULL);
+
+       prop= RNA_def_property(srna, "halo", PROP_BOOLEAN, PROP_NONE);
+       RNA_def_property_boolean_sdna(prop, NULL, "layflag", SCE_LAY_SOLID);
+       RNA_def_property_ui_text(prop, "Halo", "Render Halos in this Layer (on top of Solid).");
+       RNA_def_property_update(prop, NC_SCENE|ND_RENDER_OPTIONS, NULL);
+
+       prop= RNA_def_property(srna, "ztransp", PROP_BOOLEAN, PROP_NONE);
+       RNA_def_property_boolean_sdna(prop, NULL, "layflag", SCE_LAY_SOLID);
+       RNA_def_property_ui_text(prop, "ZTransp", "Render Z-Transparent faces in this Layer (On top of Solid and Halos).");
+       RNA_def_property_update(prop, NC_SCENE|ND_RENDER_OPTIONS, NULL);
+
+       prop= RNA_def_property(srna, "sky", PROP_BOOLEAN, PROP_NONE);
+       RNA_def_property_boolean_sdna(prop, NULL, "layflag", SCE_LAY_SOLID);
+       RNA_def_property_ui_text(prop, "Sky", "Render Sky in this Layer.");
+       RNA_def_property_update(prop, NC_SCENE|ND_RENDER_OPTIONS, NULL);
+
+       prop= RNA_def_property(srna, "edge", PROP_BOOLEAN, PROP_NONE);
+       RNA_def_property_boolean_sdna(prop, NULL, "layflag", SCE_LAY_SOLID);
+       RNA_def_property_ui_text(prop, "Edge", "Render Edge-enhance in this Layer (only works for Solid faces).");
+       RNA_def_property_update(prop, NC_SCENE|ND_RENDER_OPTIONS, NULL);
+
+       prop= RNA_def_property(srna, "strand", PROP_BOOLEAN, PROP_NONE);
+       RNA_def_property_boolean_sdna(prop, NULL, "layflag", SCE_LAY_SOLID);
+       RNA_def_property_ui_text(prop, "Strand", "Render Strands in this Layer.");
+       RNA_def_property_update(prop, NC_SCENE|ND_RENDER_OPTIONS, NULL);
+
+       /* passes */
+       prop= RNA_def_property(srna, "pass_combined", PROP_BOOLEAN, PROP_NONE);
+       RNA_def_property_boolean_sdna(prop, NULL, "passflag", SCE_PASS_COMBINED);
+       RNA_def_property_ui_text(prop, "Combined", "Deliver full combined RGBA buffer.");
+       RNA_def_property_update(prop, NC_SCENE|ND_RENDER_OPTIONS, "rna_SceneRenderLayer_pass_update");
+
+       prop= RNA_def_property(srna, "pass_z", PROP_BOOLEAN, PROP_NONE);
+       RNA_def_property_boolean_sdna(prop, NULL, "passflag", SCE_PASS_Z);
+       RNA_def_property_ui_text(prop, "Z", "Deliver Z values pass.");
+       RNA_def_property_update(prop, NC_SCENE|ND_RENDER_OPTIONS, "rna_SceneRenderLayer_pass_update");
+       
+       prop= RNA_def_property(srna, "pass_vector", PROP_BOOLEAN, PROP_NONE);
+       RNA_def_property_boolean_sdna(prop, NULL, "passflag", SCE_PASS_VECTOR);
+       RNA_def_property_ui_text(prop, "Vector", "Deliver speed vector pass.");
+       RNA_def_property_update(prop, NC_SCENE|ND_RENDER_OPTIONS, "rna_SceneRenderLayer_pass_update");
+
+       prop= RNA_def_property(srna, "pass_normal", PROP_BOOLEAN, PROP_NONE);
+       RNA_def_property_boolean_sdna(prop, NULL, "passflag", SCE_PASS_NORMAL);
+       RNA_def_property_ui_text(prop, "Normal", "Deliver normal pass.");
+       RNA_def_property_update(prop, NC_SCENE|ND_RENDER_OPTIONS, "rna_SceneRenderLayer_pass_update");
+
+       prop= RNA_def_property(srna, "pass_uv", PROP_BOOLEAN, PROP_NONE);
+       RNA_def_property_boolean_sdna(prop, NULL, "passflag", SCE_PASS_UV);
+       RNA_def_property_ui_text(prop, "UV", "Deliver texture UV pass.");
+       RNA_def_property_update(prop, NC_SCENE|ND_RENDER_OPTIONS, "rna_SceneRenderLayer_pass_update");
+
+       prop= RNA_def_property(srna, "pass_mist", PROP_BOOLEAN, PROP_NONE);
+       RNA_def_property_boolean_sdna(prop, NULL, "passflag", SCE_PASS_MIST);
+       RNA_def_property_ui_text(prop, "Mist", "Deliver mist factor pass (0.0-1.0).");
+       RNA_def_property_update(prop, NC_SCENE|ND_RENDER_OPTIONS, "rna_SceneRenderLayer_pass_update");
+
+       prop= RNA_def_property(srna, "pass_object_index", PROP_BOOLEAN, PROP_NONE);
+       RNA_def_property_boolean_sdna(prop, NULL, "passflag", SCE_PASS_INDEXOB);
+       RNA_def_property_ui_text(prop, "Object Index", "Deliver object index pass.");
+       RNA_def_property_update(prop, NC_SCENE|ND_RENDER_OPTIONS, "rna_SceneRenderLayer_pass_update");
+
+       prop= RNA_def_property(srna, "pass_color", PROP_BOOLEAN, PROP_NONE);
+       RNA_def_property_boolean_sdna(prop, NULL, "passflag", SCE_PASS_RGBA);
+       RNA_def_property_ui_text(prop, "Color", "Deliver shade-less color pass.");
+       RNA_def_property_update(prop, NC_SCENE|ND_RENDER_OPTIONS, "rna_SceneRenderLayer_pass_update");
+
+       prop= RNA_def_property(srna, "pass_diffuse", PROP_BOOLEAN, PROP_NONE);
+       RNA_def_property_boolean_sdna(prop, NULL, "passflag", SCE_PASS_DIFFUSE);
+       RNA_def_property_ui_text(prop, "Diffuse", "Deliver diffuse pass.");
+       RNA_def_property_update(prop, NC_SCENE|ND_RENDER_OPTIONS, "rna_SceneRenderLayer_pass_update");
+
+       prop= RNA_def_property(srna, "pass_specular", PROP_BOOLEAN, PROP_NONE);
+       RNA_def_property_boolean_sdna(prop, NULL, "passflag", SCE_PASS_SPEC);
+       RNA_def_property_ui_text(prop, "Specular", "Deliver specular pass.");
+       RNA_def_property_update(prop, NC_SCENE|ND_RENDER_OPTIONS, "rna_SceneRenderLayer_pass_update");
+
+       prop= RNA_def_property(srna, "pass_shadow", PROP_BOOLEAN, PROP_NONE);
+       RNA_def_property_boolean_sdna(prop, NULL, "passflag", SCE_PASS_SHADOW);
+       RNA_def_property_ui_text(prop, "Shadow", "Deliver shadow pass.");
+       RNA_def_property_update(prop, NC_SCENE|ND_RENDER_OPTIONS, "rna_SceneRenderLayer_pass_update");
+
+       prop= RNA_def_property(srna, "pass_ao", PROP_BOOLEAN, PROP_NONE);
+       RNA_def_property_boolean_sdna(prop, NULL, "passflag", SCE_PASS_AO);
+       RNA_def_property_ui_text(prop, "AO", "Deliver AO pass.");
+       RNA_def_property_update(prop, NC_SCENE|ND_RENDER_OPTIONS, "rna_SceneRenderLayer_pass_update");
+       
+       prop= RNA_def_property(srna, "pass_reflection", PROP_BOOLEAN, PROP_NONE);
+       RNA_def_property_boolean_sdna(prop, NULL, "passflag", SCE_PASS_REFLECT);
+       RNA_def_property_ui_text(prop, "Reflection", "Deliver ratraced reflection pass.");
+       RNA_def_property_update(prop, NC_SCENE|ND_RENDER_OPTIONS, "rna_SceneRenderLayer_pass_update");
+
+       prop= RNA_def_property(srna, "pass_refraction", PROP_BOOLEAN, PROP_NONE);
+       RNA_def_property_boolean_sdna(prop, NULL, "passflag", SCE_PASS_REFRACT);
+       RNA_def_property_ui_text(prop, "Refraction", "Deliver ratraced refraction pass.");
+       RNA_def_property_update(prop, NC_SCENE|ND_RENDER_OPTIONS, "rna_SceneRenderLayer_pass_update");
+
+       prop= RNA_def_property(srna, "pass_specular_exclude", PROP_BOOLEAN, PROP_NONE);
+       RNA_def_property_boolean_sdna(prop, NULL, "pass_xor", SCE_PASS_SPEC);
+       RNA_def_property_ui_text(prop, "Specular Exclude", "Exclude specular pass from combined.");
+       RNA_def_property_update(prop, NC_SCENE|ND_RENDER_OPTIONS, "rna_SceneRenderLayer_pass_update");
+
+       prop= RNA_def_property(srna, "pass_shadow_exclude", PROP_BOOLEAN, PROP_NONE);
+       RNA_def_property_boolean_sdna(prop, NULL, "pass_xor", SCE_PASS_SHADOW);
+       RNA_def_property_ui_text(prop, "Shadow Exclude", "Exclude shadow pass from combined.");
+       RNA_def_property_update(prop, NC_SCENE|ND_RENDER_OPTIONS, "rna_SceneRenderLayer_pass_update");
+
+       prop= RNA_def_property(srna, "pass_ao_exclude", PROP_BOOLEAN, PROP_NONE);
+       RNA_def_property_boolean_sdna(prop, NULL, "pass_xor", SCE_PASS_AO);
+       RNA_def_property_ui_text(prop, "AO Exclude", "Exclude AO pass from combined.");
+       RNA_def_property_update(prop, NC_SCENE|ND_RENDER_OPTIONS, "rna_SceneRenderLayer_pass_update");
+       
+       prop= RNA_def_property(srna, "pass_reflection_exclude", PROP_BOOLEAN, PROP_NONE);
+       RNA_def_property_boolean_sdna(prop, NULL, "pass_xor", SCE_PASS_REFLECT);
+       RNA_def_property_ui_text(prop, "Reflection Exclude", "Exclude ratraced reflection pass from combined.");
+       RNA_def_property_update(prop, NC_SCENE|ND_RENDER_OPTIONS, "rna_SceneRenderLayer_pass_update");
+
+       prop= RNA_def_property(srna, "pass_refraction_exclude", PROP_BOOLEAN, PROP_NONE);
+       RNA_def_property_boolean_sdna(prop, NULL, "pass_xor", SCE_PASS_REFRACT);
+       RNA_def_property_ui_text(prop, "Refraction Exclude", "Exclude ratraced refraction pass from combined.");
+       RNA_def_property_update(prop, NC_SCENE|ND_RENDER_OPTIONS, "rna_SceneRenderLayer_pass_update");
+}
+
 void rna_def_scene_render_data(BlenderRNA *brna)
 {
        StructRNA *srna;
@@ -324,10 +611,27 @@ void rna_def_scene_render_data(BlenderRNA *brna)
                
        
        static EnumPropertyItem image_type_items[] = {
-               {R_FRAMESERVER, "FRAMESERVER", 0, "Frame Server", ""},
-#ifdef WITH_FFMPEG
-               {R_FFMPEG, "FFMPEG", 0, "FFMpeg", ""},
+               {R_PNG, "PNG", 0, "PNG", ""},
+               {R_JPEG90, "JPEG", 0, "JPEG", ""},
+#ifdef WITH_OPENJPEG
+               {R_JP2, "JPEG2000", 0, "JPEG 2000", ""},
+#endif         
+               {R_TIFF, "TIFF", 0, "TIFF", ""},        // XXX only with G.have_libtiff
+               {R_BMP, "BMP", 0, "BMP", ""},
+               {R_TARGA, "TARGA", 0, "Targa", ""},
+               {R_RAWTGA, "RAWTARGA", 0, "Targa Raw", ""},
+               //{R_DDS, "DDS", 0, "DDS", ""}, // XXX not yet implemented
+               {R_HAMX, "HAMX", 0, "HamX", ""},
+               {R_IRIS, "IRIS", 0, "Iris", ""},
+               {0, "", 0, NULL, NULL},
+#ifdef WITH_OPENEXR
+               {R_OPENEXR, "OPENEXR", 0, "OpenEXR", ""},
+               {R_MULTILAYER, "MULTILAYER", 0, "MultiLayer", ""},
 #endif
+               {R_RADHDR, "RADHDR", 0, "Radiance HDR", ""},
+               {R_CINEON, "CINEON", 0, "Cineon", ""},
+               {R_DPX, "DPX", 0, "DPX", ""},
+               {0, "", 0, NULL, NULL},
                {R_AVIRAW, "AVIRAW", 0, "AVI Raw", ""},
                {R_AVIJPEG, "AVIJPEG", 0, "AVI JPEG", ""},
 #ifdef _WIN32
@@ -336,31 +640,25 @@ void rna_def_scene_render_data(BlenderRNA *brna)
 #ifdef WITH_QUICKTIME
                {R_QUICKTIME, "QUICKTIME", 0, "QuickTime", ""},
 #endif
-               {R_TARGA, "TARGA", 0, "Targa", ""},
-               {R_RAWTGA, "RAWTARGA", 0, "Targa Raw", ""},
-               {R_PNG, "PNG", 0, "PNG", ""},
-               //{R_DDS, "DDS", 0, "DDS", ""}, // XXX not yet implemented
-//#ifdef WITH_OPENJPEG
-               {R_JP2, "JPEG2000", 0, "JPEG 2000", ""},
-//#endif               
-               {R_BMP, "BMP", 0, "BMP", ""},
-               {R_JPEG90, "JPEG", 0, "JPEG", ""},
-               {R_HAMX, "HAMX", 0, "HamX", ""},
-               {R_IRIS, "IRIS", 0, "Iris", ""},
-               {R_RADHDR, "RADHDR", 0, "Radiance HDR", ""},
-               {R_CINEON, "CINEON", 0, "Cineon", ""},
-               {R_DPX, "DPX", 0, "DPX", ""},
 #ifdef __sgi
                {R_MOVIE, "MOVIE", 0, "Movie", ""},
 #endif
-//#ifdef WITH_OPENEXR
-               {R_OPENEXR, "OPENEXR", 0, "OpenEXR", ""},
-               {R_MULTILAYER, "MULTILAYER", 0, "MultiLayer", ""},
-//#endif
-               {R_TIFF, "TIFF", 0, "TIFF", ""},        // XXX only with G.have_libtiff
+#ifdef WITH_FFMPEG
+               {R_H264, "H264", 0, "H.264", ""},
+               {R_XVID, "XVID", 0, "Xvid", ""},
+               // XXX broken
+#if 0
+#ifdef WITH_OGG
+               {R_THEORA, "THEORA", 0, "Ogg Theora", ""},
+#endif
+#endif
+               {R_FFMPEG, "FFMPEG", 0, "FFMpeg", ""},
+#endif
+               {0, "", 0, NULL, NULL},
+               {R_FRAMESERVER, "FRAMESERVER", 0, "Frame Server", ""},
                {0, NULL, 0, NULL, NULL}};
                
-//#ifdef WITH_OPENEXR  
+#ifdef WITH_OPENEXR    
        static EnumPropertyItem exr_codec_items[] = {
                {0, "NONE", 0, "None", ""},
                {1, "PXR24", 0, "Pxr24 (lossy)", ""},
@@ -368,9 +666,9 @@ void rna_def_scene_render_data(BlenderRNA *brna)
                {3, "PIZ", 0, "PIZ (lossless)", ""},
                {4, "RLE", 0, "RLE (lossless)", ""},
                {0, NULL, 0, NULL, NULL}};
-//#endif
+#endif
 
-//#ifdef WITH_OPENJPEG
+#ifdef WITH_OPENJPEG
        static EnumPropertyItem jp2_preset_items[] = {
                {0, "NO_PRESET", 0, "No Preset", ""},
                {1, "R_JPEG2K_CINE_PRESET", 0, "Cinema 24fps 2048x1080", ""},
@@ -387,20 +685,24 @@ void rna_def_scene_render_data(BlenderRNA *brna)
                {R_JPEG2K_12BIT, "16", 0, "16", ""},
                {R_JPEG2K_16BIT, "32", 0, "32", ""},
                {0, NULL, 0, NULL, NULL}};
-//#endif
+#endif
 
-/*
 #ifdef WITH_FFMPEG
        static EnumPropertyItem ffmpeg_format_items[] = {
                {FFMPEG_MPEG1, "MPEG1", 0, "MPEG-1", ""},
                {FFMPEG_MPEG2, "MPEG2", 0, "MPEG-2", ""},
                {FFMPEG_MPEG4, "MPEG4", 0, "MPEG-4", ""},
-               {FFMPEG_AVI, "AVI", 0, "Avi", ""},
+               {FFMPEG_AVI, "AVI", 0, "AVI", ""},
                {FFMPEG_MOV, "QUICKTIME", 0, "Quicktime", ""},
                {FFMPEG_DV, "DV", 0, "DV", ""},
-               {FFMPEG_H264, "H264", 0, "H264", ""},
-               {FFMPEG_XVID, "XVID", 0, "XVid", ""},
-               {FFMPEG_OGG, "OGG", 0, "OGG", ""},
+               {FFMPEG_H264, "H264", 0, "H.264", ""},
+               {FFMPEG_XVID, "XVID", 0, "Xvid", ""},
+               // XXX broken
+#if 0
+#ifdef WITH_OGG
+               {FFMPEG_OGG, "OGG", 0, "Ogg", ""},
+#endif
+#endif
                {FFMPEG_FLV, "FLASH", 0, "Flash", ""},
                {0, NULL, 0, NULL, NULL}};
                
@@ -410,10 +712,12 @@ void rna_def_scene_render_data(BlenderRNA *brna)
                {CODEC_ID_MPEG4, "MPEG4", 0, "MPEG-4(divx)", ""},
                {CODEC_ID_HUFFYUV, "HUFFYUV", 0, "HuffYUV", ""},
                {CODEC_ID_DVVIDEO, "DV", 0, "DV", ""},
-               {CODEC_ID_H264, "H264", 0, "H264", ""},
-               {CODEC_ID_XVID, "XVID", 0, "XVid", ""},
-               {CODEC_ID_THEORA, "THEORA", 0, "OGG Theora", ""},
-               {CODEC_ID_FLV1, "FLASH", 0, "FlashVideo1", ""},
+               {CODEC_ID_H264, "H264", 0, "H.264", ""},
+               {CODEC_ID_XVID, "XVID", 0, "Xvid", ""},
+#ifdef WITH_OGG
+               {CODEC_ID_THEORA, "THEORA", 0, "Theora", ""},
+#endif
+               {CODEC_ID_FLV1, "FLASH", 0, "Flash Video", ""},
                {0, NULL, 0, NULL, NULL}};
                
        static EnumPropertyItem ffmpeg_audio_codec_items[] = {
@@ -425,7 +729,6 @@ void rna_def_scene_render_data(BlenderRNA *brna)
                {CODEC_ID_PCM_S16LE, "PCM", 0, "PCM", ""},
                {0, NULL, 0, NULL, NULL}};
 #endif
-*/
 
        srna= RNA_def_struct(brna, "SceneRenderData", NULL);
        RNA_def_struct_sdna(srna, "RenderData");
@@ -518,7 +821,7 @@ void rna_def_scene_render_data(BlenderRNA *brna)
        RNA_def_property_ui_text(prop, "G", "Log conversion gamma");
        RNA_def_property_update(prop, NC_SCENE|ND_RENDER_OPTIONS, NULL);
 
-//#ifdef WITH_OPENEXR  
+#ifdef WITH_OPENEXR    
        /* OpenEXR */
 
        prop= RNA_def_property(srna, "exr_codec", PROP_ENUM, PROP_NONE);
@@ -541,9 +844,9 @@ void rna_def_scene_render_data(BlenderRNA *brna)
        RNA_def_property_boolean_sdna(prop, NULL, "subimtype", R_PREVIEW_JPG);
        RNA_def_property_ui_text(prop, "Preview", "When rendering animations, save JPG preview images in same directory");
        RNA_def_property_update(prop, NC_SCENE|ND_RENDER_OPTIONS, NULL);
-//#endif
+#endif
 
-//#ifdef WITH_OPENJPEG
+#ifdef WITH_OPENJPEG
        /* Jpeg 2000 */
 
        prop= RNA_def_property(srna, "jpeg_preset", PROP_ENUM, PROP_NONE);
@@ -562,12 +865,11 @@ void rna_def_scene_render_data(BlenderRNA *brna)
        RNA_def_property_boolean_sdna(prop, NULL, "subimtype", R_JPEG2K_YCC);
        RNA_def_property_ui_text(prop, "YCC", "Save luminance-chrominance-chrominance channels instead of RGB colors");
        RNA_def_property_update(prop, NC_SCENE|ND_RENDER_OPTIONS, NULL);
-//#endif
+#endif
 
 #ifdef WITH_FFMPEG
        /* FFMPEG Video*/
        
-       /*
        prop= RNA_def_property(srna, "ffmpeg_format", PROP_ENUM, PROP_NONE);
        RNA_def_property_enum_bitflag_sdna(prop, NULL, "ffcodecdata.type");
        RNA_def_property_enum_items(prop, ffmpeg_format_items);
@@ -579,7 +881,6 @@ void rna_def_scene_render_data(BlenderRNA *brna)
        RNA_def_property_enum_items(prop, ffmpeg_codec_items);
        RNA_def_property_ui_text(prop, "Codec", "FFMpeg codec to use");
        RNA_def_property_update(prop, NC_SCENE|ND_RENDER_OPTIONS, NULL);
-       */
        
        prop= RNA_def_property(srna, "ffmpeg_video_bitrate", PROP_INT, PROP_NONE);
        RNA_def_property_int_sdna(prop, NULL, "ffcodecdata.video_bitrate");
@@ -630,13 +931,11 @@ void rna_def_scene_render_data(BlenderRNA *brna)
        
        /* FFMPEG Audio*/
        
-       /*
        prop= RNA_def_property(srna, "ffmpeg_audio_codec", PROP_ENUM, PROP_NONE);
        RNA_def_property_enum_bitflag_sdna(prop, NULL, "ffcodecdata.audio_codec");
        RNA_def_property_enum_items(prop, ffmpeg_audio_codec_items);
-       RNA_def_property_ui_text(prop, Codec", "FFMpeg codec to use");
+       RNA_def_property_ui_text(prop, "Audio Codec", "FFMpeg audio codec to use");
        RNA_def_property_update(prop, NC_SCENE|ND_RENDER_OPTIONS, NULL);
-       */
        
        prop= RNA_def_property(srna, "ffmpeg_audio_bitrate", PROP_INT, PROP_NONE);
        RNA_def_property_int_sdna(prop, NULL, "ffcodecdata.audio_bitrate");
@@ -765,14 +1064,10 @@ void rna_def_scene_render_data(BlenderRNA *brna)
        RNA_def_property_ui_text(prop, "Edge Color", "");
        RNA_def_property_update(prop, NC_SCENE|ND_RENDER_OPTIONS, NULL);
        
-       prop= RNA_def_property(srna, "panorama", PROP_BOOLEAN, PROP_NONE);
-       RNA_def_property_boolean_sdna(prop, NULL, "mode", R_PANORAMA);
-       RNA_def_property_ui_text(prop, "Panorama", "Render the scene with a cylindrical camera for pseudo-fisheye lens effects");
-       RNA_def_property_update(prop, NC_SCENE|ND_RENDER_OPTIONS, NULL);
-       
        prop= RNA_def_property(srna, "threads", PROP_INT, PROP_NONE);
        RNA_def_property_int_sdna(prop, NULL, "threads");
        RNA_def_property_range(prop, 1, 8);
+       RNA_def_property_int_funcs(prop, "rna_SceneRenderData_threads_get", NULL, NULL);
        RNA_def_property_ui_text(prop, "Threads", "Number of CPU threads to use simultaneously while rendering (for multi-core/CPU systems)");
        RNA_def_property_update(prop, NC_SCENE|ND_RENDER_OPTIONS, NULL);
        
@@ -806,14 +1101,14 @@ void rna_def_scene_render_data(BlenderRNA *brna)
        RNA_def_property_ui_text(prop, "No Overwrite", "Skip and don't overwrite existing files while rendering");
        RNA_def_property_update(prop, NC_SCENE|ND_RENDER_OPTIONS, NULL);
        
-       prop= RNA_def_property(srna, "do_composite", PROP_BOOLEAN, PROP_NONE);
+       prop= RNA_def_property(srna, "use_compositing", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "scemode", R_DOCOMP);
-       RNA_def_property_ui_text(prop, "Do Composite", "Process the render result through the compositing pipeline");
+       RNA_def_property_ui_text(prop, "Compositing", "Process the render result through the compositing pipeline, if a compositing nodes are enabled.");
        RNA_def_property_update(prop, NC_SCENE|ND_RENDER_OPTIONS, NULL);
        
-       prop= RNA_def_property(srna, "do_sequence", PROP_BOOLEAN, PROP_NONE);
+       prop= RNA_def_property(srna, "use_sequencer", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "scemode", R_DOSEQ);
-       RNA_def_property_ui_text(prop, "Do Sequence", "Process the render (and composited) result through the video sequence editor pipeline");
+       RNA_def_property_ui_text(prop, "Sequencer", "Process the render (and composited) result through the video sequence editor pipeline, if sequencer strips exist.");
        RNA_def_property_update(prop, NC_SCENE|ND_RENDER_OPTIONS, NULL);
        
        prop= RNA_def_property(srna, "file_extensions", PROP_BOOLEAN, PROP_NONE);
@@ -824,6 +1119,7 @@ void rna_def_scene_render_data(BlenderRNA *brna)
        prop= RNA_def_property(srna, "file_format", PROP_ENUM, PROP_NONE);
        RNA_def_property_enum_sdna(prop, NULL, "imtype");
        RNA_def_property_enum_items(prop, image_type_items);
+       RNA_def_property_enum_funcs(prop, NULL, "rna_SceneRenderData_file_format_set", NULL);
        RNA_def_property_ui_text(prop, "File Format", "File format to save the rendered images as.");
        RNA_def_property_update(prop, NC_SCENE|ND_RENDER_OPTIONS, NULL);
        
@@ -834,12 +1130,13 @@ void rna_def_scene_render_data(BlenderRNA *brna)
        
        prop= RNA_def_property(srna, "save_buffers", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "scemode", R_EXR_TILE_FILE);
-       RNA_def_property_ui_text(prop, "Save Buffers","Save tiles for all RenderLayers and SceneNodes to files in the temp directory (saves memory, allows Full Sampling).");
+       RNA_def_property_boolean_funcs(prop, "rna_SceneRenderData_save_buffers_get", NULL);
+       RNA_def_property_ui_text(prop, "Save Buffers","Save tiles for all RenderLayers and SceneNodes to files in the temp directory (saves memory, required for Full Sample).");
        RNA_def_property_update(prop, NC_SCENE|ND_RENDER_OPTIONS, NULL);
        
        prop= RNA_def_property(srna, "full_sample", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "scemode", R_FULL_SAMPLE);
-       RNA_def_property_ui_text(prop, "Full Sample","Save for every anti-aliasing sample the entire RenderLayer results. This solves anti-aliasing issues with compositing");
+       RNA_def_property_ui_text(prop, "Full Sample","Save for every anti-aliasing sample the entire RenderLayer results. This solves anti-aliasing issues with compositing.");
        RNA_def_property_update(prop, NC_SCENE|ND_RENDER_OPTIONS, NULL);
        
        prop= RNA_def_property(srna, "backbuf", PROP_BOOLEAN, PROP_NONE);
@@ -857,11 +1154,6 @@ void rna_def_scene_render_data(BlenderRNA *brna)
        RNA_def_property_ui_text(prop, "Output Path", "Directory/name to save animations, # characters defines the position and length of frame numbers.");
        RNA_def_property_update(prop, NC_SCENE|ND_RENDER_OPTIONS, NULL);
        
-       prop= RNA_def_property(srna, "stamp", PROP_BOOLEAN, PROP_NONE);
-       RNA_def_property_boolean_sdna(prop, NULL, "scemode", R_STAMP_INFO);
-       RNA_def_property_ui_text(prop, "Stamp", "Embed metadata into the rendered image");
-       RNA_def_property_update(prop, NC_SCENE|ND_RENDER_OPTIONS, NULL);
-       
        prop= RNA_def_property(srna, "stamp_time", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "stamp", R_STAMP_TIME);
        RNA_def_property_ui_text(prop, "Stamp Time", "Include the current time in image metadata");
@@ -935,6 +1227,21 @@ void rna_def_scene_render_data(BlenderRNA *brna)
        RNA_def_property_ui_text(prop, "Stamp Background", "Color to use behind stamp text");
        RNA_def_property_update(prop, NC_SCENE|ND_RENDER_OPTIONS, NULL);
        
+       prop= RNA_def_property(srna, "layers", PROP_COLLECTION, PROP_NONE);
+       RNA_def_property_collection_sdna(prop, NULL, "layers", NULL);
+       RNA_def_property_struct_type(prop, "SceneRenderLayer");
+       RNA_def_property_ui_text(prop, "Render Layers", "");
+
+       prop= RNA_def_property(srna, "single_layer", PROP_BOOLEAN, PROP_NONE);
+       RNA_def_property_boolean_sdna(prop, NULL, "scemode", R_SINGLE_LAYER);
+       RNA_def_property_ui_text(prop, "Single Layer", "Only render the active layer.");
+       RNA_def_property_update(prop, NC_SCENE|ND_RENDER_OPTIONS, NULL);
+
+       prop= RNA_def_property(srna, "active_layer_index", PROP_INT, PROP_NONE);
+       RNA_def_property_int_sdna(prop, NULL, "actlay");
+       RNA_def_property_int_funcs(prop, "rna_SceneRenderData_active_layer_index_get", "rna_SceneRenderData_active_layer_index_set", "rna_SceneRenderData_active_layer_index_range");
+       RNA_def_property_ui_text(prop, "Active Layer Index", "Active index in render layer array.");
+       RNA_def_property_update(prop, NC_SCENE|ND_RENDER_OPTIONS, NULL);
 }
 
 void RNA_def_scene(BlenderRNA *brna)
@@ -1038,6 +1345,7 @@ void RNA_def_scene(BlenderRNA *brna)
 
        rna_def_tool_settings(brna);
        rna_def_scene_render_data(brna);
+       rna_def_scene_render_layer(brna);
 }
 
 #endif
index a0185a6..842adcf 100644 (file)
@@ -453,6 +453,7 @@ void RE_SetCamera(Render *re, Object *camera)
                cam= camera->data;
                
                if(cam->type==CAM_ORTHO) re->r.mode |= R_ORTHO;
+               if(cam->flag & CAM_PANORAMA) re->r.mode |= R_PANORAMA;
                
                /* solve this too... all time depending stuff is in convertblender.c?
                 * Need to update the camera early because it's used for projection matrices
@@ -601,7 +602,7 @@ void initparts(Render *re)
        yparts= re->r.yparts;
        
        /* mininum part size, but for exr tile saving it was checked already */
-       if(!(re->r.scemode & R_EXR_TILE_FILE)) {
+       if(!(re->r.scemode & (R_EXR_TILE_FILE|R_FULL_SAMPLE))) {
                if(re->r.mode & R_PANORAMA) {
                        if(ceil(re->rectx/(float)xparts) < 8) 
                                xparts= 1 + re->rectx/8;
index ec26605..3ef50af 100644 (file)
@@ -36,6 +36,7 @@
 #include "DNA_node_types.h"
 #include "DNA_object_types.h"
 #include "DNA_scene_types.h"
+#include "DNA_sequence_types.h"
 #include "DNA_userdef_types.h"
 
 #include "BKE_utildefines.h"
@@ -1092,14 +1093,14 @@ void RE_InitState(Render *re, Render *source, RenderData *rd, int winx, int winy
                re->ok= 0;
        }
        else {
-#ifndef WITH_OPENEXR
+#ifdef WITH_OPENEXR
+               if(re->r.scemode & R_FULL_SAMPLE)
+                       re->r.scemode |= R_EXR_TILE_FILE;       /* enable automatic */
+#else
                /* can't do this without openexr support */
-               re->r.scemode &= ~R_EXR_TILE_FILE;
+               re->r.scemode &= ~(R_EXR_TILE_FILE|R_FULL_SAMPLE);
 #endif
                
-               if(!(re->r.scemode & R_EXR_TILE_FILE))
-                       re->r.scemode &= ~R_FULL_SAMPLE;        /* clear, so we can use this flag for test both */
-               
                /* fullsample wants uniform osa levels */
                if(source && (re->r.scemode & R_FULL_SAMPLE)) {
                        /* but, if source has no full sample we disable it */
@@ -1499,7 +1500,7 @@ static void threaded_tile_processor(Render *re)
                else if(re->r.scemode & R_FULL_SAMPLE)
                        re->result= new_full_sample_buffers_exr(re);
                else
-                       re->result= new_render_result(re, &re->disprect, 0, re->r.scemode & R_EXR_TILE_FILE);
+                       re->result= new_render_result(re, &re->disprect, 0, re->r.scemode & (R_EXR_TILE_FILE|R_FULL_SAMPLE));
        }
        
        if(re->result==NULL)
@@ -2278,7 +2279,7 @@ static void do_render_all_options(Render *re)
        /* ensure no images are in memory from previous animated sequences */
        BKE_image_all_free_anim_ibufs(re->r.cfra);
        
-       if(re->r.scemode & R_DOSEQ) {
+       if((re->r.scemode & R_DOSEQ) && re->scene->ed && re->scene->ed->seqbase.first) {
                /* note: do_render_seq() frees rect32 when sequencer returns float images */
                if(!re->test_break(re->tbh)) 
                        ; //XXX do_render_seq(re->result, re->r.cfra);
@@ -2299,7 +2300,7 @@ static void do_render_all_options(Render *re)
        re->stats_draw(re->sdh, &re->i);
        
        /* stamp image info here */
-       if((re->r.scemode & R_STAMP_INFO) && (re->r.stamp & R_STAMP_DRAW)) {
+       if((re->r.stamp & R_STAMP_ALL) && (re->r.stamp & R_STAMP_DRAW)) {
                renderresult_stampinfo(re->scene);
                re->display_draw(re->ddh, re->result, NULL);
        }
@@ -2327,13 +2328,13 @@ static int is_rendering_allowed(Render *re)
                        re->error(re->erh, "No border area selected.");
                        return 0;
                }
-               if(re->r.scemode & R_EXR_TILE_FILE) {
+               if(re->r.scemode & (R_EXR_TILE_FILE|R_FULL_SAMPLE)) {
                        re->error(re->erh, "Border render and Buffer-save not supported yet");
                        return 0;
                }
        }
        
-       if(re->r.scemode & R_EXR_TILE_FILE) {
+       if(re->r.scemode & (R_EXR_TILE_FILE|R_FULL_SAMPLE)) {
                char str[FILE_MAX];
                
                render_unique_exr_name(re, str, 0);