Commit 58b07185 authored by meta-androcto's avatar meta-androcto
Browse files

render_shots: remove?: unsupported T63750

parent 62ccae64
# ***** BEGIN GPL LICENSE BLOCK *****
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software Foundation,
# Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
#
# ***** END GPL LICENCE BLOCK *****
bl_info = {
"name": "Render Shots",
"author": "Aaron Symons",
"version": (0, 3, 2),
"blender": (2, 76, 0),
"location": "Properties > Render > Render Shots",
"description": "Render an image or animation from different camera views",
"warning": "",
"wiki_url": "http://wiki.blender.org/index.php?title=Extensions:2.6/Py"\
"/Scripts/Render/Render_Shots",
"tracker_url": "https://developer.blender.org/maniphest/task/edit/form/2/",
"category": "Render"}
import bpy
from bpy.props import BoolProperty, IntProperty, StringProperty
from bpy.app.handlers import persistent
import os, shutil
#####################################
# Update Functions
#####################################
def shape_nav(self, context):
nav = self.rs_shotshape_nav
if self.rs_shotshape_shape != "":
shapeVerts = bpy.data.objects[self.rs_shotshape_shape].data.vertices
max = len(shapeVerts)-1
min = max - (max+max)
if nav > max or nav < min:
nav = 0
v = shapeVerts[nav].co
self.location = (v[0], v[1], v[2])
return None
def is_new_object(ob):
try:
isNew = ob["rs_shotshape_use_frames"]
except:
isNew = None
return True if isNew is None else False
def update_shot_list(scn):
scn.rs_is_updating = True
if hasattr(scn, 'rs_create_folders'):
scn.rs_create_folders = False
for ob in bpy.data.objects:
if ob.type == 'CAMERA':
if is_new_object(ob):
ob["rs_shot_include"] = True
ob["rs_shot_start"] = scn.frame_start
ob["rs_shot_end"] = scn.frame_end
ob["rs_shot_output"] = ""
ob["rs_toggle_panel"] = True
ob["rs_settings_use"] = False
ob["rs_resolution_x"] = scn.render.resolution_x
ob["rs_resolution_y"] = scn.render.resolution_y
ob["rs_cycles_samples"] = 10
ob["rs_shotshape_use"] = False
ob["rs_shotshape_shape"] = ""
ob["rs_shotshape_nav"] = 0
ob["rs_shotshape_nav_start"] = False
ob["rs_shotshape_offset"] = 1
ob["rs_shotshape_use_frames"] = False
else:
ob["rs_shot_include"]
ob["rs_shot_start"]
ob["rs_shot_end"]
ob["rs_shot_output"]
ob["rs_toggle_panel"]
ob["rs_settings_use"]
ob["rs_resolution_x"]
ob["rs_resolution_y"]
ob["rs_cycles_samples"]
ob["rs_shotshape_use"]
ob["rs_shotshape_shape"]
ob["rs_shotshape_nav"]
ob["rs_shotshape_nav_start"]
ob["rs_shotshape_offset"]
ob["rs_shotshape_use_frames"]
scn.rs_is_updating = False
#####################################
# Initialisation
#####################################
def init_props():
object = bpy.types.Object
scene = bpy.types.Scene
# Camera properties
object.rs_shot_include = BoolProperty(name="",
description="Include this shot during render", default=True)
object.rs_shot_start = IntProperty(name="Start",
description="First frame in this shot",
default=0, min=0, max=300000)
object.rs_shot_end = IntProperty(name="End",
description="Last frame in this shot",
default=0, min=0, max=300000)
object.rs_shot_output = StringProperty(name="",
description="Directory/name to save to", subtype='DIR_PATH')
object.rs_toggle_panel = BoolProperty(name="",
description="Show/hide options for this shot", default=True)
# Render settings
object.rs_settings_use = BoolProperty(name = "", default=False,
description = "Use specific render settings for this shot")
object.rs_resolution_x = IntProperty(name="X",
description="Number of horizontal pixels in the rendered image",
default=2000, min=4, max=10000)
object.rs_resolution_y = IntProperty(name="Y",
description = "Number of vertical pixels in the rendered image",
default=2000, min=4, max=10000)
object.rs_cycles_samples = IntProperty(name="Samples",
description = "Number of samples to render for each pixel",
default=10, min=1, max=2147483647)
# Shot shapes
object.rs_shotshape_use = BoolProperty(name="", default=False,
description="Use a shape to set a series of shots for this camera")
object.rs_shotshape_shape = StringProperty(name="Shape:",
description="Select an object")
object.rs_shotshape_nav = IntProperty(name="Navigate",
description="Navigate through this shape's vertices (0 = first vertex)",
default=0, update=shape_nav)
object.rs_shotshape_nav_start = BoolProperty(name="Start from here",
default=False,
description="Start from this vertex (skips previous vertices)")
object.rs_shotshape_offset = IntProperty(name="Offset",
description="Offset between frames (defines animation length)",
default=1, min=1, max=200)
object.rs_shotshape_use_frames = BoolProperty(name="Use frame range",
description="Use the shot's frame range instead of the object's vertex"\
" count", default=False)
# Internal
scene.rs_is_updating = BoolProperty(name="", description="", default=False)
scene.rs_create_folders = BoolProperty(name="", description="", default=False)
scene.rs_main_folder = StringProperty(name="Main Folder",
subtype='DIR_PATH', default="",
description="Main folder in which to create the sub folders")
scene.rs_overwrite_folders = BoolProperty(name="Overwrite", default=False,
description="Overwrite existing folders (this will delete all"\
" files inside any existing folders)")
#####################################
# Operators and Functions
#####################################
RENDER_DONE = True
RENDER_SETTINGS_HELP = False
TIMELINE = {"start": 1, "end": 250, "current": 1}
RENDER_SETTINGS = {"cycles_samples": 10, "res_x": 1920, "res_y": 1080}
@persistent
def render_finished(unused):
global RENDER_DONE
RENDER_DONE = True
def using_cycles(scn):
return True if scn.render.engine == 'CYCLES' else False
def timeline_handler(scn, mode):
global TIMELINE
if mode == 'GET':
TIMELINE["start"] = scn.frame_start
TIMELINE["end"] = scn.frame_end
TIMELINE["current"] = scn.frame_current
elif mode == 'SET':
scn.frame_start = TIMELINE["start"]
scn.frame_end = TIMELINE["end"]
scn.frame_current = TIMELINE["current"]
def render_settings_handler(scn, mode, cycles_on, ob):
global RENDER_SETTINGS
if mode == 'GET':
RENDER_SETTINGS["cycles_samples"] = scn.cycles.samples
RENDER_SETTINGS["res_x"] = scn.render.resolution_x
RENDER_SETTINGS["res_y"] = scn.render.resolution_y
elif mode == 'SET':
if cycles_on:
scn.cycles.samples = ob["rs_cycles_samples"]
scn.render.resolution_x = ob["rs_resolution_x"]
scn.render.resolution_y = ob["rs_resolution_y"]
elif mode == 'REVERT':
if cycles_on:
scn.cycles.samples = RENDER_SETTINGS["cycles_samples"]
scn.render.resolution_x = RENDER_SETTINGS["res_x"]
scn.render.resolution_y = RENDER_SETTINGS["res_y"]
def frames_from_verts(ob, end, shape, mode):
start = ob.rs_shot_start
frame_range = (end - start)+1
verts = len(shape.data.vertices)
if frame_range % verts != 0:
end += 1
return create_frames_from_verts(ob, end, shape, mode)
else:
if mode == 'OFFSET':
return frame_range / verts
elif mode == 'END':
return end
def keyframes_handler(scn, ob, shape, mode):
bpy.ops.object.select_all(action='DESELECT')
ob.select_set(True)
start = ob.rs_shotshape_nav if ob.rs_shotshape_nav_start else 0
if ob.rs_shotshape_use_frames and shape is not None:
firstframe = ob.rs_shot_start
offset = frames_from_verts(ob, ob.rs_shot_end, shape, 'OFFSET')
else:
firstframe = 1
offset = ob.rs_shotshape_offset
if mode == 'SET':
scn.frame_current = firstframe
for vert in shape.data.vertices:
if vert.index >= start:
ob.location = vert.co
bpy.ops.anim.keyframe_insert_menu(type='Location')
scn.frame_current += offset
return (len(shape.data.vertices) - start) * offset
elif mode == 'WIPE':
ob.animation_data_clear()
class RENDER_OT_RenderShots_create_folders(bpy.types.Operator):
''' Create the output folders for all cameras '''
bl_idname = "render.rendershots_create_folders"
bl_label = "Create Folders"
mode = IntProperty()
def execute(self, context):
scn = context.scene
if self.mode == 1: # Display options
scn.rs_create_folders = True
elif self.mode == 2: # Create folders
if scn.rs_main_folder != "" and not scn.rs_main_folder.isspace():
for ob in bpy.data.objects:
if ob.type == 'CAMERA' and not is_new_object(ob):
# Name cleaning
if "." in ob.name:
name = ob.name.split(".")
camName = name[0]+name[1]
else:
camName = ob.name
mainFolder = scn.rs_main_folder
destination = os.path.join(mainFolder, camName)
# Folder creation
if scn.rs_overwrite_folders:
if os.path.isdir(destination):
shutil.rmtree(destination)
os.mkdir(destination)
ob.rs_shot_output = destination+"\\"
else:
if not os.path.isdir(destination):
ob.rs_shot_output = destination+"\\"
os.makedirs(destination_path)
self.report({'INFO'}, "Output folders created")
scn.rs_overwrite_folders = False
scn.rs_create_folders = False
else:
self.report({'ERROR'}, "No main folder selected")
elif self.mode == 3: # Cancelled
scn.rs_overwrite_folders = False
scn.rs_create_folders = False
return {'FINISHED'}
class RENDER_OT_RenderShots_settingshelp(bpy.types.Operator):
''' \
Edit the resolutions and see the changes in 3D View ('ESC' to finish)\
'''
bl_idname = "render.rendershots_settingshelp"
bl_label = "Render Settings Help"
cam = StringProperty()
def execute(self, context):
global RENDER_SETTINGS_HELP
RENDER_SETTINGS_HELP = True
scn = context.scene
render_settings_handler(scn, 'GET', using_cycles(scn), None)
context.window_manager.modal_handler_add(self)
return {'RUNNING_MODAL'}
def modal(self, context, event):
scn = context.scene
ob = bpy.data.objects[self.cam]
if event.type in {'ESC'}:
global RENDER_SETTINGS_HELP
RENDER_SETTINGS_HELP = False
render_settings_handler(scn, 'REVERT', using_cycles(scn), None)
return {'FINISHED'}
scn.render.resolution_x = ob["rs_resolution_x"]
scn.render.resolution_y = ob["rs_resolution_y"]
return {'PASS_THROUGH'}
class RENDER_OT_RenderShots_constraints_add(bpy.types.Operator):
''' Add the tracking constraints and Empty for this camera '''
bl_idname = "render.rendershots_constraints_add"
bl_label = "Create Constraints"
cam: StringProperty()
def execute(self, context):
ob = bpy.data.objects[self.cam]
ssName = "LookAt_for_"+ob.name
bpy.ops.object.add(type="EMPTY")
context.active_object.name = ssName
target = bpy.data.objects[ssName]
ob.constraints.new(type="DAMPED_TRACK").name="SS_Damped"
damped_track = ob.constraints["SS_Damped"]
damped_track.target = target
damped_track.track_axis = 'TRACK_NEGATIVE_Z'
damped_track.influence = 0.994
ob.constraints.new(type="LOCKED_TRACK").name="SS_Locked"
locked_track = ob.constraints["SS_Locked"]
locked_track.target = target
locked_track.track_axis = 'TRACK_Y'
locked_track.lock_axis = 'LOCK_Z'
locked_track.influence = 1.0
return {'FINISHED'}
class RENTER_OT_rendershots_refresh(bpy.types.Operator):
''' Adds newly created cameras to the list '''
bl_idname = "render.rendershots_refresh"
bl_label = "Refresh"
def execute(self, context):
update_shot_list(context.scene)
return {'FINISHED'}
class RENDER_OT_RenderShots_render(bpy.types.Operator):
''' Render shots '''
bl_idname = "render.rendershots_render"
bl_label = "Render"
animation: BoolProperty(default=False)
_timer = None
_usingShape = False
def execute(self, context):
global RENDER_DONE
RENDER_DONE = True
scn = context.scene
self.camList = []
self.vertTrack = -1
self.cam = ""
for ob in bpy.data.objects:
if ob.type == 'CAMERA' and not is_new_object(ob):
if ob["rs_shot_include"]:
output = ob["rs_shot_output"]
addToList = False
if output != "" and not output.isspace():
addToList = True
else:
message = "\"%s\" has no output destination" % ob.name
self.report({'WARNING'}, message)
if ob["rs_shotshape_use"]:
shotShape = ob["rs_shotshape_shape"]
if shotShape == "":
addToList = False
self.report({'WARNING'},
"\"%s\" has no shot shape" % ob.name)
elif bpy.data.objects[shotShape].type != 'MESH':
errObj = bpy.data.objects[shotShape].name
addToList = False
self.report({'ERROR'},
"\"%s\" is not a mesh object" % errObj)
#else:
# bpy.data.objects[shotShape].hide_render = True
if addToList:
self.camList.append(ob.name)
self.camList.reverse()
timeline_handler(scn, 'GET')
render_settings_handler(scn, 'GET', using_cycles(scn), None)
context.window_manager.modal_handler_add(self)
self._timer = context.window_manager.event_timer_add(3, context.window)
return {'RUNNING_MODAL'}
def modal(self, context, event):
global RENDER_DONE
scn = context.scene
if event.type in {'ESC'}:
context.window_manager.event_timer_remove(self._timer)
keyframes_handler(scn, bpy.data.objects[self.cam], None, 'WIPE')
render_settings_handler(scn, 'REVERT', using_cycles(scn), None)
timeline_handler(scn, 'SET')
return {'CANCELLED'}
if RENDER_DONE and self.camList:
RENDER_DONE = False
objs = bpy.data.objects
range = 0
if self._usingShape:
keyframes_handler(scn, objs[self.cam], None, 'WIPE')
self._usingShape = False
if not self._usingShape and self.camList:
self.cam = self.camList.pop()
ob = objs[self.cam]
# Output and name cleaning
scn.camera = ob
output = ob["rs_shot_output"]
if output[-1] == "/" or output[-1] == "\\":
if "." in self.cam:
camName = self.cam.split(".")
output += camName[0]+camName[1]
else:
output += self.cam
# Shot shapes
if ob["rs_shotshape_use"]:
self._usingShape = True
shape = ob["rs_shotshape_shape"]
range = keyframes_handler(scn, ob, objs[shape], 'SET')
# Render settings
if ob["rs_settings_use"]:
render_settings_handler(scn, 'SET', using_cycles(scn), ob)
else:
render_settings_handler(scn, 'REVERT', using_cycles(scn), None)
context.scene.render.filepath = output
# Render
ssUsing = ob["rs_shotshape_use"]
if self.animation and not ssUsing and not self._usingShape:
scn.frame_start = ob["rs_shot_start"]
scn.frame_end = ob["rs_shot_end"]
bpy.ops.render.render('INVOKE_DEFAULT', animation=True)
elif self.animation and ssUsing and self._usingShape:
if ob["rs_shotshape_use_frames"]:
scn.frame_start = ob.rs_shot_start
scn.frame_end = frames_from_verts(ob, ob.rs_shot_end,
objs[shape], 'END')
else:
scn.frame_start = 1
scn.frame_end = range
bpy.ops.render.render('INVOKE_DEFAULT', animation=True)
elif not self.animation and not ssUsing and not self._usingShape:
bpy.ops.render.render('INVOKE_DEFAULT', write_still=True)
elif RENDER_DONE and not self.camList:
context.window_manager.event_timer_remove(self._timer)
keyframes_handler(scn, bpy.data.objects[self.cam], None, 'WIPE')
render_settings_handler(scn, 'REVERT', using_cycles(scn), None)
timeline_handler(scn, 'SET')
return {'FINISHED'}
return {'PASS_THROUGH'}
class RENDER_OT_RenderShots_previewcamera(bpy.types.Operator):
''' Preview this shot (makes this the active camera in 3D View) '''
bl_idname = "render.rendershots_preview_camera"
bl_label = "Preview Camera"
camera = bpy.props.StringProperty()
def execute(self, context):
scn = context.scene
cam = bpy.data.objects[self.camera]
scn.objects.active = cam
scn.camera = cam
return {'FINISHED'}
#####################################
# UI
#####################################
class RENDER_PT_RenderShots(bpy.types.Panel):
bl_label = "Render Shots"
bl_space_type = "PROPERTIES"
bl_region_type = "WINDOW"
bl_context = "render"
def draw(self, context):
global RENDER_SETTINGS_HELP
layout = self.layout
scn = context.scene
ANI_ICO, STILL_ICO = "RENDER_ANIMATION", "RENDER_STILL"
INCL_ICO = "RESTRICT_RENDER_OFF"
RENDER_OP = "render.rendershots_render"
row = layout.row()
row.operator(RENDER_OP, text="Image", icon=STILL_ICO)
row.operator(RENDER_OP, text="Animation", icon=ANI_ICO).animation=True
row = layout.row()
if scn.rs_create_folders:
row.operator("render.rendershots_create_folders",
icon="FILE_TICK").mode=2
else:
row.operator("render.rendershots_create_folders",
icon="NEWFOLDER").mode=1
row.operator("render.rendershots_refresh", icon="FILE_REFRESH")
if scn.rs_create_folders:
row = layout.row()
col = row.column(align=True)
colrow = col.row()
colrow.label(text="Main Folder:")
colrow = col.row()
colrow.prop(scn, "rs_main_folder", text="")
colrow = col.row()
colrow.prop(scn, "rs_overwrite_folders")
colrow.operator("render.rendershots_create_folders", text="Cancel",
icon="X").mode=3
if not scn.rs_is_updating:
for ob in bpy.data.objects:
if ob.type == 'CAMERA' and not is_new_object(ob):
TOGL_ICO = "TRIA_DOWN" if ob["rs_toggle_panel"] else "TRIA_LEFT"