def CopyDRAsset(bus, srcFilepath):
scene = bus['scene']
VRayScene = scene.vray
VRayDR = VRayScene.VRayDR
srcFilepath = os.path.normpath(srcFilepath)
dstRoot = CreateDirectory(bpy.path.abspath(VRayDR.shared_dir))
ExtToSubdir = {
'ies': "ies",
'lens': "misc",
'vrmesh': "proxy",
'vrmap': "lightmaps",
'vrst': "lightmaps",
'vrsm': "lightmaps",
}
srcFilename = os.path.basename(srcFilepath)
srcFiletype = os.path.splitext(srcFilename)[1]
assetSubdir = ExtToSubdir.get(srcFiletype.lower(), "textures")
if assetSubdir:
dstRoot = CreateDirectory(os.path.join(dstRoot, assetSubdir))
dstFilepath = os.path.join(dstRoot, srcFilename)
if not os.path.exists(srcFilepath):
# debug.PrintError('"%s" file does not exists!' % srcFilepath)
return srcFilepath
if not os.path.isfile(srcFilepath):
debug.PrintError('"%s" is not a file!' % srcFilepath)
return srcFilepath
else:
if os.path.exists(dstFilepath):
if not filecmp.cmp(srcFilepath, dstFilepath):
debug.Debug('Copying "%s" to "%s"' %
(debug.Color(srcFilename, 'magenta'), dstRoot))
shutil.copyfile(srcFilepath, dstFilepath)
else:
debug.Debug('File "%s" exists and not modified.' %
debug.Color(srcFilename, 'magenta'))
else:
debug.Debug('Copying "%s" to "%s"' %
(debug.Color(srcFilename, 'magenta'), dstRoot))
shutil.copyfile(srcFilepath, dstFilepath)
if VRayDR.networkType == 'WW':
return pathlib.Path(r'\\') / SysUtils.GetHostname(
) / VRayDR.share_name / assetSubdir / srcFilename
return dstFilepath
def _check_process(self):
_, port, log_lvl = self._get_settings()
if self._zmq_process is not None:
self._zmq_process.poll()
debug.Debug("ZMQ: %s -> code[%s]" %
(self._zmq_process, self._zmq_process.returncode))
if self._zmq_process is None or self._zmq_process.returncode is not None:
executable_path = SysUtils.GetZmqPath()
if not executable_path or not os.path.exists(executable_path):
debug.PrintError("Can't find V-Ray ZMQ Server!")
return
envAppSDK = os.environ.copy()
def _joinPath(*args):
return os.path.normpath(os.path.join(*args))
def _extendEnv(env, name, value):
prevValue = env.get(name, None)
env[name] = value
if prevValue:
env[name] += "%s%s" % (os.pathsep, prevValue)
appSdkDir = _joinPath(os.path.dirname(executable_path), "appsdk")
envAppSDK['VRAY_ZMQSERVER_APPSDK_PATH'] = os.environ.get(
'VRAY_ZMQSERVER_APPSDK_PATH', appSdkDir)
envAppSDK['VRAY_PATH'] = appSdkDir
envAppSDK['QT_PLUGIN_PATH'] = appSdkDir
envAppSDK['QT_QPA_PLATFORM_PLUGIN_PATH'] = _joinPath(
appSdkDir, "platforms")
if sys.platform == "win32":
_extendEnv(envAppSDK, 'PATH', appSdkDir)
elif sys.platform == "linux":
_extendEnv(envAppSDK, 'LD_LIBRARY_PATH', appSdkDir)
elif sys.platform == "darwin":
_extendEnv(envAppSDK, 'DYLD_FALLBACK_LIBRARY_PATH', appSdkDir)
cmd = [
executable_path, "-p", port, "-log",
self.log_lvl_translate[log_lvl], "-vfb"
]
debug.Debug(' '.join(cmd))
try:
self.start_heartbeat()
self._zmq_process = subprocess.Popen(cmd, env=envAppSDK)
except Exception as e:
debug.PrintError(e)
def CreateDirectory(directory):
directory = path_sep_to_unix(directory)
if not os.path.exists(directory):
debug.Debug('Creating directory "%s"...' % directory)
try:
os.makedirs(directory)
except OSError:
debug.Debug('Error creating directory: "%s"' % directory, msgType='ERROR')
directory = tempfile.gettempdir()
debug.Debug("Using TMP path: %s" % directory)
return os.path.expanduser(directory)
def ExportCameraLoop(bus):
scene = bus['scene']
engine = bus['engine']
camera = bus['camera']
o = bus['output']
VRayScene = scene.vray
VRayExporter = VRayScene.Exporter
cameras = GetLoopCameras(scene)
if not len(cameras):
return 'No cameras are selected for "Camera Loop"!'
cameras = sorted(cameras, key=lambda c: c.name)
# We will create animated camera from 'cameras'
o.setAnimation(True)
o.setFrameStart(1)
o.setFrameEnd(len(cameras))
o.setFrameStep(1)
if IsHideFromViewUsed(cameras):
debug.Debug('Using "Hide From View"...')
# Since hide from view affect object properties we have to export in
# animation mode
exp_init.InitAnimation(bus, isAnimation=True)
for i, camera in enumerate(cameras):
# Setup camera
bus['camera'] = camera
# Setup fake frame
frame = i+1
o.setFrame(frame)
_vray_for_blender.setFrame(frame)
# Since we are using 'Hide From View' we have to update
# object's visibilities.
# Export meshes only for the first frame since
# 'Hide From View' affects only object level.
#
exp_scene.ExportScene(bus, exportNodes=True, exportMeshes=(frame==1))
else:
# Export objects as usual
exp_scene.ExportScene(bus)
# Export animated camera from 'Camera Loop' cameras
for i, camera in enumerate(cameras):
# Setup camera
bus['camera'] = camera
# Setup fake frame
frame = i+1
o.setFrame(frame)
exp_camera.ExportCamera(bus)
def render(self, scene):
debug.Debug("render()")
vrayExporter = self._get_settings()
use_std = vrayExporter.backend == 'STD'
if use_std:
super().render(scene)
elif self.renderer:
_vray_for_blender_rt.render(self.renderer)
def stop(self):
if self.is_running():
try:
debug.Debug('Zmq stopped - stopping all viewports')
self.stop_heartbeat()
if self._zmq_process:
debug.Debug('Zmq terminating process')
self._zmq_process.terminate()
for area in bpy.context.screen.areas:
if area.type == 'VIEW_3D':
for space in area.spaces:
if space.type == 'VIEW_3D' and space.viewport_shade == 'RENDERED':
space.viewport_shade = 'SOLID'
except Exception as e:
debug.PrintError(e)
else:
debug.Debug("Not running - cant stop")
def LoadImage(scene, engine, o, p):
debug.Debug("LoadImage()")
VRayScene = scene.vray
VRayExporter = VRayScene.Exporter
if VRayExporter.animation_mode not in {'NONE'}:
return
imageToBlender = VRayExporter.auto_save_render and VRayExporter.image_to_blender
if not (engine.is_preview or imageToBlender):
return
pm = o.getFileManager().getPathManager()
imageFile = pm.getImgLoadFilepath()
# There was some version that was always adding frame number
imageFilePreviewCompat = imageFile.replace(
"preview.exr", "preview.000%i.exr" % scene.frame_current)
resolution_x = int(scene.render.resolution_x *
scene.render.resolution_percentage * 0.01)
resolution_y = int(scene.render.resolution_y *
scene.render.resolution_percentage * 0.01)
# TODO: Create VRayImage loader and load image while rendering
#
while True:
if not p.is_running():
result = engine.begin_result(0, 0, resolution_x, resolution_y)
layer = result.layers[0]
try:
if os.path.exists(imageFile):
layer.load_from_file(imageFile)
elif engine.is_preview and os.path.exists(
imageFilePreviewCompat):
layer.load_from_file(imageFilePreviewCompat)
except Exception as e:
debug.Debug("Error loading file! [%s]" % e, msgType='ERROR')
engine.end_result(result)
break
time.sleep(0.1)
def RunEx(bus):
debug.Debug("RunEx()")
try:
Run(bus)
except Exception as e:
debug.ExceptionInfo(e)
return "Run error: %s" % e
return None
def start_heartbeat(self):
addr, port, _ = self._get_settings()
ip = 'localhost'
try:
ip = str(ipaddress.ip_address(str(addr)))
except:
debug.PrintError("Failed parsing ip addr from [%s], falling back to %s" % (addr, ip))
bpy.context.scene.vray.Exporter.zmq_address = ip
self._heartbeat_running = _vray_for_blender_rt.zmq_heartbeat_start("tcp://%s:%s" % (ip, port))
debug.Debug('ZMQ starting heartbeat = %s' % self._heartbeat_running)
def __init__(self):
_vray_for_blender_rt.set_preview_dir(PathUtils.GetPreviewDir())
VRayRendererRT.backgroundRendererInstance += 1
self.canRender = True
if bpy.app.background:
# when in background mode, Blender's animation handler will create
# the renderer for each frame, but we will do all the work on the first
# call so we ignore all others
self.canRender = VRayRendererRT.backgroundRendererInstance == 1
self.parseArguments()
debug.Debug("__init__()")
self.renderer = None
def _check_process(self):
_, port, log_lvl = self._get_settings()
if self._zmq_process is not None:
self._zmq_process.poll()
debug.Debug("ZMQ: %s -> code[%s]" %
(self._zmq_process, self._zmq_process.returncode))
if self._zmq_process is None or self._zmq_process.returncode is not None:
executable_path = SysUtils.GetZmqPath()
if not executable_path or not os.path.exists(executable_path):
debug.PrintError("Can't find V-Ray ZMQ Server!")
else:
try:
env = os.environ.copy()
if sys.platform == "win32":
if 'VRAY_ZMQSERVER_APPSDK_PATH' not in env:
debug.PrintError(
'Environment variable VRAY_ZMQSERVER_APPSDK_PATH is missing!'
)
else:
appsdk = os.path.dirname(
env['VRAY_ZMQSERVER_APPSDK_PATH'])
env['PATH'] = env['PATH'] + os.pathsep + appsdk
env['VRAY_PATH'] = appsdk
old_ld = (os.pathsep + env['LD_LIBRARY_PATH']
) if 'LD_LIBRARY_PATH' in env else ''
env['LD_LIBRARY_PATH'] = appsdk + old_ld
cmd = [
executable_path, "-p", port, "-log",
self.log_lvl_translate[log_lvl], "-vfb"
]
debug.Debug(' '.join(cmd))
self.start_heartbeat()
self._zmq_process = subprocess.Popen(cmd, env=env)
except Exception as e:
debug.PrintError(e)
def ExportSingleFrame(bus):
o = bus['output']
scene = bus['scene']
err = None
VRayScene = scene.vray
VRayExporter = VRayScene.Exporter
mb_duration, mb_interval_center = GetMotionBlurFrames(bus)
if mb_duration:
debug.Debug("MB Duration: %.3f sec" % mb_duration)
debug.Debug("MB Interval Center: %.3f sec" % mb_interval_center)
if mb_duration < 1.0:
mb_duration = 1.0
# We need to export +1 frames data
mb_duration += 1
frameStart = scene.frame_current
frameEnd = frameStart + mb_duration - 1
frameStep = scene.frame_step
o.setAnimation(True)
o.setFrameStart(frameStart)
o.setFrameEnd(frameEnd)
o.setFrameStep(frameStep)
err = exp_anim_full.ExportFullRange(bus)
else:
_vray_for_blender.setFrame(scene.frame_current)
err = exp_scene.ExportScene(bus)
return err
def view_update(self, context):
debug.Debug("view_update()")
ZMQ.check_start()
if not self.renderer:
self.renderer = _vray_for_blender_rt.init_rt(
context=context.as_pointer(),
engine=self.as_pointer(),
data=bpy.data.as_pointer(),
scene=bpy.context.scene.as_pointer(),
)
if self.renderer:
_vray_for_blender_rt.view_update(self.renderer)
def render(self, scene):
if not self.doRender():
return
debug.Debug("render()")
vrayExporter = self.getExporter()
use_std = vrayExporter.backend == 'STD'
if use_std:
super().render(scene)
if bpy.app.background:
# free renderer so we close and flush all files
self._free_renderer()
# in backgorund mode we render only once, so exit here to force
# Blender not rendering more frames and not wrinting files
sys.exit(0)
elif self.renderer:
_vray_for_blender_rt.render(self.renderer)
def update(self, data, scene):
debug.Debug("update()")
vrayExporter = self._get_settings()
if vrayExporter.backend != 'STD':
ZMQ.check_start()
# Init ZMQ exporter
if not self.renderer:
arguments = {
'context': bpy.context.as_pointer(),
'engine': self.as_pointer(),
'data': data.as_pointer(),
'scene': scene.as_pointer(),
}
self.renderer = _vray_for_blender_rt.init(**arguments)
if self.renderer:
_vray_for_blender_rt.update(self.renderer)
def Run(bus):
debug.Debug("Run()")
scene = bus['scene']
engine = bus['engine']
o = bus['output']
VRayScene = scene.vray
VRayExporter = VRayScene.Exporter
VRayDR = VRayScene.VRayDR
vrayCmd = SysUtils.GetVRayStandalonePath()
if not vrayCmd:
raise Exception("V-Ray not found!")
imageToBlender = VRayExporter.animation_mode == 'NONE' and not scene.render.use_border and VRayExporter.auto_save_render and VRayExporter.image_to_blender
p = VRayProcess()
p.setVRayStandalone(vrayCmd)
p.setSceneFile(o.fileManager.getOutputFilepath())
p.setAutorun(VRayExporter.autorun)
p.setVerboseLevel(VRayExporter.verboseLevel)
p.setShowProgress(VRayExporter.showProgress)
p.setDisplaySRGB(scene.display_settings.display_device == 'sRGB')
p.setDisplayVFB(VRayExporter.display)
p.setAutoclose(VRayExporter.autoclose)
if SysUtils.IsGPUEngine(bus):
p.setRtEngine(VRayExporter.device_gpu_type, VRayScene.SettingsRTEngine)
# TODO: Rewrite into 'SettingsOutput'
if scene.render.use_border:
resolution_x = int(scene.render.resolution_x *
scene.render.resolution_percentage * 0.01)
resolution_y = int(scene.render.resolution_y *
scene.render.resolution_percentage * 0.01)
x0 = resolution_x * scene.render.border_min_x
y0 = resolution_y * (1.0 - scene.render.border_max_y)
x1 = resolution_x * scene.render.border_max_x
y1 = resolution_y * (1.0 - scene.render.border_min_y)
p.setRegion(x0, y0, x1, y1, useCrop=scene.render.use_crop_to_border)
if imageToBlender:
p.setWaitExit(True)
p.setAutoclose(True)
if engine.is_preview:
p.setPreview(True)
p.setShowProgress(0)
p.setVerboseLevel(0)
p.setAutoclose(True)
p.setDisplayVFB(False)
if VRayDR.on:
if len(VRayDR.nodes):
transferAssets = VRayDR.assetSharing == 'TRANSFER'
if transferAssets:
if VRayDR.checkAssets:
transferAssets = 2
p.setDistributed(2 if VRayDR.renderOnlyOnNodes else 1)
hosts = []
for n in VRayDR.nodes:
if n.use:
hosts.append("%s:%s" %
(n.address,
n.port) if n.port_override else n.address)
p.setRenderhosts(hosts)
p.setPortNumber(VRayDR.port)
p.setTransferAssets(transferAssets)
p.setLimitHosts(VRayDR.limitHosts)
if VRayExporter.animation_mode == 'NONE':
p.setFrames(scene.frame_current)
elif VRayExporter.animation_mode == 'FRAMEBYFRAME':
p.setWaitExit(True)
p.setAutoclose(True)
p.setFrames(scene.frame_current)
else:
p.setFrames(o.frameStart, o.frameEnd, o.frameStep)
if not scene.render.threads_mode == 'AUTO':
p.setThreads(scene.render.threads)
if bpy.app.background or VRayExporter.wait:
p.setWaitExit(True)
if bpy.app.background:
if not VRayExporter.display_vfb_in_batch:
p.setDisplayVFB(False) # Disable VFB
p.setAutoclose(True) # Exit on render end
if VRayExporter.gen_run_file:
p.setGenRunFile(True)
if VRayExporter.submit_to_vray_cloud:
p.setAutorun(False)
exportExitStatus = p.run()
if exportExitStatus == 0 and VRayExporter.submit_to_vray_cloud:
job = VCloudJob(bus)
cloudExitStatus = job.submitToCloud()
if cloudExitStatus == -404:
print("Chaos Cloud binary is not detected on your system!")
webbrowser.open("https://www.chaosgroup.com/cloud")
if imageToBlender or engine.is_preview:
exp_load.LoadImage(scene, engine, o, p)
def __del__(self):
debug.Debug("__del__()")
self._free_renderer()
def ExportEx(bus):
debug.Debug("ExportEx()")
err = None
scene = bus['scene']
engine = bus['engine']
o = bus['output']
VRayScene = scene.vray
VRayExporter = VRayScene.Exporter
VRayDR = VRayScene.VRayDR
pm = VRayFilePaths()
# Setting user defined value here
# It could be overriden in 'initFromScene'
# depending on VRayDR settings
pm.setSeparateFiles(VRayExporter.useSeparateFiles)
pm.initFromScene(engine, scene)
pm.printInfo()
fm = VRayExportFiles(pm)
fm.setOverwriteGeometry(VRayExporter.auto_meshes)
try:
fm.init()
except Exception as e:
debug.ExceptionInfo(e)
return "Error initing files!"
o.setFileManager(fm)
o.setPreview(engine.is_preview)
bus['exporter'] = exp_init.InitExporter(bus)
try:
# We do everything here basically because we want to close files
# if smth goes wrong...
rtExporter = HAS_VB35 and engine.bl_idname == 'VRAY_RENDER_RT'
if not rtExporter:
err = Export(bus, scene, engine, engine.is_preview)
else:
if not VRayExporter.animation_mode in {'NONE', 'CAMERA_LOOP'}:
o.setAnimation(True)
o.setFrameStart(scene.frame_start)
o.setFrameEnd(scene.frame_end)
o.setFrameStep(scene.frame_step)
elif VRayExporter.animation_mode == 'CAMERA_LOOP':
cameraCount = len([
1 for o in scene.objects
if o.type == 'CAMERA' and o.data.vray.use_camera_loop
])
o.setAnimation(True)
o.setFrameStart(1)
o.setFrameEnd(cameraCount)
o.setFrameStep(1)
init = {
'context': bpy.context.as_pointer(),
'engine': engine.as_pointer(),
'data': bpy.data.as_pointer(),
'scene': scene.as_pointer(),
'mainFile': fm.getFileByPluginType('MAIN'),
'objectFile': fm.getFileByPluginType('OBJECT'),
'envFile': fm.getFileByPluginType('WORLD'),
'geometryFile': fm.getFileByPluginType('GEOMETRY'),
'lightsFile': fm.getFileByPluginType('LIGHT'),
'materialFile': fm.getFileByPluginType('MATERIAL'),
'textureFile': fm.getFileByPluginType('TEXTURE'),
'cameraFile': fm.getFileByPluginType('CAMERA'),
}
# Free anything we have
if engine.renderer:
del engine.renderer
renderer = _vray_for_blender_rt.init(**init)
if renderer:
# Write settings for new exporter.
# TODO: Move this to cpp.
exp_settings.ExportSettings(bus)
setattr(engine, 'renderer', renderer)
_vray_for_blender_rt.render(renderer)
except Exception as e:
debug.ExceptionInfo(e)
err = str(e)
finally:
exp_init.ShutdownExporter(bus)
o.done()
return err
def __init__(self):
debug.Debug("__init__()")
self.renderer = None
def should_start(self):
should_start = self.use_zmq() and self.is_local()
debug.Debug('ZMQ should start %s' % should_start)
return should_start
def stop_heartbeat(self):
_vray_for_blender_rt.zmq_heartbeat_stop()
self._heartbeat_running = False
debug.Debug('ZMQ stopping heartbeat')
def __del__(self):
debug.Debug("__del__()")
if hasattr(self, 'renderer') and self.renderer is not None:
_vray_for_blender_rt.free(self.renderer)
