mirror of
https://github.com/blw1138/Zordon.git
synced 2025-12-17 16:58:12 +00:00
212 lines
8.7 KiB
Python
212 lines
8.7 KiB
Python
#!/usr/bin/env python3
|
|
import json
|
|
import re
|
|
from utilities.render_worker import *
|
|
|
|
|
|
class BlenderRenderWorker(BaseRenderWorker):
|
|
|
|
renderer = 'Blender'
|
|
render_engine = 'blender'
|
|
supported_extensions = ['.blend']
|
|
install_paths = ['/Applications/Blender.app/Contents/MacOS/Blender']
|
|
supported_export_formats = ['TGA', 'RAWTGA', 'JPEG', 'IRIS', 'IRIZ', 'AVIRAW', 'AVIJPEG', 'PNG', 'BMP', 'HDR',
|
|
'TIFF', 'OPEN_EXR', 'OPEN_EXR_MULTILAYER', 'MPEG', 'CINEON', 'DPX', 'DDS', 'JP2']
|
|
|
|
def __init__(self, input_path, output_path, args=None):
|
|
super(BlenderRenderWorker, self).__init__(input_path=input_path, output_path=output_path,
|
|
ignore_extensions=False, args=args)
|
|
|
|
# Args
|
|
self.engine = self.args.get('engine', 'BLENDER_EEVEE').upper()
|
|
self.export_format = self.args.get('export_format', None) or 'JPEG'
|
|
self.camera = self.args.get('camera', None)
|
|
self.render_all_frames = self.args.get('render_all_frames', False)
|
|
self.frame_to_render = 0
|
|
|
|
# Stats
|
|
self.__frame_percent_complete = 0.0
|
|
|
|
# Scene Info
|
|
self.scene_info = get_scene_info(input_path)
|
|
self.total_frames = (int(self.scene_info.get('frame_end', 0)) - int(self.scene_info.get('frame_start', 0)) + 1) \
|
|
if self.render_all_frames else 1
|
|
self.current_frame = int(self.scene_info.get('frame_start', 0))
|
|
|
|
@classmethod
|
|
def version(cls):
|
|
version = None
|
|
try:
|
|
render_path = cls.renderer_path()
|
|
if render_path:
|
|
ver_out = subprocess.check_output([render_path, '-v'])
|
|
version = ver_out.decode('utf-8').splitlines()[0].replace('Blender', '').strip()
|
|
except Exception as e:
|
|
logging.error(f'Failed to get {cls.renderer} version: {e}')
|
|
return version
|
|
|
|
def _generate_subprocess(self):
|
|
|
|
cmd = [self.renderer_path()]
|
|
if self.args.get('background', True): # optionally run render not in background
|
|
cmd.append('-b')
|
|
cmd.append(self.input_path)
|
|
|
|
if self.camera:
|
|
cmd.extend(['--python-expr', f"import bpy;bpy.context.scene.camera = bpy.data.objects['{self.camera}'];"])
|
|
|
|
cmd.extend(['-E', self.engine, '-o', self.output_path, '-F', self.export_format])
|
|
|
|
# all frames or single
|
|
cmd.extend(['-a'] if self.render_all_frames else ['-f', str(self.frame_to_render)])
|
|
|
|
# Convert raw args from string if available
|
|
raw_args = self.args.get('raw', None)
|
|
if raw_args:
|
|
cmd.extend(raw_args.split(' '))
|
|
|
|
return cmd
|
|
|
|
def _parse_stdout(self, line):
|
|
|
|
pattern = re.compile(
|
|
r'Fra:(?P<frame>\d*).*Mem:(?P<memory>\S+).*Time:(?P<time>\S+)(?:.*Remaining:)?(?P<remaining>\S*)')
|
|
found = pattern.search(line)
|
|
if found:
|
|
stats = found.groupdict()
|
|
memory_use = stats['memory']
|
|
time_elapsed = stats['time']
|
|
time_remaining = stats['remaining'] or 'Unknown'
|
|
|
|
sample_string = line.split('|')[-1].strip()
|
|
if "sample" in sample_string.lower():
|
|
samples = re.sub(r'[^\d/]', '', sample_string)
|
|
self.__frame_percent_complete = int(samples.split('/')[0]) / int(samples.split('/')[-1])
|
|
|
|
# Calculate rough percent based on cycles
|
|
# EEVEE
|
|
# 10-Apr-22 22:42:06 - RENDERER: Fra:0 Mem:857.99M (Peak 928.55M) | Time:00:03.96 | Rendering 1 / 65 samples
|
|
# 10-Apr-22 22:42:10 - RENDERER: Fra:0 Mem:827.09M (Peak 928.55M) | Time:00:07.92 | Rendering 26 / 64 samples
|
|
# 10-Apr-22 22:42:10 - RENDERER: Fra:0 Mem:827.09M (Peak 928.55M) | Time:00:08.17 | Rendering 51 / 64 samples
|
|
# 10-Apr-22 22:42:10 - RENDERER: Fra:0 Mem:827.09M (Peak 928.55M) | Time:00:08.31 | Rendering 64 / 64 samples
|
|
|
|
# CYCLES
|
|
# 10-Apr-22 22:43:22 - RENDERER: Fra:0 Mem:836.30M (Peak 1726.13M) | Time:00:01.56 | Remaining:00:30.65 | Mem:588.68M, Peak:588.68M | Scene, View Layer | Sample 1/150
|
|
# 10-Apr-22 22:43:43 - RENDERER: Fra:0 Mem:836.30M (Peak 1726.13M) | Time:00:22.01 | Remaining:00:03.36 | Mem:588.68M, Peak:588.68M | Scene, View Layer | Sample 129/150
|
|
|
|
if int(stats['frame']) > self.current_frame:
|
|
self.current_frame = int(stats['frame'])
|
|
logger.debug(
|
|
'Frame:{0} | Mem:{1} | Time:{2} | Remaining:{3}'.format(self.current_frame, memory_use,
|
|
time_elapsed, time_remaining))
|
|
elif 'error' in line.lower():
|
|
logger.error(line)
|
|
self.errors.append(line)
|
|
elif 'Saved' in line or 'Saving' in line or 'quit' in line:
|
|
match = re.match(r'Time: (.*) \(Saving', line)
|
|
if match:
|
|
time_completed = match.groups()[0]
|
|
if self.render_all_frames:
|
|
logger.debug(f'Frame {self.current_frame} completed in {time_completed}')
|
|
else:
|
|
logger.info(f'Render completed in {time_completed}')
|
|
else:
|
|
logger.debug(line)
|
|
else:
|
|
pass
|
|
# if len(line.strip()):
|
|
# logger.debug(line.strip())
|
|
|
|
def percent_complete(self):
|
|
if self.total_frames <= 1:
|
|
return self.__frame_percent_complete
|
|
else:
|
|
whole_frame_percent = (self.current_frame - 1) / self.total_frames
|
|
adjusted_frame_percent = self.__frame_percent_complete / self.total_frames
|
|
total_percent = whole_frame_percent + adjusted_frame_percent
|
|
return max(total_percent, 0)
|
|
|
|
|
|
def run_python_expression_in_blend(path, python_expression):
|
|
if os.path.exists(path):
|
|
try:
|
|
return subprocess.run([BlenderRenderWorker.renderer_path(), '-b', path, '--python-expr', python_expression],
|
|
capture_output=True)
|
|
except Exception as e:
|
|
logger.warning(f"Error running python expression in blender: {e}")
|
|
pass
|
|
else:
|
|
raise FileNotFoundError
|
|
|
|
|
|
def run_python_script_in_blend(path, python_path):
|
|
if os.path.exists(path) and os.path.exists(python_path):
|
|
try:
|
|
return subprocess.run([BlenderRenderWorker.renderer_path(), '-b', path, '--python', python_path],
|
|
capture_output=True)
|
|
except Exception as e:
|
|
logger.warning(f"Error running python expression in blender: {e}")
|
|
pass
|
|
else:
|
|
raise FileNotFoundError
|
|
|
|
|
|
def pack_blender_files(path):
|
|
# Credit to L0Lock for pack script - https://blender.stackexchange.com/a/243935
|
|
pack_script = "import bpy\n" \
|
|
"bpy.ops.file.pack_all()\n" \
|
|
"myPath = bpy.data.filepath\n" \
|
|
"myPath = str(myPath)\n" \
|
|
"bpy.ops.wm.save_as_mainfile(filepath=myPath[:-6]+'_packed'+myPath[-6:])"
|
|
|
|
try:
|
|
results = run_python_expression_in_blend(path, pack_script)
|
|
|
|
result_text = results.stdout.decode()
|
|
dir_name = os.path.dirname(path)
|
|
|
|
# report any missing textures
|
|
not_found = re.findall("(Unable to pack file, source path .*)\n", result_text)
|
|
for err in not_found:
|
|
logger.error(err)
|
|
|
|
p = re.compile('Info: Saved "(.*)"')
|
|
match = p.search(result_text)
|
|
if match:
|
|
new_path = os.path.join(dir_name, match.group(1))
|
|
logger.info(f'Blender file packed successfully to {new_path}')
|
|
return new_path
|
|
except Exception as e:
|
|
logger.error(f'Error packing .blend file: {e}')
|
|
return None
|
|
|
|
|
|
def get_scene_info(path):
|
|
|
|
scene_info = None
|
|
try:
|
|
results = run_python_script_in_blend(path, os.path.join(os.path.dirname(os.path.realpath(__file__)),
|
|
'scripts', 'get_blender_info.py'))
|
|
result_text = results.stdout.decode()
|
|
for line in result_text.splitlines():
|
|
if line.startswith('SCENE_DATA:'):
|
|
raw_data = line.split('SCENE_DATA:')[-1]
|
|
scene_info = json.loads(raw_data)
|
|
break
|
|
except Exception as e:
|
|
logger.error(f'Error getting file details for .blend file: {e}')
|
|
return scene_info
|
|
|
|
|
|
if __name__ == '__main__':
|
|
|
|
# x = pack_blender_files('/Users/brett/Blender Files/temple_animatic.blend')
|
|
# print(x)
|
|
|
|
logging.basicConfig(format='%(asctime)s - %(message)s', datefmt='%d-%b-%y %H:%M:%S', level=logging.DEBUG)
|
|
r = BlenderRenderWorker('/Users/brett/Blender Files/temple_animatic.blend', '/Users/brett/testing1234')
|
|
# r.engine = 'CYCLES'
|
|
r.start()
|
|
while r.is_running():
|
|
time.sleep(1)
|