blender/blender-addons
19
43
Fork 96
Code Issues 630 Pull Requests 27 Projects 1 Releases Wiki Activity
v4.1.0
blender-addons/render_povray/render.py
Campbell Barton e8da6131fd License headers: use SPDX-FileCopyrightText for all addons 
Move copyright text to SPDX-FileCopyrightText or set to the
Blender Foundation so "make check_licenses" now runs without warnings.
2023-06-15 16:54:05 +10:00

814 lines
32 KiB
Python
Executable File
Raw Permalink Blame History

# SPDX-FileCopyrightText: 2010-2023 Blender Foundation
#
# SPDX-License-Identifier: GPL-2.0-or-later
"""Write the POV file using this file's functions and some from other modules then render it."""
import bpy
import subprocess
import os
from sys import platform
#import time
from math import (
pi,
) # maybe move to scenography.py and topology_*****_data.py respectively with smoke and matrix
import mathutils #import less than full
import tempfile # generate temporary files with random names
from bpy.types import Operator
from bpy.utils import register_class, unregister_class
from . import (
scripting,
) # for writing, importing and rendering directly POV Scene Description Language items
from . import render_core
from . import scenography # for atmosphere, environment, effects, lighting, camera
from . import shading # for BI POV shaders emulation
from . import nodes_fn
from . import texturing_procedural # for Blender procedurals to POV patterns emulation
from . import model_all # for mesh based geometry
from . import model_meta_topology # for mesh based geometry
from . import model_curve_topology # for curves based geometry
# from . import model_primitives # for import and export of POV specific primitives
from .scenography import image_format, img_map, img_map_transforms, path_image
from .shading import write_object_material_interior
from .model_primitives import write_object_modifiers
tab_level = 0
tab=""
comments = False
using_uberpov = False
unpacked_images = []
from .render_core import (
preview_dir,
PovRender,
)
def string_strip_hyphen(name):
"""Remove hyphen characters from a string to avoid POV errors."""
return name.replace("-", "")
def safety(name, ref_level_bound):
"""append suffix characters to names of various material declinations.
Material declinations are necessary to POV syntax and used in shading.py
by the pov_has_no_specular_maps function to create the finish map trick and
the suffixes avoid name collisions.
Keyword arguments:
name -- the initial material name as a string
ref_level_bound -- the enum number of the ref_level_bound being written:
ref_level_bound=1 is for texture with No specular nor Mirror reflection
ref_level_bound=2 is for texture with translation of spec and mir levels
for when no map influences them
ref_level_bound=3 is for texture with Maximum Spec and Mirror
"""
# All the try except clause below seems useless as each time
# prefix rewritten even after and outside of it what was the point?
# It may not even be any longer possible to feed no arg from Blender UI
# try:
# if name: # if int(name) > 0: # could be zero if no argument provided
# # and always triggered exception so is this similar ?
# prefix = "shader"
# except BaseException as e:
# print(e.__doc__)
# print('An exception occurred: {}'.format(e))
# prefix = "" # rewritten below...
prefix = "shader_"
name = string_strip_hyphen(name)
if ref_level_bound == 2:
return prefix + name
# implicit else-if (no return yet)
if ref_level_bound == 1:
return prefix + name + "0" # used for 0 of specular map
# implicit else-if (no return yet)
if ref_level_bound == 3:
return prefix + name + "1" # used for 1 of specular map
# -------- end safety string name material
csg_list = []
def is_renderable(ob):
"""test for objects flagged as hidden or boolean operands not to render"""
return not ob.hide_render and ob not in csg_list
def renderable_objects():
"""test for non hidden, non boolean operands objects to render"""
return [ob for ob in bpy.data.objects if is_renderable(ob)]
def non_renderable_objects():
"""Boolean operands only. Not to render"""
return list(csg_list)
def set_tab(tabtype, spaces):
"""Apply the configured indentation all along the exported POV file
Arguments:
tabtype -- Specifies user preference between tabs or spaces indentation
spaces -- If using spaces, sets the number of space characters to use
Returns:
The beginning blank space for each line of the generated pov file
"""
tab_str = ""
match tabtype:
case 'SPACE':
tab_str = spaces * " "
case 'NONE':
tab_str = ""
case 'TAB':
tab_str = "\t"
return tab_str
'''
# below properties not added to __init__ yet to avoid conflicts with material sss scale
# unless it would override then should be interfaced also in scene units property tab
# if scene.pov.sslt_enable:
# file.write(" mm_per_unit %s\n"%scene.pov.mm_per_unit)
# file.write(" subsurface {\n")
# file.write(" samples %s, %s\n"%(scene.pov.sslt_samples_max,scene.pov.sslt_samples_min))
# if scene.pov.sslt_radiosity:
# file.write(" radiosity on\n")
# file.write("}\n")
'''
# def write_object_modifiers(ob, File):
# """Translate some object level POV statements from Blender UI
# to POV syntax and write to exported file """
# # Maybe return that string to be added instead of directly written.
# '''XXX WIP
# import .model_all.write_object_csg_inside_vector
# write_object_csg_inside_vector(ob, file)
# '''
# if ob.pov.hollow:
# File.write("\thollow\n")
# if ob.pov.double_illuminate:
# File.write("\tdouble_illuminate\n")
# if ob.pov.sturm:
# File.write("\tsturm\n")
# if ob.pov.no_shadow:
# File.write("\tno_shadow\n")
# if ob.pov.no_image:
# File.write("\tno_image\n")
# if ob.pov.no_reflection:
# File.write("\tno_reflection\n")
# if ob.pov.no_radiosity:
# File.write("\tno_radiosity\n")
# if ob.pov.inverse:
# File.write("\tinverse\n")
# if ob.pov.hierarchy:
# File.write("\thierarchy\n")
# # XXX, Commented definitions
# '''
# if scene.pov.photon_enable:
# File.write("photons {\n")
# if ob.pov.target:
# File.write("target %.4g\n"%ob.pov.target_value)
# if ob.pov.refraction:
# File.write("refraction on\n")
# if ob.pov.reflection:
# File.write("reflection on\n")
# if ob.pov.pass_through:
# File.write("pass_through\n")
# File.write("}\n")
# if ob.pov.object_ior > 1:
# File.write("interior {\n")
# File.write("ior %.4g\n"%ob.pov.object_ior)
# if scene.pov.photon_enable and ob.pov.target and ob.pov.refraction and ob.pov.dispersion:
# File.write("ior %.4g\n"%ob.pov.dispersion_value)
# File.write("ior %s\n"%ob.pov.dispersion_samples)
# if scene.pov.photon_enable == False:
# File.write("caustics %.4g\n"%ob.pov.fake_caustics_power)
# '''
def tab_write(file, str_o, scene=None):
"""write directly to exported file if user checked autonamed temp files (faster).
Otherwise, indent POV syntax from brackets levels and write to exported file"""
if not scene:
scene = bpy.data.scenes[0]
global tab
tab = set_tab(scene.pov.indentation_character, scene.pov.indentation_spaces)
if scene.pov.tempfiles_enable:
file.write(str_o)
else:
global tab_level
brackets = str_o.count("{") - str_o.count("}") + str_o.count("[") - str_o.count("]")
if brackets < 0:
tab_level = tab_level + brackets
if tab_level < 0:
print("Indentation Warning: tab_level = %s" % tab_level)
tab_level = 0
if tab_level >= 1:
file.write("%s" % tab * tab_level)
file.write(str_o)
if brackets > 0:
tab_level = tab_level + brackets
def write_matrix(file, matrix):
"""Translate some transform matrix from Blender UI
to POV syntax and write to exported file """
tab_write(file,
"matrix <%.6f, %.6f, %.6f, %.6f, %.6f, %.6f, %.6f, %.6f, %.6f, %.6f, %.6f, %.6f>\n"
% (
matrix[0][0],
matrix[1][0],
matrix[2][0],
matrix[0][1],
matrix[1][1],
matrix[2][1],
matrix[0][2],
matrix[1][2],
matrix[2][2],
matrix[0][3],
matrix[1][3],
matrix[2][3],
)
)
global_matrix = mathutils.Matrix.Rotation(-pi / 2.0, 4, 'X')
def write_pov(filename, scene=None, info_callback=None):
"""Main export process from Blender UI to POV syntax and write to exported file """
with open(filename, "w") as file:
# Only for testing
if not scene:
scene = bpy.data.scenes[0]
render = scene.render
world = scene.world
global comments
comments = scene.pov.comments_enable and not scene.pov.tempfiles_enable
feature_set = bpy.context.preferences.addons[__package__].preferences.branch_feature_set_povray
global using_uberpov
using_uberpov = feature_set == 'uberpov'
pov_binary = PovRender._locate_binary()
if using_uberpov:
print("Unofficial UberPOV feature set chosen in preferences")
else:
print("Official POV-Ray 3.7 feature set chosen in preferences")
if 'uber' in pov_binary:
print("The name of the binary suggests you are probably rendering with Uber POV engine")
else:
print("The name of the binary suggests you are probably rendering with standard POV engine")
def unique_name(name, name_seq):
"""Increment any generated POV name that could get identical to avoid collisions"""
if name not in name_seq:
name = string_strip_hyphen(name)
return name
name_orig = name
i = 1
while name in name_seq:
name = "%s_%.3d" % (name_orig, i)
i += 1
name = string_strip_hyphen(name)
return name
material_names_dictionary = {}
DEF_MAT_NAME = "" # or "Default"?
# -----------------------------------------------------------------------------
def export_global_settings(scene):
"""write all POV global settings to exported file """
# Imperial units warning
if scene.unit_settings.system == "IMPERIAL":
print("Warning: Imperial units not supported")
tab_write(file, "global_settings {\n")
tab_write(file, "assumed_gamma 1.0\n")
tab_write(file, "max_trace_level %d\n" % scene.pov.max_trace_level)
if scene.pov.global_settings_advanced:
if not scene.pov.radio_enable:
file.write(" adc_bailout %.6f\n" % scene.pov.adc_bailout)
file.write(" ambient_light <%.6f,%.6f,%.6f>\n" % scene.pov.ambient_light[:])
file.write(" irid_wavelength <%.6f,%.6f,%.6f>\n" % scene.pov.irid_wavelength[:])
file.write(" number_of_waves %s\n" % scene.pov.number_of_waves)
file.write(" noise_generator %s\n" % scene.pov.noise_generator)
if scene.pov.radio_enable:
tab_write(file, "radiosity {\n")
tab_write(file, "adc_bailout %.4g\n" % scene.pov.radio_adc_bailout)
tab_write(file, "brightness %.4g\n" % scene.pov.radio_brightness)
tab_write(file, "count %d\n" % scene.pov.radio_count)
tab_write(file, "error_bound %.4g\n" % scene.pov.radio_error_bound)
tab_write(file, "gray_threshold %.4g\n" % scene.pov.radio_gray_threshold)
tab_write(file, "low_error_factor %.4g\n" % scene.pov.radio_low_error_factor)
tab_write(file, "maximum_reuse %.4g\n" % scene.pov.radio_maximum_reuse)
tab_write(file, "minimum_reuse %.4g\n" % scene.pov.radio_minimum_reuse)
tab_write(file, "nearest_count %d\n" % scene.pov.radio_nearest_count)
tab_write(file, "pretrace_start %.3g\n" % scene.pov.radio_pretrace_start)
tab_write(file, "pretrace_end %.3g\n" % scene.pov.radio_pretrace_end)
tab_write(file, "recursion_limit %d\n" % scene.pov.radio_recursion_limit)
tab_write(file, "always_sample %d\n" % scene.pov.radio_always_sample)
tab_write(file, "normal %d\n" % scene.pov.radio_normal)
tab_write(file, "media %d\n" % scene.pov.radio_media)
tab_write(file, "subsurface %d\n" % scene.pov.radio_subsurface)
tab_write(file, "}\n")
once_sss = 1
once_ambient = 1
once_photons = 1
for material in bpy.data.materials:
if material.pov_subsurface_scattering.use and once_sss:
# In pov, the scale has reversed influence compared to blender. these number
# should correct that
tab_write(file,
"mm_per_unit %.6f\n" % (material.pov_subsurface_scattering.scale * 1000.0)
)
# 1000 rather than scale * (-100.0) + 15.0))
# In POV-Ray, the scale factor for all subsurface shaders needs to be the same
# formerly sslt_samples were multiplied by 100 instead of 10
sslt_samples = (11 - material.pov_subsurface_scattering.error_threshold) * 10
tab_write(file, "subsurface { samples %d, %d }\n" % (sslt_samples, sslt_samples / 10))
once_sss = 0
if world and once_ambient:
tab_write(file, "ambient_light rgb<%.3g, %.3g, %.3g>\n" % world.pov.ambient_color[:])
once_ambient = 0
if (
scene.pov.photon_enable
and once_photons
and (
material.pov.refraction_type == "2"
or material.pov.photons_reflection
)
):
tab_write(file, "photons {\n")
tab_write(file, "spacing %.6f\n" % scene.pov.photon_spacing)
tab_write(file, "max_trace_level %d\n" % scene.pov.photon_max_trace_level)
tab_write(file, "adc_bailout %.3g\n" % scene.pov.photon_adc_bailout)
tab_write(file,
"gather %d, %d\n"
% (scene.pov.photon_gather_min, scene.pov.photon_gather_max)
)
if scene.pov.photon_map_file_save_load in {'save'}:
ph_file_name = 'Photon_map_file.ph'
if scene.pov.photon_map_file != '':
ph_file_name = scene.pov.photon_map_file + '.ph'
ph_file_dir = tempfile.gettempdir()
path = bpy.path.abspath(scene.pov.photon_map_dir)
if os.path.exists(path):
ph_file_dir = path
full_file_name = os.path.join(ph_file_dir, ph_file_name)
tab_write(file, 'save_file "%s"\n' % full_file_name)
scene.pov.photon_map_file = full_file_name
if scene.pov.photon_map_file_save_load in {'load'}:
full_file_name = bpy.path.abspath(scene.pov.photon_map_file)
if os.path.exists(full_file_name):
tab_write(file, 'load_file "%s"\n' % full_file_name)
tab_write(file, "}\n")
once_photons = 0
tab_write(file, "}\n")
# sel = renderable_objects() #removed for booleans
if comments:
file.write(
"//----------------------------------------------\n"
"//--Exported with POV-Ray exporter for Blender--\n"
"//----------------------------------------------\n\n"
)
file.write("#version 3.7;\n") # Switch below as soon as 3.8 beta gets easy linked
# file.write("#version 3.8;\n")
file.write(
"#declare Default_texture = texture{pigment {rgb 0.8} " "finish {brilliance 3.8} }\n\n"
)
if comments:
file.write("\n//--Global settings--\n\n")
export_global_settings(scene)
if comments:
file.write("\n//--Custom Code--\n\n")
scripting.export_custom_code(file)
if comments:
file.write("\n//--Patterns Definitions--\n\n")
local_pattern_names = []
for texture in bpy.data.textures: # ok?
if texture.users > 0:
current_pat_name = string_strip_hyphen(bpy.path.clean_name(texture.name))
# string_strip_hyphen(patternNames[texture.name]) #maybe instead of the above
local_pattern_names.append(current_pat_name)
# use above list to prevent writing texture instances several times and assign in mats?
if (
texture.type not in {'NONE', 'IMAGE'} and texture.pov.tex_pattern_type == 'emulator'
) or (texture.type in {'NONE', 'IMAGE'} and texture.pov.tex_pattern_type != 'emulator'):
file.write("\n#declare PAT_%s = \n" % current_pat_name)
file.write(texturing_procedural.export_pattern(texture))
file.write("\n")
if comments:
file.write("\n//--Background--\n\n")
scenography.export_world(file, scene.world, scene, global_matrix, tab_write)
if comments:
file.write("\n//--Cameras--\n\n")
scenography.export_camera(file, scene, global_matrix, render, tab_write)
if comments:
file.write("\n//--Lamps--\n\n")
for ob in bpy.data.objects:
if ob.type == 'MESH':
for mod in ob.modifiers:
if mod.type == 'BOOLEAN' and mod.object not in csg_list:
csg_list.append(mod.object)
if csg_list:
csg = False
sel = non_renderable_objects()
# export non rendered boolean objects operands
model_all.objects_loop(
file,
scene,
sel,
csg,
material_names_dictionary,
unpacked_images,
tab_level,
tab_write,
info_callback,
)
csg = True
sel = renderable_objects()
scenography.export_lights(
[L for L in sel if (L.type == 'LIGHT' and L.pov.object_as != 'RAINBOW')],
file,
scene,
global_matrix,
tab_write,
)
if comments:
file.write("\n//--Rainbows--\n\n")
scenography.export_rainbows(
[L for L in sel if (L.type == 'LIGHT' and L.pov.object_as == 'RAINBOW')],
file,
scene,
global_matrix,
tab_write,
)
if comments:
file.write("\n//--Special Curves--\n\n")
for c in sel:
if c.is_modified(scene, 'RENDER'):
continue # don't export as pov curves objects with modifiers, but as mesh
# Implicit else-if (as not skipped by previous "continue")
if c.type == 'CURVE' and (c.pov.curveshape in {'lathe', 'sphere_sweep', 'loft', 'birail'}):
model_curve_topology.export_curves(file, c, tab_write)
if comments:
file.write("\n//--Material Definitions--\n\n")
# write a default pigment for objects with no material (comment out to show black)
file.write("#default{ pigment{ color srgb 0.8 }}\n")
# Convert all materials to strings we can access directly per vertex.
# exportMaterials()
shading.write_material(
file,
using_uberpov,
DEF_MAT_NAME,
tab_write,
comments,
unique_name,
material_names_dictionary,
None,
) # default material
for material in bpy.data.materials:
if material.users > 0:
r, g, b, a = material.diffuse_color[:]
pigment_color = "pigment {rgbt <%.4g,%.4g,%.4g,%.4g>}" % (r, g, b, 1 - a)
if material.pov.material_use_nodes:
# Also make here other pigment_color fallback using BSDF node main color ?
ntree = material.node_tree
pov_mat_name = string_strip_hyphen(bpy.path.clean_name(material.name))
if len(ntree.nodes) == 0:
file.write('#declare %s = texture {%s}\n' % (pov_mat_name, pigment_color))
else:
nodes_fn.write_nodes(pov_mat_name, ntree, file)
for node in ntree.nodes:
if node:
if node.bl_idname == "PovrayOutputNode":
if node.inputs["Texture"].is_linked:
for link in ntree.links:
if link.to_node.bl_idname == "PovrayOutputNode":
pov_mat_name = (
string_strip_hyphen(
bpy.path.clean_name(link.from_node.name)
)
+ "_%s" % pov_mat_name
)
else:
file.write(
'#declare %s = texture {%s}\n' % (pov_mat_name, pigment_color)
)
else:
shading.write_material(
file,
using_uberpov,
DEF_MAT_NAME,
tab_write,
comments,
unique_name,
material_names_dictionary,
material,
)
# attributes are all the variables needed by the other python file...
if comments:
file.write("\n")
model_meta_topology.export_meta(file,
[m for m in sel if m.type == 'META'],
material_names_dictionary,
tab_write,
DEF_MAT_NAME,)
if comments:
file.write("//--Mesh objects--\n")
# tbefore = time.time()
model_all.objects_loop(
file,
scene,
sel,
csg,
material_names_dictionary,
unpacked_images,
tab_level,
tab_write,
info_callback,
)
# totime = time.time() - tbefore
# print("objects_loop took" + str(totime))
# What follow used to happen here:
# export_camera()
# scenography.export_world(file, scene.world, scene, global_matrix, tab_write)
# export_global_settings(scene)
# MR:..and the order was important for implementing pov 3.7 baking
# (mesh camera) comment for the record
# CR: Baking should be a special case than. If "baking", than we could change the order.
if not file.closed:
file.close()
def write_pov_ini(filename_ini, filename_log, filename_pov, filename_image):
"""Write ini file."""
feature_set = bpy.context.preferences.addons[__package__].preferences.branch_feature_set_povray
global using_uberpov
using_uberpov = feature_set == 'uberpov'
# scene = bpy.data.scenes[0]
scene = bpy.context.scene
render = scene.render
x = int(render.resolution_x * render.resolution_percentage * 0.01)
y = int(render.resolution_y * render.resolution_percentage * 0.01)
with open(filename_ini, "w") as file:
file.write("Version=3.7\n")
# write povray text stream to temporary file of same name with _log suffix
# file.write("All_File='%s'\n" % filename_log)
# DEBUG.OUT log if none specified:
file.write("All_File=1\n")
file.write("Input_File_Name='%s'\n" % filename_pov)
file.write("Output_File_Name='%s'\n" % filename_image)
file.write("Width=%d\n" % x)
file.write("Height=%d\n" % y)
# Border render.
if render.use_border:
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" % (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
# Activated (turn this back off when better live exchange is done between the two programs
# (see next comment)
file.write("Display=1\n")
file.write("Pause_When_Done=0\n")
# PNG, with POV-Ray 3.7, can show background color with alpha. In the long run using the
# POV-Ray interactive preview like bishop 3D could solve the preview for all formats.
file.write("Output_File_Type=N\n")
# file.write("Output_File_Type=T\n") # TGA, best progressive loading
file.write("Output_Alpha=1\n")
if scene.pov.antialias_enable:
# method 2 (recursive) with higher max subdiv forced because no mipmapping in POV-Ray
# needs higher sampling.
# aa_mapping = {"5": 2, "8": 3, "11": 4, "16": 5}
if using_uberpov:
method = {"0": 1, "1": 2, "2": 3}
else:
method = {"0": 1, "1": 2, "2": 2}
file.write("Antialias=on\n")
file.write("Antialias_Depth=%d\n" % scene.pov.antialias_depth)
file.write("Antialias_Threshold=%.3g\n" % scene.pov.antialias_threshold)
if using_uberpov and scene.pov.antialias_method == '2':
file.write("Sampling_Method=%s\n" % method[scene.pov.antialias_method])
file.write("Antialias_Confidence=%.3g\n" % scene.pov.antialias_confidence)
else:
file.write("Sampling_Method=%s\n" % method[scene.pov.antialias_method])
file.write("Antialias_Gamma=%.3g\n" % scene.pov.antialias_gamma)
if scene.pov.jitter_enable:
file.write("Jitter=on\n")
file.write("Jitter_Amount=%3g\n" % scene.pov.jitter_amount)
else:
file.write("Jitter=off\n") # prevent animation flicker
else:
file.write("Antialias=off\n")
if not file.closed:
file.close()
# --------------------------------------------------------------------------------- #
# ----------------------------------- Operators ----------------------------------- #
# --------------------------------------------------------------------------------- #
class RenderPovTexturePreview(Operator):
"""Export only files necessary to texture preview and render image"""
bl_idname = "tex.preview_update"
bl_label = "Update preview"
def execute(self, context):
tex = bpy.context.object.active_material.active_texture # context.texture
tex_prev_name = string_strip_hyphen(bpy.path.clean_name(tex.name)) + "_prev"
# Make sure Preview directory exists and is empty
if not os.path.isdir(preview_dir):
os.mkdir(preview_dir)
ini_prev_file = os.path.join(preview_dir, "Preview.ini")
input_prev_file = os.path.join(preview_dir, "Preview.pov")
output_prev_file = os.path.join(preview_dir, tex_prev_name)
# ---------------------------------- ini ---------------------------------- #
with open(ini_prev_file, "w") as file_ini:
file_ini.write('Version=3.8\n')
file_ini.write('Input_File_Name="%s"\n' % input_prev_file)
file_ini.write('Output_File_Name="%s.png"\n' % output_prev_file)
file_ini.write('Library_Path="%s"\n' % preview_dir)
file_ini.write('Width=256\n')
file_ini.write('Height=256\n')
file_ini.write('Pause_When_Done=0\n')
file_ini.write('Output_File_Type=N\n')
file_ini.write('Output_Alpha=1\n')
file_ini.write('Antialias=on\n')
file_ini.write('Sampling_Method=2\n')
file_ini.write('Antialias_Depth=3\n')
file_ini.write('-d\n')
if not file_ini.closed:
file_ini.close()
# ---------------------------------- pov ---------------------------------- #
with open(input_prev_file, "w") as file_pov:
pat_name = "PAT_" + string_strip_hyphen(bpy.path.clean_name(tex.name))
file_pov.write("#declare %s = \n" % pat_name)
file_pov.write(texturing_procedural.export_pattern(tex))
file_pov.write("#declare Plane =\n")
file_pov.write("mesh {\n")
file_pov.write(
" triangle {<-2.021,-1.744,2.021>,<-2.021,-1.744,-2.021>,<2.021,-1.744,2.021>}\n"
)
file_pov.write(
" triangle {<-2.021,-1.744,-2.021>,<2.021,-1.744,-2.021>,<2.021,-1.744,2.021>}\n"
)
file_pov.write(" texture{%s}\n" % pat_name)
file_pov.write("}\n")
file_pov.write("object {Plane}\n")
file_pov.write("light_source {\n")
file_pov.write(" <0,4.38,-1.92e-07>\n")
file_pov.write(" color rgb<4, 4, 4>\n")
file_pov.write(" parallel\n")
file_pov.write(" point_at <0, 0, -1>\n")
file_pov.write("}\n")
file_pov.write("camera {\n")
file_pov.write(" location <0, 0, 0>\n")
file_pov.write(" look_at <0, 0, -1>\n")
file_pov.write(" right <-1.0, 0, 0>\n")
file_pov.write(" up <0, 1, 0>\n")
file_pov.write(" angle 96.805211\n")
file_pov.write(" rotate <-90.000003, -0.000000, 0.000000>\n")
file_pov.write(" translate <0.000000, 0.000000, 0.000000>\n")
file_pov.write("}\n")
if not file_pov.closed:
file_pov.close()
# ------------------------------- end write ------------------------------- #
pov_binary = PovRender._locate_binary()
if platform.startswith('win'):
with subprocess.Popen(
["%s" % pov_binary, "/EXIT", "%s" % ini_prev_file],
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT,
) as p1:
p1.wait()
else:
with subprocess.Popen(
["%s" % pov_binary, "-d", "%s" % ini_prev_file],
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT,
) as p1:
p1.wait()
tex.use_nodes = True
tree = tex.node_tree
links = tree.links
for n in tree.nodes:
tree.nodes.remove(n)
im = tree.nodes.new("TextureNodeImage")
path_prev = "%s.png" % output_prev_file
im.image = bpy.data.images.load(path_prev)
name = path_prev
name = name.split("/")
name = name[len(name) - 1]
im.name = name
im.location = 200, 200
previewer = tree.nodes.new('TextureNodeOutput')
previewer.label = "Preview"
previewer.location = 400, 400
links.new(im.outputs[0], previewer.inputs[0])
# tex.type="IMAGE" # makes clip extend possible
# tex.extension="CLIP"
return {'FINISHED'}
class RunPovTextRender(Operator):
"""Export files depending on text editor options and render image."""
bl_idname = "text.run"
bl_label = "Run"
bl_context = "text"
bl_description = "Run a render with this text only"
def execute(self, context):
scene = context.scene
scene.pov.text_block = context.space_data.text.name
bpy.ops.render.render()
# empty text name property again
scene.pov.text_block = ""
return {'FINISHED'}
classes = (
#PovRender,
RenderPovTexturePreview,
RunPovTextRender,
)
def register():
for cls in classes:
register_class(cls)
scripting.register()
def unregister():
scripting.unregister()
for cls in reversed(classes):
unregister_class(cls)
Reference in New Issue View Git Blame Copy Permalink