diff --git a/render_povray/render.py b/render_povray/render.py
index ee227b493d1d90bb638fb37f6475d6f2c9c9339b..78712b3a404fab5864e4e5444dac358e9d1a77f2 100644
--- a/render_povray/render.py
+++ b/render_povray/render.py
@@ -24,6 +24,7 @@ import os
import sys
import time
from math import atan, pi, degrees, sqrt
+import re
##############################SF###########################
##############find image texture
@@ -1364,6 +1365,7 @@ def write_pov(filename, scene=None, info_callback=None):
tabWrite("image_map{%s \"%s\" %s}\n" % (imageFormat(texturesBlend), texturesBlend, imgMapBG(t_blend)))
tabWrite("}\n")
tabWrite("%s\n" % (mappingBlend))
+ # The following layered pigment opacifies to black over the texture for transmit below 1 or otherwise adds to itself
tabWrite("pigment {rgb 0 transmit %s}\n" % (t.texture.intensity))
tabWrite("}\n")
#tabWrite("scale 2\n")
@@ -1529,8 +1531,8 @@ def write_pov(filename, scene=None, info_callback=None):
#print("pov file closed %s" % file.closed)
-def write_pov_ini(filename_ini, filename_pov, filename_image):
- scene = bpy.data.scenes[0]
+def write_pov_ini(scene, filename_ini, filename_pov, filename_image):
+ #scene = bpy.data.scenes[0]
render = scene.render
x = int(render.resolution_x * render.resolution_percentage * 0.01)
@@ -1549,8 +1551,8 @@ def write_pov_ini(filename_ini, filename_pov, filename_image):
file.write("Start_Column=%4g\n" % render.border_min_x)
file.write("End_Column=%4g\n" % (render.border_max_x))
- file.write("Start_Row=%4g\n" % (render.border_min_y))
- file.write("End_Row=%4g\n" % (render.border_max_y))
+ file.write("Start_Row=%4g\n" % (1.0-render.border_max_y))
+ file.write("End_Row=%4g\n" % (1.0-render.border_min_y))
file.write("Bounding_Method=2\n") # The new automatic BSP is faster in most scenes
@@ -1618,7 +1620,7 @@ class PovrayRender(bpy.types.RenderEngine):
except OSError:
pass
- write_pov_ini(self._temp_file_ini, self._temp_file_in, self._temp_file_out)
+ write_pov_ini(scene, self._temp_file_ini, self._temp_file_in, self._temp_file_out)
print ("***-STARTING-***")
@@ -1630,7 +1632,11 @@ class PovrayRender(bpy.types.RenderEngine):
for newArg in scene.pov_command_line_switches.split(" "):
extra_args.append(newArg)
+ self._is_windows = False
if sys.platform[:3] == "win":
+ self._is_windows = True
+ #extra_args.append("/EXIT")
+
import winreg
import platform as pltfrm
if pltfrm.architecture()[0] == "64bit":
@@ -1646,7 +1652,8 @@ class PovrayRender(bpy.types.RenderEngine):
if bitness == 64:
try:
pov_binary = winreg.QueryValueEx(regKey, "Home")[0] + "\\bin\\pvengine64"
- self._process = subprocess.Popen([pov_binary, self._temp_file_ini] + extra_args)
+ self._process = subprocess.Popen([pov_binary, self._temp_file_ini] + extra_args,
+ stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
# This would work too but means we have to wait until its done:
# os.system("%s %s" % (pov_binary, self._temp_file_ini))
@@ -1654,7 +1661,8 @@ class PovrayRender(bpy.types.RenderEngine):
# someone might run povray 32 bits on a 64 bits blender machine
try:
pov_binary = winreg.QueryValueEx(regKey, "Home")[0] + "\\bin\\pvengine"
- self._process = subprocess.Popen([pov_binary, self._temp_file_ini] + extra_args)
+ self._process = subprocess.Popen([pov_binary, self._temp_file_ini] + extra_args,
+ stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
except OSError:
# TODO, report api
@@ -1678,13 +1686,15 @@ class PovrayRender(bpy.types.RenderEngine):
else:
try:
pov_binary = winreg.QueryValueEx(regKey, "Home")[0] + "\\bin\\pvengine"
- self._process = subprocess.Popen([pov_binary, self._temp_file_ini] + extra_args)
+ self._process = subprocess.Popen([pov_binary, self._temp_file_ini] + extra_args,
+ stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
# someone might also run povray 64 bits with a 32 bits build of blender.
except OSError:
try:
pov_binary = winreg.QueryValueEx(regKey, "Home")[0] + "\\bin\\pvengine64"
- self._process = subprocess.Popen([pov_binary, self._temp_file_ini] + extra_args)
+ self._process = subprocess.Popen([pov_binary, self._temp_file_ini] + extra_args,
+ stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
except OSError:
# TODO, report api
@@ -1725,7 +1735,8 @@ class PovrayRender(bpy.types.RenderEngine):
return False
try:
- self._process = subprocess.Popen([pov_binary, self._temp_file_ini] + extra_args)
+ self._process = subprocess.Popen([pov_binary, self._temp_file_ini] + extra_args,
+ stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
except OSError:
# TODO, report api
@@ -1740,16 +1751,18 @@ class PovrayRender(bpy.types.RenderEngine):
print("Command line arguments passed: " + str(extra_args))
return True
+ # Now that we have a valid process
+
def _cleanup(self):
for f in (self._temp_file_in, self._temp_file_ini, self._temp_file_out):
- try:
- os.unlink(f)
- except OSError: # was that the proper error type?
- #print("POV-Ray 3.7: could not remove/unlink TEMP file %s" % f.name)
- pass
- #print("")
-
- self.update_stats("", "")
+ for i in range(5):
+ try:
+ os.unlink(f)
+ break
+ except OSError:
+ # Wait a bit before retrying file might be still in use by Blender,
+ # and Windows does not know how to delete a file in use!
+ time.sleep(self.DELAY)
def render(self, scene):
import tempfile
@@ -1864,84 +1877,147 @@ class PovrayRender(bpy.types.RenderEngine):
x = int(r.resolution_x * r.resolution_percentage * 0.01)
y = int(r.resolution_y * r.resolution_percentage * 0.01)
- # Wait for the file to be created
- while not os.path.exists(self._temp_file_out):
- # print("***POV WAITING FOR FILE***")
+ # This makes some tests on the render, returning True if all goes good, and False if
+ # it was finished one way or the other.
+ # It also pauses the script (time.sleep())
+ def _test_wait():
+ time.sleep(self.DELAY)
+
+ # User interrupts the rendering
if self.test_break():
try:
self._process.terminate()
print("***POV INTERRUPTED***")
except OSError:
pass
- break
+ return False
poll_result = self._process.poll()
+ # POV process is finisehd, one way or the other
if poll_result is not None:
- print("***POV PROCESS FAILED : %s ***" % poll_result)
- self.update_stats("", "POV-Ray 3.7: Failed")
- break
-
- time.sleep(self.DELAY)
-
- if os.path.exists(self._temp_file_out):
- # print("***POV FILE OK***")
- self.update_stats("", "POV-Ray 3.7: Rendering")
-
- prev_size = -1
+ if poll_result < 0:
+ print("***POV PROCESS FAILED : %s ***" % poll_result)
+ self.update_stats("", "POV-Ray 3.7: Failed")
+ return False
- def update_image():
- xmin = int(r.border_min_x * x)
- ymin = int(r.border_min_y * y)
- xmax = int(r.border_max_x * x)
- ymax = int(r.border_max_y * y)
+ return True
- # print("***POV UPDATING IMAGE***")
- result = self.begin_result(0, 0, x, y)
- #result = self.begin_result(xmin, ymin, xmax - xmin, ymax - ymin) # XXX, test for border render.
- lay = result.layers[0]
- # possible the image wont load early on.
- try:
- lay.load_from_file(self._temp_file_out)
- #lay.load_from_file(self._temp_file_out, xmin, ymin) # XXX, test for border render.
- except RuntimeError:
- pass
- self.end_result(result)
- # Update while POV-Ray renders
- while True:
- # print("***POV RENDER LOOP***")
+ # Wait for the file to be created
+ # XXX This is no more valid, as 3.7 always creates output file once render is finished!
+ parsing = re.compile(br"= \[Parsing\.\.\.\] =")
+ rendering = re.compile(br"= \[Rendering\.\.\.\] =")
+ percent = re.compile(r"\(([0-9]{1,3})%\)")
+ # print("***POV WAITING FOR FILE***")
+
+ data = b""
+ last_line = ""
+ while _test_wait():
+ # POV in Windows does not output its stdout/stderr, it displays them in its GUI
+ if self._is_windows:
+ self.update_stats("", "POV-Ray 3.7: Rendering File")
+ else:
+ t_data = self._process.stdout.read1(10000)
+ if not t_data: continue
+
+ data += t_data
+ # XXX This is working for UNIX, not sure whether it might need adjustments for other OSs
+ t_data = str(t_data).replace('\\r\\n', '\\n').replace('\\r', '\r') # First replace is for windows
+ lines = t_data.split('\\n')
+ last_line += lines[0]
+ lines[0] = last_line
+ print('\n'.join(lines), end="")
+ last_line = lines[-1]
+
+ if rendering.search(data):
+ _pov_rendering = True
+ match = percent.findall(str(data))
+ if match:
+ self.update_stats("", "POV-Ray 3.7: Rendering File (%s%%)" % match[-1])
+ else:
+ self.update_stats("", "POV-Ray 3.7: Rendering File")
- # test if POV-Ray exists
- if self._process.poll() is not None:
- print("***POV PROCESS FINISHED***")
- update_image()
- break
+ elif parsing.search(data):
+ self.update_stats("", "POV-Ray 3.7: Parsing File")
- # user exit
- if self.test_break():
- try:
- self._process.terminate()
- print("***POV PROCESS INTERRUPTED***")
- except OSError:
- pass
+ if os.path.exists(self._temp_file_out):
+ # print("***POV FILE OK***")
+ #self.update_stats("", "POV-Ray 3.7: Rendering")
- break
+ # prev_size = -1
- # Would be nice to redirect the output
- # stdout_value, stderr_value = self._process.communicate() # locks
+ xmin = int(r.border_min_x * x)
+ ymin = int(r.border_min_y * y)
+ xmax = int(r.border_max_x * x)
+ ymax = int(r.border_max_y * y)
- # check if the file updated
- new_size = os.path.getsize(self._temp_file_out)
+ # print("***POV UPDATING IMAGE***")
+ result = self.begin_result(0, 0, x, y)
+ #result = self.begin_result(xmin, ymin, xmax - xmin, ymax - ymin) # XXX, test for border render.
+ #result = self.begin_result(0, 0, xmax - xmin, ymax - ymin) # XXX, test for border render.
+ lay = result.layers[0]
- if new_size != prev_size:
- update_image()
- prev_size = new_size
+ # This assumes the file has been fully written We wait a bit, just in case!
+ time.sleep(self.DELAY)
+ try:
+ lay.load_from_file(self._temp_file_out)
+ #lay.load_from_file(self._temp_file_out, xmin, ymin) # XXX, test for border render.
+ #lay.load_from_file(self._temp_file_out, xmin, ymin) # XXX, test for border render.
+ except RuntimeError:
+ print("***POV ERROR WHILE READING OUTPUT FILE***")
+
+ # Not needed right now, might only be useful if we find a way to use temp raw output of
+ # pov 3.7 (in which case it might go under _test_wait()).
+# def update_image():
+# # possible the image wont load early on.
+# try:
+# lay.load_from_file(self._temp_file_out)
+# #lay.load_from_file(self._temp_file_out, xmin, ymin) # XXX, test for border render.
+# #lay.load_from_file(self._temp_file_out, xmin, ymin) # XXX, test for border render.
+# except RuntimeError:
+# pass
+
+# # Update while POV-Ray renders
+# while True:
+# # print("***POV RENDER LOOP***")
+
+# # test if POV-Ray exists
+# if self._process.poll() is not None:
+# print("***POV PROCESS FINISHED***")
+# update_image()
+# break
+
+# # user exit
+# if self.test_break():
+# try:
+# self._process.terminate()
+# print("***POV PROCESS INTERRUPTED***")
+# except OSError:
+# pass
+
+# break
+
+# # Would be nice to redirect the output
+# # stdout_value, stderr_value = self._process.communicate() # locks
+
+# # check if the file updated
+# new_size = os.path.getsize(self._temp_file_out)
+
+# if new_size != prev_size:
+# update_image()
+# prev_size = new_size
+
+# time.sleep(self.DELAY)
+
+ self.end_result(result)
- time.sleep(self.DELAY)
else:
print("***POV FILE NOT FOUND***")
print("***POV FINISHED***")
- #time.sleep(self.DELAY)
+
+ self.update_stats("", "")
+
if scene.pov_tempfiles_enable or scene.pov_deletefiles_enable:
self._cleanup()
+