if not scene:
scene = bpy.data.scenes[0]
- render = scene.render_data
+ render = scene.render
world = scene.world
def uniqueName(name, nameSeq):
def write_pov_ini(filename_ini, filename_pov, filename_image):
scene = bpy.data.scenes[0]
- render = scene.render_data
+ render = scene.render
x = int(render.resolution_x * render.resolution_percentage * 0.01)
y = int(render.resolution_y * render.resolution_percentage * 0.01)
self.update_stats("", "POVRAY: Parsing File")
self._render()
- r = scene.render_data
+ r = scene.render
# compute resolution
x = int(r.resolution_x * r.resolution_percentage * 0.01)
# COMPAT_ENGINES must be defined in each subclass, external engines can add themselves here
def poll(self, context):
- rd = context.scene.render_data
+ rd = context.scene.render
return (rd.use_game_engine == False) and (rd.engine in self.COMPAT_ENGINES)
layout = self.layout
scene = context.scene
- rd = scene.render_data
+ rd = scene.render
layout.active = scene.pov_radio_enable
# XXX don't know what to do with this, probably do the same? (Arystan)
if BATCH_GROUP: #group
# group, so objects update properly, add a dummy scene.
- sce = bpy.data.scenes.new()
- sce.Layers = (1<<20) -1
- bpy.data.scenes.active = sce
+ scene = bpy.data.scenes.new()
+ scene.Layers = (1<<20) -1
+ bpy.data.scenes.active = scene
for ob_base in data.objects:
- sce.objects.link(ob_base)
+ scene.objects.link(ob_base)
- sce.update(1)
+ scene.update(1)
# TODO - BUMMER! Armatures not in the group wont animate the mesh
if BATCH_GROUP:
# remove temp group scene
- bpy.data.remove_scene(sce)
-# bpy.data.scenes.unlink(sce)
+ bpy.data.remove_scene(scene)
+# bpy.data.scenes.unlink(scene)
bpy.data.scenes.active = orig_sce
except:
return False
- sce = context.scene
-# sce = bpy.data.scenes.active
- world = sce.world
+ scene = context.scene
+# scene = bpy.data.scenes.active
+ world = scene.world
# ---------------------------- Write the header first
'''
Write a blender camera
'''
- render = sce.render_data
+ render = scene.render
width = render.resolution_x
height = render.resolution_y
-# render = sce.render
+# render = scene.render
# width = render.sizeX
# height = render.sizeY
aspect = float(width)/height
# if EXP_OBS_SELECTED is false, use sceens objects
if not batch_objects:
if EXP_OBS_SELECTED: tmp_objects = context.selected_objects
-# if EXP_OBS_SELECTED: tmp_objects = sce.objects.context
- else: tmp_objects = sce.objects
+# if EXP_OBS_SELECTED: tmp_objects = scene.objects.context
+ else: tmp_objects = scene.objects
else:
tmp_objects = batch_objects
# ob_base.makeDisplayList()
# This causes the makeDisplayList command to effect the mesh
- sce.set_frame(sce.current_frame)
+ scene.set_frame(scene.current_frame)
# Blender.Set('curframe', Blender.Get('curframe'))
ob_base.make_display_list()
# ob_base.makeDisplayList()
# This causes the makeDisplayList command to effect the mesh
- sce.set_frame(sce.current_frame)
+ scene.set_frame(scene.current_frame)
# Blender.Set('curframe', Blender.Get('curframe'))
del tmp_ob_type, tmp_objects
# Needed for scene footer as well as animation
- render = sce.render_data
-# render = sce.render
+ render = scene.render
+# render = scene.render
# from the FBX sdk
#define KTIME_ONE_SECOND KTime (K_LONGLONG(46186158000))
return int(0.5 + ((t/fps) * 46186158000))
fps = float(render.fps)
- start = sce.start_frame
+ start = scene.start_frame
# start = render.sFrame
- end = sce.end_frame
+ end = scene.end_frame
# end = render.eFrame
if end < start: start, end = end, start
if start==end: ANIM_ENABLE = False
if ANIM_ENABLE and [tmp for tmp in ob_anim_lists if tmp]:
- frame_orig = sce.current_frame
+ frame_orig = scene.current_frame
# frame_orig = Blender.Get('curframe')
if ANIM_OPTIMIZE:
if blenAction in my_bone.blenActionList:
ob.action = blenAction
# print '\t\tSetting Action!', blenAction
- # sce.update(1)
+ # scene.update(1)
file.write('\n\t\tFileName: "Default_Take.tak"') # ??? - not sure why this is needed
file.write('\n\t\tLocalTime: %i,%i' % (fbx_time(act_start-1), fbx_time(act_end-1))) # ??? - not sure why this is needed
'''
i = act_start
while i <= act_end:
- sce.set_frame(i)
+ scene.set_frame(i)
# Blender.Set('curframe', i)
for ob_generic in ob_anim_lists:
for my_ob in ob_generic:
file.write('\n}')
- sce.set_frame(frame_orig)
+ scene.set_frame(frame_orig)
# Blender.Set('curframe', frame_orig)
else:
'''
def writeViewpoint(self, ob, mat, scene):
- context = scene.render_data
+ context = scene.render
# context = scene.render
ratio = float(context.resolution_x)/float(context.resolution_y)
# ratio = float(context.imageSizeY())/float(context.imageSizeX())
def render_slave(self, scene):
- slave.render_slave(self, scene.network_render, scene.render_data.threads)
+ slave.render_slave(self, scene.network_render, scene.render.threads)
def render_client(self, scene):
netsettings = scene.network_render
conn.close()
return
- r = scene.render_data
+ r = scene.render
x= int(r.resolution_x*r.resolution_percentage*0.01)
y= int(r.resolution_y*r.resolution_percentage*0.01)
def initInfo(self):
if not self.resolution:
- self.resolution = tuple(getFileInfo(self.files[0].filepath, ["bpy.context.scene.render_data.resolution_x", "bpy.context.scene.render_data.resolution_y", "bpy.context.scene.render_data.resolution_percentage"]))
+ self.resolution = tuple(getFileInfo(self.files[0].filepath, ["bpy.context.scene.render.resolution_x", "bpy.context.scene.render.resolution_y", "bpy.context.scene.render.resolution_percentage"]))
def save(self):
if self.save_path:
def execute(self, context):
netsettings = context.scene.network_render
- rd = context.scene.render_data
+ rd = context.scene.render
conn = clientConnection(netsettings.server_address, netsettings.server_port, self.report)
# COMPAT_ENGINES must be defined in each subclass, external engines can add themselves here
def poll(self, context):
- rd = context.scene.render_data
+ rd = context.scene.render
return (rd.use_game_engine==False) and (rd.engine in self.COMPAT_ENGINES)
# Setting panel, use in the scene for now.
layout = self.layout
scene = context.scene
- rd = scene.render_data
+ rd = scene.render
netsettings = scene.network_render
layout.prop(netsettings, "slave_clear")
return thumbname
if bpy:
- sce = bpy.data.scenes[0]
- sce.render_data.file_format = "JPEG"
- sce.render_data.quality = 90
+ scene = bpy.data.scenes[0] # FIXME, this is dodgy!
+ scene.render.file_format = "JPEG"
+ scene.render.quality = 90
bpy.ops.image.open(path = filename)
img = bpy.data.images[imagename]
- img.save(thumbname, scene = sce)
+ img.save(thumbname, scene=scene)
try:
process = subprocess.Popen(["convert", thumbname, "-resize", "300x300", thumbname])
name = AddPresetBase.name
preset_values = [
- "bpy.context.scene.render_data.resolution_x",
- "bpy.context.scene.render_data.resolution_y",
- "bpy.context.scene.render_data.pixel_aspect_x",
- "bpy.context.scene.render_data.pixel_aspect_y",
- "bpy.context.scene.render_data.fps",
- "bpy.context.scene.render_data.fps_base",
- "bpy.context.scene.render_data.resolution_percentage",
- "bpy.context.scene.render_data.fields",
- "bpy.context.scene.render_data.field_order",
- "bpy.context.scene.render_data.fields_still",
+ "bpy.context.scene.render.resolution_x",
+ "bpy.context.scene.render.resolution_y",
+ "bpy.context.scene.render.pixel_aspect_x",
+ "bpy.context.scene.render.pixel_aspect_y",
+ "bpy.context.scene.render.fps",
+ "bpy.context.scene.render.fps_base",
+ "bpy.context.scene.render.resolution_percentage",
+ "bpy.context.scene.render.fields",
+ "bpy.context.scene.render.field_order",
+ "bpy.context.scene.render.fields_still",
]
preset_subdir = "render"
bl_undo = False
def execute(self, context):
- sce = context.scene
- rd = sce.render_data
+ scene = context.scene
+ rd = scene.render
prefs = context.user_preferences
preset = prefs.filepaths.animation_player_preset
file = ''.join([(c if file_b[i] == c else "#") for i, c in enumerate(file_a)])
else:
# works for movies and images
- file = rd.frame_path(frame=sce.start_frame)
+ file = rd.frame_path(frame=scene.start_frame)
cmd = [player_path]
# extra options, fps controls etc.
opts = [file, "-playback_speed", str(rd.fps)]
cmd.extend(opts)
elif preset == 'FRAMECYCLER':
- opts = [file, "%d-%d" % (sce.start_frame, sce.end_frame)]
+ opts = [file, "%d-%d" % (scene.start_frame, scene.end_frame)]
cmd.extend(opts)
elif preset == 'RV':
opts = ["-fps", str(rd.fps), "-play", "[ %s ]" % file]
-bpy.context.scene.render_data.resolution_x = 1920
-bpy.context.scene.render_data.resolution_y = 1080
-bpy.context.scene.render_data.resolution_percentage = 100
-bpy.context.scene.render_data.pixel_aspect_x = 1
-bpy.context.scene.render_data.pixel_aspect_y = 1
-bpy.context.scene.render_data.fps = 24
-bpy.context.scene.render_data.fps_base = 1
+bpy.context.scene.render.resolution_x = 1920
+bpy.context.scene.render.resolution_y = 1080
+bpy.context.scene.render.resolution_percentage = 100
+bpy.context.scene.render.pixel_aspect_x = 1
+bpy.context.scene.render.pixel_aspect_y = 1
+bpy.context.scene.render.fps = 24
+bpy.context.scene.render.fps_base = 1
-bpy.context.scene.render_data.resolution_x = 1280
-bpy.context.scene.render_data.resolution_y = 720
-bpy.context.scene.render_data.resolution_percentage = 100
-bpy.context.scene.render_data.pixel_aspect_x = 1
-bpy.context.scene.render_data.pixel_aspect_y = 1
-bpy.context.scene.render_data.fps = 24
-bpy.context.scene.render_data.fps_base = 1
+bpy.context.scene.render.resolution_x = 1280
+bpy.context.scene.render.resolution_y = 720
+bpy.context.scene.render.resolution_percentage = 100
+bpy.context.scene.render.pixel_aspect_x = 1
+bpy.context.scene.render.pixel_aspect_y = 1
+bpy.context.scene.render.fps = 24
+bpy.context.scene.render.fps_base = 1
-bpy.context.scene.render_data.resolution_x = 720
-bpy.context.scene.render_data.resolution_y = 480
-bpy.context.scene.render_data.resolution_percentage = 100
-bpy.context.scene.render_data.pixel_aspect_x = 10
-bpy.context.scene.render_data.pixel_aspect_y = 11
-bpy.context.scene.render_data.fps = 30
-bpy.context.scene.render_data.fps_base = 1.001
+bpy.context.scene.render.resolution_x = 720
+bpy.context.scene.render.resolution_y = 480
+bpy.context.scene.render.resolution_percentage = 100
+bpy.context.scene.render.pixel_aspect_x = 10
+bpy.context.scene.render.pixel_aspect_y = 11
+bpy.context.scene.render.fps = 30
+bpy.context.scene.render.fps_base = 1.001
-bpy.context.scene.render_data.resolution_x = 720
-bpy.context.scene.render_data.resolution_y = 576
-bpy.context.scene.render_data.resolution_percentage = 100
-bpy.context.scene.render_data.pixel_aspect_x = 54
-bpy.context.scene.render_data.pixel_aspect_y = 51
-bpy.context.scene.render_data.fps = 25
-bpy.context.scene.render_data.fps_base = 1
+bpy.context.scene.render.resolution_x = 720
+bpy.context.scene.render.resolution_y = 576
+bpy.context.scene.render.resolution_percentage = 100
+bpy.context.scene.render.pixel_aspect_x = 54
+bpy.context.scene.render.pixel_aspect_y = 51
+bpy.context.scene.render.fps = 25
+bpy.context.scene.render.fps_base = 1
-bpy.context.scene.render_data.resolution_x = 720
-bpy.context.scene.render_data.resolution_y = 576
-bpy.context.scene.render_data.resolution_percentage = 100
-bpy.context.scene.render_data.pixel_aspect_x = 64
-bpy.context.scene.render_data.pixel_aspect_y = 45
-bpy.context.scene.render_data.fps = 25
-bpy.context.scene.render_data.fps_base = 1
+bpy.context.scene.render.resolution_x = 720
+bpy.context.scene.render.resolution_y = 576
+bpy.context.scene.render.resolution_percentage = 100
+bpy.context.scene.render.pixel_aspect_x = 64
+bpy.context.scene.render.pixel_aspect_y = 45
+bpy.context.scene.render.fps = 25
+bpy.context.scene.render.fps_base = 1
def poll(self, context):
ob = context.active_object
- rd = context.scene.render_data
+ rd = context.scene.render
return ob and ob.game and (rd.engine == 'BLENDER_GAME')
def poll(self, context):
game = context.object.game
- rd = context.scene.render_data
+ rd = context.scene.render
return (game.physics_type in ('DYNAMIC', 'RIGID_BODY', 'SENSOR', 'SOFT_BODY', 'STATIC')) and (rd.engine == 'BLENDER_GAME')
def draw_header(self, context):
bl_context = "render"
def poll(self, context):
- rd = context.scene.render_data
+ rd = context.scene.render
return (rd.engine == 'BLENDER_GAME')
def poll(self, context):
scene = context.scene
- return (scene.render_data.engine == 'BLENDER_GAME') and (scene.world is not None)
+ return (scene.render.engine == 'BLENDER_GAME') and (scene.world is not None)
class WORLD_PT_game_context_world(WorldButtonsPanel):
bl_show_header = False
def poll(self, context):
- rd = context.scene.render_data
+ rd = context.scene.render
return (context.scene) and (rd.use_game_engine)
def draw(self, context):
def poll(self, context):
mat = context.material
- engine = context.scene.render_data.engine
+ engine = context.scene.render.engine
return mat and (engine in self.COMPAT_ENGINES)
# An exception, dont call the parent poll func because
# this manages materials for all engine types
- engine = context.scene.render_data.engine
+ engine = context.scene.render.engine
return (context.material or context.object) and (engine in self.COMPAT_ENGINES)
def draw(self, context):
def poll(self, context):
mat = active_node_mat(context.material)
- engine = context.scene.render_data.engine
+ engine = context.scene.render.engine
return mat and (mat.type in ('SURFACE', 'WIRE', 'HALO')) and (engine in self.COMPAT_ENGINES)
def draw(self, context):
def poll(self, context):
mat = context.material
- engine = context.scene.render_data.engine
+ engine = context.scene.render.engine
return mat and (mat.type in ('SURFACE', 'WIRE', 'HALO')) and (engine in self.COMPAT_ENGINES)
def draw(self, context):
def poll(self, context):
mat = active_node_mat(context.material)
- engine = context.scene.render_data.engine
+ engine = context.scene.render.engine
return mat and (mat.type in ('SURFACE', 'WIRE', 'HALO')) and (engine in self.COMPAT_ENGINES)
def draw(self, context):
def poll(self, context):
mat = active_node_mat(context.material)
- engine = context.scene.render_data.engine
+ engine = context.scene.render.engine
return mat and (mat.type in ('SURFACE', 'WIRE')) and (engine in self.COMPAT_ENGINES)
def draw(self, context):
def poll(self, context):
mat = active_node_mat(context.material)
- engine = context.scene.render_data.engine
+ engine = context.scene.render.engine
return mat and (mat.type in ('SURFACE', 'WIRE')) and (engine in self.COMPAT_ENGINES)
def draw(self, context):
def poll(self, context):
mat = active_node_mat(context.material)
- engine = context.scene.render_data.engine
+ engine = context.scene.render.engine
return mat and (mat.type in ('SURFACE', 'WIRE')) and (engine in self.COMPAT_ENGINES)
def draw(self, context):
def poll(self, context):
mat = active_node_mat(context.material)
- engine = context.scene.render_data.engine
+ engine = context.scene.render.engine
return mat and (mat.type in ('SURFACE', 'WIRE')) and (engine in self.COMPAT_ENGINES)
def draw_header(self, context):
def poll(self, context):
mat = active_node_mat(context.material)
- engine = context.scene.render_data.engine
+ engine = context.scene.render.engine
return mat and (mat.type in ('SURFACE', 'WIRE')) and (engine in self.COMPAT_ENGINES)
def draw_header(self, context):
def poll(self, context):
mat = active_node_mat(context.material)
- engine = context.scene.render_data.engine
+ engine = context.scene.render.engine
return mat and (mat.type in ('SURFACE', 'WIRE')) and (engine in self.COMPAT_ENGINES)
def draw_header(self, context):
def poll(self, context):
mat = active_node_mat(context.material)
- engine = context.scene.render_data.engine
+ engine = context.scene.render.engine
return mat and (engine in self.COMPAT_ENGINES)
def draw_header(self, context):
def poll(self, context):
mat = context.material
- engine = context.scene.render_data.engine
+ engine = context.scene.render.engine
return mat and (mat.type == 'HALO') and (engine in self.COMPAT_ENGINES)
def draw(self, context):
def poll(self, context):
mat = context.material
- engine = context.scene.render_data.engine
+ engine = context.scene.render.engine
return mat and (mat.type == 'HALO') and (engine in self.COMPAT_ENGINES)
def draw_header(self, context):
def poll(self, context):
mat = context.material
- engine = context.scene.render_data.engine
+ engine = context.scene.render.engine
return mat and (mat.type == 'VOLUME') and (engine in self.COMPAT_ENGINES)
def poll(self, context):
ob = context.object
- rd = context.scene.render_data
+ rd = context.scene.render
return (ob and ob.type == 'MESH') and (not rd.use_game_engine)
bl_context = "physics"
def poll(self, context):
- rd = context.scene.render_data
+ rd = context.scene.render
return (context.object) and (not rd.use_game_engine)
def poll(self, context):
ob = context.object
- rd = context.scene.render_data
+ rd = context.scene.render
return (ob and ob.type == 'MESH') and (not rd.use_game_engine)
def draw(self, context):
def poll(self, context):
ob = context.object
- rd = context.scene.render_data
+ rd = context.scene.render
return (ob and ob.type == 'MESH') and (not rd.use_game_engine)
def poll(self, context):
ob = context.object
- rd = context.scene.render_data
+ rd = context.scene.render
return (ob and ob.type == 'MESH') and (not rd.use_game_engine)
def poll(self, context):
ob = context.object
- rd = context.scene.render_data
+ rd = context.scene.render
return (ob and ob.type == 'MESH') and (not rd.use_game_engine)
# COMPAT_ENGINES must be defined in each subclass, external engines can add themselves here
def poll(self, context):
- rd = context.scene.render_data
+ rd = context.scene.render
return (context.scene and rd.use_game_engine is False) and (rd.engine in self.COMPAT_ENGINES)
def draw(self, context):
layout = self.layout
- rd = context.scene.render_data
+ rd = context.scene.render
wide_ui = context.region.width > narrowui
split = layout.split()
layout = self.layout
scene = context.scene
- rd = scene.render_data
+ rd = scene.render
wide_ui = context.region.width > narrowui
row = layout.row()
def draw(self, context):
layout = self.layout
- rd = context.scene.render_data
+ rd = context.scene.render
wide_ui = context.region.width > narrowui
split = layout.split()
def draw(self, context):
layout = self.layout
- rd = context.scene.render_data
+ rd = context.scene.render
wide_ui = context.region.width > narrowui
split = layout.split()
def draw(self, context):
layout = self.layout
- rd = context.scene.render_data
+ rd = context.scene.render
wide_ui = context.region.width > narrowui
split = layout.split()
def draw(self, context):
layout = self.layout
- rd = context.scene.render_data
+ rd = context.scene.render
wide_ui = context.region.width > narrowui
layout.prop(rd, "output_path", text="")
elif rd.file_format == 'QUICKTIME_CARBON':
split = layout.split()
- split.operator("scene.render_data_set_quicktime_codec")
+ split.operator("scene.render_set_quicktime_codec")
elif rd.file_format == 'QUICKTIME_QTKIT':
split = layout.split()
COMPAT_ENGINES = {'BLENDER_RENDER'}
def poll(self, context):
- rd = context.scene.render_data
+ rd = context.scene.render
return rd.file_format in ('FFMPEG', 'XVID', 'H264', 'THEORA')
def draw(self, context):
layout = self.layout
- rd = context.scene.render_data
+ rd = context.scene.render
wide_ui = context.region.width > narrowui
split = layout.split()
COMPAT_ENGINES = {'BLENDER_RENDER'}
def draw_header(self, context):
- rd = context.scene.render_data
+ rd = context.scene.render
self.layout.prop(rd, "antialiasing", text="")
def draw(self, context):
layout = self.layout
- rd = context.scene.render_data
+ rd = context.scene.render
wide_ui = context.region.width > narrowui
layout.active = rd.antialiasing
COMPAT_ENGINES = {'BLENDER_RENDER'}
def draw_header(self, context):
- rd = context.scene.render_data
+ rd = context.scene.render
self.layout.prop(rd, "motion_blur", text="")
def draw(self, context):
layout = self.layout
- rd = context.scene.render_data
+ rd = context.scene.render
layout.active = rd.motion_blur
row = layout.row()
layout = self.layout
scene = context.scene
- rd = scene.render_data
+ rd = scene.render
wide_ui = context.region.width > narrowui
row = layout.row().split()
COMPAT_ENGINES = {'BLENDER_RENDER'}
def draw_header(self, context):
- rd = context.scene.render_data
+ rd = context.scene.render
self.layout.prop(rd, "render_stamp", text="")
def draw(self, context):
layout = self.layout
- rd = context.scene.render_data
+ rd = context.scene.render
wide_ui = context.region.width > narrowui
layout.active = rd.render_stamp
def draw(self, context):
layout = self.layout
- rd = context.scene.render_data
+ rd = context.scene.render
wide_ui = context.region.width > narrowui
layout.operator("object.bake_image", icon='RENDER_STILL')
def draw_header(self, context):
scene = context.scene
- rd = scene.render_data
+ rd = scene.render
self.layout.prop(rd, "use_simplify", text="")
def draw(self, context):
layout = self.layout
scene = context.scene
- rd = scene.render_data
+ rd = scene.render
wide_ui = context.region.width > narrowui
layout.active = rd.use_simplify
# COMPAT_ENGINES must be defined in each subclass, external engines can add themselves here
def poll(self, context):
- rd = context.scene.render_data
+ rd = context.scene.render
return (context.world) and (not rd.use_game_engine) and (rd.engine in self.COMPAT_ENGINES)
COMPAT_ENGINES = {'BLENDER_RENDER'}
def poll(self, context):
- rd = context.scene.render_data
+ rd = context.scene.render
return (not rd.use_game_engine) and (rd.engine in self.COMPAT_ENGINES)
def draw(self, context):
bl_label = "Game Properties"
def poll(self, context):
- rd = context.scene.render_data
+ rd = context.scene.render
sima = context.space_data
return (sima and sima.image) and (rd.engine == 'BLENDER_GAME')
window = context.window
scene = context.scene
- rd = scene.render_data
+ rd = scene.render
row = layout.row(align=True)
row.template_header()
def draw(self, context):
layout = self.layout
- # rd = context.scene.render_data
+ # rd = context.scene.render
layout.operator("screen.render", text="Render Image", icon='RENDER_STILL')
layout.operator("screen.render", text="Render Animation", icon='RENDER_ANIMATION').animation = True
layout.prop(snode_id, "use_nodes")
elif snode.tree_type == 'COMPOSITING':
- snode_id = snode.id
+ scene = snode.id
- layout.prop(snode_id, "use_nodes")
- layout.prop(snode_id.render_data, "free_unused_nodes", text="Free Unused")
+ layout.prop(scene, "use_nodes")
+ layout.prop(scene.render, "free_unused_nodes", text="Free Unused")
layout.prop(snode, "backdrop")
def draw(self, context):
layout = self.layout
- render_data = context.scene.render_data
+ render = context.scene.render
strip = act_strip(context)
split = layout.split(percentage=0.3)
col.prop(strip, "start_frame")
subrow = col.split(percentage=0.66)
subrow.prop(strip, "length")
- subrow.label(text="%.2f sec" % (strip.length / (render_data.fps / render_data.fps_base)))
+ subrow.label(text="%.2f sec" % (strip.length / (render.fps / render.fps_base)))
col = layout.column(align=True)
col.label(text="Offset:")
extern StructRNA RNA_EnvironmentMap;
extern StructRNA RNA_EnvironmentMapTexture;
extern StructRNA RNA_Event;
-extern StructRNA RNA_Extension;
extern StructRNA RNA_ExplodeModifier;
extern StructRNA RNA_ExpressionController;
+extern StructRNA RNA_Extension;
extern StructRNA RNA_FCurve;
extern StructRNA RNA_FCurveSample;
extern StructRNA RNA_FieldSettings;
extern StructRNA RNA_RenderLayer;
extern StructRNA RNA_RenderPass;
extern StructRNA RNA_RenderResult;
+extern StructRNA RNA_RenderSettings;
extern StructRNA RNA_RGBANodeSocket;
extern StructRNA RNA_RigidBodyJointConstraint;
extern StructRNA RNA_Scene;
extern StructRNA RNA_SceneGameData;
-extern StructRNA RNA_SceneRenderData;
extern StructRNA RNA_SceneRenderLayer;
extern StructRNA RNA_SceneSequence;
extern StructRNA RNA_Screen;
}
-static char *rna_SceneRenderData_path(PointerRNA *ptr)
+static char *rna_RenderSettings_path(PointerRNA *ptr)
{
- return BLI_sprintfN("render_data");
+ return BLI_sprintfN("render");
}
-static int rna_SceneRenderData_threads_get(PointerRNA *ptr)
+static int rna_RenderSettings_threads_get(PointerRNA *ptr)
{
RenderData *rd= (RenderData*)ptr->data;
return BLI_system_thread_count();
}
-static int rna_SceneRenderData_save_buffers_get(PointerRNA *ptr)
+static int rna_RenderSettings_save_buffers_get(PointerRNA *ptr)
{
RenderData *rd= (RenderData*)ptr->data;
if(rd->mode & R_BORDER)
return (rd->scemode & (R_EXR_TILE_FILE|R_FULL_SAMPLE)) != 0;
}
-static int rna_SceneRenderData_full_sample_get(PointerRNA *ptr)
+static int rna_RenderSettings_full_sample_get(PointerRNA *ptr)
{
RenderData *rd= (RenderData*)ptr->data;
return (rd->scemode & R_FULL_SAMPLE) && !(rd->mode & R_BORDER);
}
-static void rna_SceneRenderData_file_format_set(PointerRNA *ptr, int value)
+static void rna_RenderSettings_file_format_set(PointerRNA *ptr, int value)
{
RenderData *rd= (RenderData*)ptr->data;
BKE_add_image_extension(str, rd->imtype);
}
-void rna_SceneRenderData_jpeg2k_preset_update(RenderData *rd)
+void rna_RenderSettings_jpeg2k_preset_update(RenderData *rd)
{
rd->subimtype &= ~(R_JPEG2K_12BIT|R_JPEG2K_16BIT | R_JPEG2K_CINE_PRESET|R_JPEG2K_CINE_48FPS);
}
#ifdef WITH_OPENJPEG
-static void rna_SceneRenderData_jpeg2k_preset_set(PointerRNA *ptr, int value)
+static void rna_RenderSettings_jpeg2k_preset_set(PointerRNA *ptr, int value)
{
RenderData *rd= (RenderData*)ptr->data;
rd->jp2_preset= value;
- rna_SceneRenderData_jpeg2k_preset_update(rd);
+ rna_RenderSettings_jpeg2k_preset_update(rd);
}
-static void rna_SceneRenderData_jpeg2k_depth_set(PointerRNA *ptr, int value)
+static void rna_RenderSettings_jpeg2k_depth_set(PointerRNA *ptr, int value)
{
RenderData *rd= (RenderData*)ptr->data;
rd->jp2_depth= value;
- rna_SceneRenderData_jpeg2k_preset_update(rd);
+ rna_RenderSettings_jpeg2k_preset_update(rd);
}
#endif
#ifdef WITH_QUICKTIME
-static int rna_SceneRenderData_qtcodecsettings_codecType_get(PointerRNA *ptr)
+static int rna_RenderSettings_qtcodecsettings_codecType_get(PointerRNA *ptr)
{
RenderData *rd= (RenderData*)ptr->data;
return quicktime_rnatmpvalue_from_codectype(rd->qtcodecsettings.codecType);
}
-static void rna_SceneRenderData_qtcodecsettings_codecType_set(PointerRNA *ptr, int value)
+static void rna_RenderSettings_qtcodecsettings_codecType_set(PointerRNA *ptr, int value)
{
RenderData *rd= (RenderData*)ptr->data;
rd->qtcodecsettings.codecType = quicktime_codecType_from_rnatmpvalue(value);
}
-static EnumPropertyItem *rna_SceneRenderData_qtcodecsettings_codecType_itemf(bContext *C, PointerRNA *ptr, int *free)
+static EnumPropertyItem *rna_RenderSettings_qtcodecsettings_codecType_itemf(bContext *C, PointerRNA *ptr, int *free)
{
EnumPropertyItem *item= NULL;
EnumPropertyItem tmp = {0, "", 0, "", ""};
}
#endif
-static int rna_SceneRenderData_active_layer_index_get(PointerRNA *ptr)
+static int rna_RenderSettings_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)
+static void rna_RenderSettings_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)
+static void rna_RenderSettings_active_layer_index_range(PointerRNA *ptr, int *min, int *max)
{
RenderData *rd= (RenderData*)ptr->data;
*max= MAX2(0, *max);
}
-static void rna_SceneRenderData_engine_set(PointerRNA *ptr, int value)
+static void rna_RenderSettings_engine_set(PointerRNA *ptr, int value)
{
RenderData *rd= (RenderData*)ptr->data;
RenderEngineType *type= BLI_findlink(&R_engines, value);
BLI_strncpy(rd->engine, type->idname, sizeof(rd->engine));
}
-static EnumPropertyItem *rna_SceneRenderData_engine_itemf(bContext *C, PointerRNA *ptr, int *free)
+static EnumPropertyItem *rna_RenderSettings_engine_itemf(bContext *C, PointerRNA *ptr, int *free)
{
RenderEngineType *type;
EnumPropertyItem *item= NULL;
return item;
}
-static int rna_SceneRenderData_engine_get(PointerRNA *ptr)
+static int rna_RenderSettings_engine_get(PointerRNA *ptr)
{
RenderData *rd= (RenderData*)ptr->data;
RenderEngineType *type;
return 0;
}
-static void rna_SceneRenderData_color_management_update(Main *bmain, Scene *unused, PointerRNA *ptr)
+static void rna_RenderSettings_color_management_update(Main *bmain, Scene *unused, PointerRNA *ptr)
{
/* reset image nodes */
Scene *scene= (Scene*)ptr->id.data;
}
}
-static int rna_SceneRenderData_multiple_engines_get(PointerRNA *ptr)
+static int rna_RenderSettings_multiple_engines_get(PointerRNA *ptr)
{
return (BLI_countlist(&R_engines) > 1);
}
-static int rna_SceneRenderData_use_game_engine_get(PointerRNA *ptr)
+static int rna_RenderSettings_use_game_engine_get(PointerRNA *ptr)
{
RenderData *rd= (RenderData*)ptr->data;
RenderEngineType *type;
{0, "BLENDER_RENDER", 0, "Blender Render", ""},
{0, NULL, 0, NULL, NULL}};
- srna= RNA_def_struct(brna, "SceneRenderData", NULL);
+ srna= RNA_def_struct(brna, "RenderSettings", NULL);
RNA_def_struct_sdna(srna, "RenderData");
RNA_def_struct_nested(brna, srna, "Scene");
- RNA_def_struct_path_func(srna, "rna_SceneRenderData_path");
+ RNA_def_struct_path_func(srna, "rna_RenderSettings_path");
RNA_def_struct_ui_text(srna, "Render Data", "Rendering settings for a Scene datablock");
prop= RNA_def_property(srna, "color_mode", PROP_ENUM, PROP_NONE);
prop= RNA_def_property(srna, "jpeg2k_preset", PROP_ENUM, PROP_NONE);
RNA_def_property_enum_sdna(prop, NULL, "jp2_preset");
RNA_def_property_enum_items(prop, jp2_preset_items);
- RNA_def_property_enum_funcs(prop, NULL, "rna_SceneRenderData_jpeg2k_preset_set", NULL);
+ RNA_def_property_enum_funcs(prop, NULL, "rna_RenderSettings_jpeg2k_preset_set", NULL);
RNA_def_property_ui_text(prop, "Preset", "Use a DCI Standard preset for saving jpeg2000");
RNA_def_property_update(prop, NC_SCENE|ND_RENDER_OPTIONS, NULL);
prop= RNA_def_property(srna, "jpeg2k_depth", PROP_ENUM, PROP_NONE);
RNA_def_property_enum_bitflag_sdna(prop, NULL, "jp2_depth");
RNA_def_property_enum_items(prop, jp2_depth_items);
- RNA_def_property_enum_funcs(prop, NULL, "rna_SceneRenderData_jpeg2k_depth_set", NULL);
+ RNA_def_property_enum_funcs(prop, NULL, "rna_RenderSettings_jpeg2k_depth_set", NULL);
RNA_def_property_ui_text(prop, "Depth", "Bit depth per channel");
RNA_def_property_update(prop, NC_SCENE|ND_RENDER_OPTIONS, NULL);
prop= RNA_def_property(srna, "quicktime_codec_type", PROP_ENUM, PROP_NONE);
RNA_def_property_enum_bitflag_sdna(prop, NULL, "qtcodecsettings.codecType");
RNA_def_property_enum_items(prop, quicktime_codec_type_items);
- RNA_def_property_enum_funcs(prop, "rna_SceneRenderData_qtcodecsettings_codecType_get",
- "rna_SceneRenderData_qtcodecsettings_codecType_set",
- "rna_SceneRenderData_qtcodecsettings_codecType_itemf");
+ RNA_def_property_enum_funcs(prop, "rna_RenderSettings_qtcodecsettings_codecType_get",
+ "rna_RenderSettings_qtcodecsettings_codecType_set",
+ "rna_RenderSettings_qtcodecsettings_codecType_itemf");
RNA_def_property_ui_text(prop, "Codec", "QuickTime codec type");
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, BLENDER_MAX_THREADS);
- RNA_def_property_int_funcs(prop, "rna_SceneRenderData_threads_get", NULL, NULL);
+ RNA_def_property_int_funcs(prop, "rna_RenderSettings_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);
prop= RNA_def_property(srna, "color_management", PROP_BOOLEAN, PROP_NONE);
RNA_def_property_boolean_sdna(prop, NULL, "color_mgt_flag", R_COLOR_MANAGEMENT);
RNA_def_property_ui_text(prop, "Color Management", "Use color profiles and gamma corrected imaging pipeline");
- RNA_def_property_update(prop, NC_SCENE|ND_RENDER_OPTIONS|NC_MATERIAL|ND_SHADING, "rna_SceneRenderData_color_management_update");
+ RNA_def_property_update(prop, NC_SCENE|ND_RENDER_OPTIONS|NC_MATERIAL|ND_SHADING, "rna_RenderSettings_color_management_update");
prop= RNA_def_property(srna, "use_file_extension", PROP_BOOLEAN, PROP_NONE);
RNA_def_property_boolean_sdna(prop, NULL, "scemode", R_EXTENSION);
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_enum_funcs(prop, NULL, "rna_RenderSettings_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);
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_boolean_funcs(prop, "rna_SceneRenderData_save_buffers_get", NULL);
+ RNA_def_property_boolean_funcs(prop, "rna_RenderSettings_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_boolean_funcs(prop, "rna_SceneRenderData_full_sample_get", NULL);
+ RNA_def_property_boolean_funcs(prop, "rna_RenderSettings_full_sample_get", NULL);
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, "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_int_funcs(prop, "rna_RenderSettings_active_layer_index_get", "rna_RenderSettings_active_layer_index_set", "rna_RenderSettings_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);
/* engine */
prop= RNA_def_property(srna, "engine", PROP_ENUM, PROP_NONE);
RNA_def_property_enum_items(prop, engine_items);
- RNA_def_property_enum_funcs(prop, "rna_SceneRenderData_engine_get", "rna_SceneRenderData_engine_set", "rna_SceneRenderData_engine_itemf");
+ RNA_def_property_enum_funcs(prop, "rna_RenderSettings_engine_get", "rna_RenderSettings_engine_set", "rna_RenderSettings_engine_itemf");
RNA_def_property_ui_text(prop, "Engine", "Engine to use for rendering");
RNA_def_property_update(prop, NC_WINDOW, NULL);
prop= RNA_def_property(srna, "multiple_engines", PROP_BOOLEAN, PROP_NONE);
- RNA_def_property_boolean_funcs(prop, "rna_SceneRenderData_multiple_engines_get", NULL);
+ RNA_def_property_boolean_funcs(prop, "rna_RenderSettings_multiple_engines_get", NULL);
RNA_def_property_clear_flag(prop, PROP_EDITABLE);
RNA_def_property_ui_text(prop, "Multiple Engines", "More than one rendering engine is available");
prop= RNA_def_property(srna, "use_game_engine", PROP_BOOLEAN, PROP_NONE);
- RNA_def_property_boolean_funcs(prop, "rna_SceneRenderData_use_game_engine_get", NULL);
+ RNA_def_property_boolean_funcs(prop, "rna_RenderSettings_use_game_engine_get", NULL);
RNA_def_property_clear_flag(prop, PROP_EDITABLE);
RNA_def_property_ui_text(prop, "Use Game Engine", "Current rendering engine is a game engine");
RNA_def_property_update(prop, 0, "rna_Physics_update");
/* Render Data */
- prop= RNA_def_property(srna, "render_data", PROP_POINTER, PROP_NONE);
+ prop= RNA_def_property(srna, "render", PROP_POINTER, PROP_NONE);
RNA_def_property_flag(prop, PROP_NEVER_NULL);
RNA_def_property_pointer_sdna(prop, NULL, "r");
- RNA_def_property_struct_type(prop, "SceneRenderData");
+ RNA_def_property_struct_type(prop, "RenderSettings");
RNA_def_property_ui_text(prop, "Render Data", "");
/* Markers */
projects / blender.git / commitdiff