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)