868 lines
36 KiB
Python
Executable File
868 lines
36 KiB
Python
Executable File
# SPDX-License-Identifier: GPL-2.0-or-later
|
|
|
|
"""With respect to camera frame and optics distortions, also export environment
|
|
|
|
with world, sky, atmospheric effects such as rainbows or smoke """
|
|
|
|
import bpy
|
|
|
|
import os
|
|
from imghdr import what # imghdr is a python lib to identify image file types
|
|
from math import atan, pi, sqrt, degrees
|
|
from . import voxel_lib # for smoke rendering
|
|
from .model_primitives import write_object_modifiers
|
|
|
|
|
|
# -------- find image texture # used for export_world -------- #
|
|
|
|
|
|
def image_format(img_f):
|
|
"""Identify input image filetypes to transmit to POV."""
|
|
# First use the below explicit extensions to identify image file prospects
|
|
ext = {
|
|
"JPG": "jpeg",
|
|
"JPEG": "jpeg",
|
|
"GIF": "gif",
|
|
"TGA": "tga",
|
|
"IFF": "iff",
|
|
"PPM": "ppm",
|
|
"PNG": "png",
|
|
"SYS": "sys",
|
|
"TIFF": "tiff",
|
|
"TIF": "tiff",
|
|
"EXR": "exr",
|
|
"HDR": "hdr",
|
|
}.get(os.path.splitext(img_f)[-1].upper(), "")
|
|
# Then, use imghdr to really identify the filetype as it can be different
|
|
if not ext:
|
|
# maybe add a check for if path exists here?
|
|
print(" WARNING: texture image has no extension") # too verbose
|
|
|
|
ext = what(img_f) # imghdr is a python lib to identify image file types
|
|
return ext
|
|
|
|
|
|
def img_map(ts):
|
|
"""Translate mapping type from Blender UI to POV syntax and return that string."""
|
|
image_map = ""
|
|
texdata = bpy.data.textures[ts.texture]
|
|
if ts.mapping == "FLAT":
|
|
image_map = "map_type 0 "
|
|
elif ts.mapping == "SPHERE":
|
|
image_map = "map_type 1 "
|
|
elif ts.mapping == "TUBE":
|
|
image_map = "map_type 2 "
|
|
|
|
# map_type 3 and 4 in development (?) (ENV in pov 3.8)
|
|
# for POV-Ray, currently they just seem to default back to Flat (type 0)
|
|
# elif ts.mapping=="?":
|
|
# image_map = " map_type 3 "
|
|
# elif ts.mapping=="?":
|
|
# image_map = " map_type 4 "
|
|
if ts.use_interpolation: # Available if image sampling class reactivated?
|
|
image_map += " interpolate 2 "
|
|
if texdata.extension == "CLIP":
|
|
image_map += " once "
|
|
# image_map += "}"
|
|
# if ts.mapping=='CUBE':
|
|
# image_map+= "warp { cubic } rotate <-90,0,180>"
|
|
# no direct cube type mapping. Though this should work in POV 3.7
|
|
# it doesn't give that good results(best suited to environment maps?)
|
|
# if image_map == "":
|
|
# print(" No texture image found ")
|
|
return image_map
|
|
|
|
|
|
def img_map_transforms(ts):
|
|
"""Translate mapping transformations from Blender UI to POV syntax and return that string."""
|
|
# XXX TODO: unchecked textures give error of variable referenced before assignment XXX
|
|
# POV-Ray "scale" is not a number of repetitions factor, but ,its
|
|
# inverse, a standard scale factor.
|
|
# 0.5 Offset is needed relatively to scale because center of the
|
|
# scale is 0.5,0.5 in blender and 0,0 in POV
|
|
# Strange that the translation factor for scale is not the same as for
|
|
# translate.
|
|
# TODO: verify both matches with other blender renderers / internal in previous versions.
|
|
image_map_transforms = ""
|
|
image_map_transforms = "scale <%.4g,%.4g,%.4g> translate <%.4g,%.4g,%.4g>" % (
|
|
ts.scale[0],
|
|
ts.scale[1],
|
|
ts.scale[2],
|
|
ts.offset[0],
|
|
ts.offset[1],
|
|
ts.offset[2],
|
|
)
|
|
# image_map_transforms = (" translate <-0.5,-0.5,0.0> scale <%.4g,%.4g,%.4g> translate <%.4g,%.4g,%.4g>" % \
|
|
# ( 1.0 / ts.scale.x,
|
|
# 1.0 / ts.scale.y,
|
|
# 1.0 / ts.scale.z,
|
|
# (0.5 / ts.scale.x) + ts.offset.x,
|
|
# (0.5 / ts.scale.y) + ts.offset.y,
|
|
# ts.offset.z))
|
|
# image_map_transforms = (
|
|
# "translate <-0.5,-0.5,0> "
|
|
# "scale <-1,-1,1> * <%.4g,%.4g,%.4g> "
|
|
# "translate <0.5,0.5,0> + <%.4g,%.4g,%.4g>" % \
|
|
# (1.0 / ts.scale.x,
|
|
# 1.0 / ts.scale.y,
|
|
# 1.0 / ts.scale.z,
|
|
# ts.offset.x,
|
|
# ts.offset.y,
|
|
# ts.offset.z)
|
|
# )
|
|
return image_map_transforms
|
|
|
|
|
|
def img_map_bg(wts):
|
|
"""Translate world mapping from Blender UI to POV syntax and return that string."""
|
|
tex = bpy.data.textures[wts.texture]
|
|
image_mapBG = ""
|
|
# texture_coords refers to the mapping of world textures:
|
|
if wts.texture_coords in ["VIEW", "GLOBAL"]:
|
|
image_mapBG = " map_type 0 "
|
|
elif wts.texture_coords == "ANGMAP":
|
|
image_mapBG = " map_type 1 "
|
|
elif wts.texture_coords == "TUBE":
|
|
image_mapBG = " map_type 2 "
|
|
|
|
if tex.use_interpolation:
|
|
image_mapBG += " interpolate 2 "
|
|
if tex.extension == "CLIP":
|
|
image_mapBG += " once "
|
|
# image_mapBG += "}"
|
|
# if wts.mapping == 'CUBE':
|
|
# image_mapBG += "warp { cubic } rotate <-90,0,180>"
|
|
# no direct cube type mapping. Though this should work in POV 3.7
|
|
# it doesn't give that good results(best suited to environment maps?)
|
|
# if image_mapBG == "":
|
|
# print(" No background texture image found ")
|
|
return image_mapBG
|
|
|
|
|
|
def path_image(image):
|
|
"""Conform a path string to POV syntax to avoid POV errors."""
|
|
return bpy.path.abspath(image.filepath, library=image.library).replace("\\", "/")
|
|
# .replace("\\","/") to get only forward slashes as it's what POV prefers,
|
|
# even on windows
|
|
|
|
|
|
# end find image texture
|
|
# -----------------------------------------------------------------------------
|
|
|
|
|
|
def export_camera(file, scene, global_matrix, render, tab_write):
|
|
"""Translate camera from Blender UI to POV syntax and write to exported file."""
|
|
camera = scene.camera
|
|
|
|
# DH disabled for now, this isn't the correct context
|
|
active_object = None # bpy.context.active_object # does not always work MR
|
|
matrix = global_matrix @ camera.matrix_world
|
|
focal_point = camera.data.dof.focus_distance
|
|
|
|
# compute resolution
|
|
q_size = render.resolution_x / render.resolution_y
|
|
tab_write(file, "#declare camLocation = <%.6f, %.6f, %.6f>;\n" % matrix.translation[:])
|
|
tab_write(
|
|
file,
|
|
(
|
|
"#declare camLookAt = <%.6f, %.6f, %.6f>;\n"
|
|
% tuple(degrees(e) for e in matrix.to_3x3().to_euler())
|
|
),
|
|
)
|
|
|
|
tab_write(file, "camera {\n")
|
|
if scene.pov.baking_enable and active_object and active_object.type == "MESH":
|
|
tab_write(file, "mesh_camera{ 1 3\n") # distribution 3 is what we want here
|
|
tab_write(file, "mesh{%s}\n" % active_object.name)
|
|
tab_write(file, "}\n")
|
|
tab_write(file, "location <0,0,.01>")
|
|
tab_write(file, "direction <0,0,-1>")
|
|
|
|
else:
|
|
if camera.data.type == "ORTHO":
|
|
# XXX todo: track when SensorHeightRatio was added to see if needed (not used)
|
|
sensor_height_ratio = (
|
|
render.resolution_x * camera.data.ortho_scale / render.resolution_y
|
|
)
|
|
tab_write(file, "orthographic\n")
|
|
# Blender angle is radian so should be converted to degrees:
|
|
# % (camera.data.angle * (180.0 / pi) )
|
|
# but actually argument is not compulsory after angle in pov ortho mode
|
|
tab_write(file, "angle\n")
|
|
tab_write(file, "right <%6f, 0, 0>\n" % -camera.data.ortho_scale)
|
|
tab_write(file, "location <0, 0, 0>\n")
|
|
tab_write(file, "look_at <0, 0, -1>\n")
|
|
tab_write(file, "up <0, %6f, 0>\n" % (camera.data.ortho_scale / q_size))
|
|
|
|
elif camera.data.type == "PANO":
|
|
tab_write(file, "panoramic\n")
|
|
tab_write(file, "location <0, 0, 0>\n")
|
|
tab_write(file, "look_at <0, 0, -1>\n")
|
|
tab_write(file, "right <%s, 0, 0>\n" % -q_size)
|
|
tab_write(file, "up <0, 1, 0>\n")
|
|
tab_write(file, "angle %f\n" % (360.0 * atan(16.0 / camera.data.lens) / pi))
|
|
elif camera.data.type == "PERSP":
|
|
# Standard camera otherwise would be default in pov
|
|
tab_write(file, "location <0, 0, 0>\n")
|
|
tab_write(file, "look_at <0, 0, -1>\n")
|
|
tab_write(file, "right <%s, 0, 0>\n" % -q_size)
|
|
tab_write(file, "up <0, 1, 0>\n")
|
|
tab_write(
|
|
file,
|
|
"angle %f\n"
|
|
% (2 * atan(camera.data.sensor_width / 2 / camera.data.lens) * 180.0 / pi),
|
|
)
|
|
|
|
tab_write(
|
|
file,
|
|
"rotate <%.6f, %.6f, %.6f>\n" % tuple(degrees(e) for e in matrix.to_3x3().to_euler()),
|
|
)
|
|
|
|
tab_write(file, "translate <%.6f, %.6f, %.6f>\n" % matrix.translation[:])
|
|
if camera.data.dof.use_dof and (focal_point != 0 or camera.data.dof.focus_object):
|
|
tab_write(
|
|
file, "aperture %.3g\n" % (1 / (camera.data.dof.aperture_fstop * 10000) * 1000)
|
|
)
|
|
tab_write(
|
|
file,
|
|
"blur_samples %d %d\n"
|
|
% (camera.data.pov.dof_samples_min, camera.data.pov.dof_samples_max),
|
|
)
|
|
tab_write(file, "variance 1/%d\n" % camera.data.pov.dof_variance)
|
|
tab_write(file, "confidence %.3g\n" % camera.data.pov.dof_confidence)
|
|
if camera.data.dof.focus_object:
|
|
focal_ob = scene.objects[camera.data.dof.focus_object.name]
|
|
matrix_blur = global_matrix @ focal_ob.matrix_world
|
|
tab_write(file, "focal_point <%.4f,%.4f,%.4f>\n" % matrix_blur.translation[:])
|
|
else:
|
|
tab_write(file, "focal_point <0, 0, %f>\n" % focal_point)
|
|
if camera.data.pov.normal_enable:
|
|
tab_write(
|
|
file,
|
|
"normal {%s %.4f turbulence %.4f scale %.4f}\n"
|
|
% (
|
|
camera.data.pov.normal_patterns,
|
|
camera.data.pov.cam_normal,
|
|
camera.data.pov.turbulence,
|
|
camera.data.pov.scale,
|
|
),
|
|
)
|
|
tab_write(file, "}\n")
|
|
|
|
|
|
exported_lights_count = 0
|
|
|
|
|
|
def export_lights(lamps, file, scene, global_matrix, tab_write):
|
|
"""Translate lights from Blender UI to POV syntax and write to exported file."""
|
|
|
|
from .render import write_matrix, tab_write
|
|
|
|
# Incremented after each lamp export to declare its target
|
|
# currently used for Fresnel diffuse shader as their slope vector:
|
|
global exported_lights_count
|
|
# Get all lamps and keep their count in a global variable
|
|
for exported_lights_count, ob in enumerate(lamps, start=1):
|
|
lamp = ob.data
|
|
|
|
matrix = global_matrix @ ob.matrix_world
|
|
|
|
# Color is no longer modified by energy
|
|
# any way to directly get bpy_prop_array as tuple?
|
|
color = tuple(lamp.color)
|
|
|
|
tab_write(file, "light_source {\n")
|
|
tab_write(file, "< 0,0,0 >\n")
|
|
tab_write(file, "color srgb<%.3g, %.3g, %.3g>\n" % color)
|
|
|
|
if lamp.type == "POINT":
|
|
pass
|
|
elif lamp.type == "SPOT":
|
|
tab_write(file, "spotlight\n")
|
|
|
|
# Falloff is the main radius from the centre line
|
|
tab_write(file, "falloff %.2f\n" % (degrees(lamp.spot_size) / 2.0)) # 1 TO 179 FOR BOTH
|
|
tab_write(
|
|
file, "radius %.6f\n" % ((degrees(lamp.spot_size) / 2.0) * (1.0 - lamp.spot_blend))
|
|
)
|
|
|
|
# Blender does not have a tightness equivalent, 0 is most like blender default.
|
|
tab_write(file, "tightness 0\n") # 0:10f
|
|
|
|
tab_write(file, "point_at <0, 0, -1>\n")
|
|
if lamp.pov.use_halo:
|
|
tab_write(file, "looks_like{\n")
|
|
tab_write(file, "sphere{<0,0,0>,%.6f\n" % lamp.distance)
|
|
tab_write(file, "hollow\n")
|
|
tab_write(file, "material{\n")
|
|
tab_write(file, "texture{\n")
|
|
tab_write(file, "pigment{rgbf<1,1,1,%.4f>}\n" % (lamp.pov.halo_intensity * 5.0))
|
|
tab_write(file, "}\n")
|
|
tab_write(file, "interior{\n")
|
|
tab_write(file, "media{\n")
|
|
tab_write(file, "emission 1\n")
|
|
tab_write(file, "scattering {1, 0.5}\n")
|
|
tab_write(file, "density{\n")
|
|
tab_write(file, "spherical\n")
|
|
tab_write(file, "color_map{\n")
|
|
tab_write(file, "[0.0 rgb <0,0,0>]\n")
|
|
tab_write(file, "[0.5 rgb <1,1,1>]\n")
|
|
tab_write(file, "[1.0 rgb <1,1,1>]\n")
|
|
tab_write(file, "}\n")
|
|
tab_write(file, "}\n")
|
|
tab_write(file, "}\n")
|
|
tab_write(file, "}\n")
|
|
tab_write(file, "}\n")
|
|
tab_write(file, "}\n")
|
|
tab_write(file, "}\n")
|
|
elif lamp.type == "SUN":
|
|
tab_write(file, "parallel\n")
|
|
tab_write(file, "point_at <0, 0, -1>\n") # *must* be after 'parallel'
|
|
|
|
elif lamp.type == "AREA":
|
|
tab_write(file, "fade_distance %.6f\n" % (lamp.distance / 2.0))
|
|
# Area lights have no falloff type, so always use blenders lamp quad equivalent
|
|
# for those?
|
|
tab_write(file, "fade_power %d\n" % 2)
|
|
size_x = lamp.size
|
|
samples_x = lamp.pov.shadow_ray_samples_x
|
|
if lamp.shape == "SQUARE":
|
|
size_y = size_x
|
|
samples_y = samples_x
|
|
else:
|
|
size_y = lamp.size_y
|
|
samples_y = lamp.pov.shadow_ray_samples_y
|
|
|
|
tab_write(
|
|
file,
|
|
"area_light <%.6f,0,0>,<0,%.6f,0> %d, %d\n"
|
|
% (size_x, size_y, samples_x, samples_y),
|
|
)
|
|
tab_write(file, "area_illumination\n")
|
|
if lamp.pov.shadow_ray_sample_method == "CONSTANT_JITTERED":
|
|
if lamp.pov.use_jitter:
|
|
tab_write(file, "jitter\n")
|
|
else:
|
|
tab_write(file, "adaptive 1\n")
|
|
tab_write(file, "jitter\n")
|
|
|
|
# No shadow checked either at global or light level:
|
|
if not scene.pov.use_shadows or (lamp.pov.shadow_method == "NOSHADOW"):
|
|
tab_write(file, "shadowless\n")
|
|
|
|
# Sun shouldn't be attenuated. Area lights have no falloff attribute so they
|
|
# are put to type 2 attenuation a little higher above.
|
|
if lamp.type not in {"SUN", "AREA"}:
|
|
if lamp.falloff_type == "INVERSE_SQUARE":
|
|
tab_write(file, "fade_distance %.6f\n" % (sqrt(lamp.distance / 2.0)))
|
|
tab_write(file, "fade_power %d\n" % 2) # Use blenders lamp quad equivalent
|
|
elif lamp.falloff_type == "INVERSE_LINEAR":
|
|
tab_write(file, "fade_distance %.6f\n" % (lamp.distance / 2.0))
|
|
tab_write(file, "fade_power %d\n" % 1) # Use blenders lamp linear
|
|
elif lamp.falloff_type == "CONSTANT":
|
|
tab_write(file, "fade_distance %.6f\n" % (lamp.distance / 2.0))
|
|
tab_write(file, "fade_power %d\n" % 3)
|
|
# Use blenders lamp constant equivalent no attenuation.
|
|
# Using Custom curve for fade power 3 for now.
|
|
elif lamp.falloff_type == "CUSTOM_CURVE":
|
|
tab_write(file, "fade_power %d\n" % 4)
|
|
|
|
write_matrix(file, matrix)
|
|
|
|
tab_write(file, "}\n")
|
|
|
|
# v(A,B) rotates vector A about origin by vector B.
|
|
file.write(
|
|
"#declare lampTarget%s= vrotate(<%.4g,%.4g,%.4g>,<%.4g,%.4g,%.4g>);\n"
|
|
% (
|
|
exported_lights_count,
|
|
-ob.location.x,
|
|
-ob.location.y,
|
|
-ob.location.z,
|
|
ob.rotation_euler.x,
|
|
ob.rotation_euler.y,
|
|
ob.rotation_euler.z,
|
|
)
|
|
)
|
|
|
|
|
|
def export_world(file, world, scene, global_matrix, tab_write):
|
|
"""write world as POV background and sky_sphere to exported file"""
|
|
render = scene.pov
|
|
agnosticrender = scene.render
|
|
camera = scene.camera
|
|
# matrix = global_matrix @ camera.matrix_world # view dependant for later use NOT USED
|
|
if not world:
|
|
return
|
|
|
|
# These lines added to get sky gradient (visible with PNG output)
|
|
|
|
# For simple flat background:
|
|
if not world.pov.use_sky_blend:
|
|
# No alpha with Sky option:
|
|
if render.alpha_mode == "SKY" and not agnosticrender.film_transparent:
|
|
tab_write(
|
|
file, "background {rgbt<%.3g, %.3g, %.3g, 0>}\n" % (world.pov.horizon_color[:])
|
|
)
|
|
|
|
elif render.alpha_mode == "STRAIGHT" or agnosticrender.film_transparent:
|
|
tab_write(
|
|
file, "background {rgbt<%.3g, %.3g, %.3g, 1>}\n" % (world.pov.horizon_color[:])
|
|
)
|
|
else:
|
|
# Non fully transparent background could premultiply alpha and avoid
|
|
# anti-aliasing display issue
|
|
tab_write(
|
|
file,
|
|
"background {rgbft<%.3g, %.3g, %.3g, %.3g, 0>}\n"
|
|
% (
|
|
world.pov.horizon_color[0],
|
|
world.pov.horizon_color[1],
|
|
world.pov.horizon_color[2],
|
|
render.alpha_filter,
|
|
),
|
|
)
|
|
|
|
world_tex_count = 0
|
|
# For Background image textures
|
|
for t in world.pov_texture_slots: # risk to write several sky_spheres but maybe ok.
|
|
if t:
|
|
tex = bpy.data.textures[t.texture]
|
|
if tex.type is not None:
|
|
world_tex_count += 1
|
|
# XXX No enable checkbox for world textures yet (report it?)
|
|
# if t and tex.type == 'IMAGE' and t.use:
|
|
if tex.type == "IMAGE":
|
|
image_filename = path_image(tex.image)
|
|
if tex.image.filepath != image_filename:
|
|
tex.image.filepath = image_filename
|
|
if image_filename != "" and t.use_map_blend:
|
|
textures_blend = image_filename
|
|
# colvalue = t.default_value
|
|
t_blend = t
|
|
|
|
# Commented below was an idea to make the Background image oriented as camera
|
|
# taken here:
|
|
# http://news.pov.org/pov.newusers/thread/%3Cweb.4a5cddf4e9c9822ba2f93e20@news.pov.org%3E/
|
|
# Replace 4/3 by the ratio of each image found by some custom or existing
|
|
# function
|
|
# mapping_blend = (" translate <%.4g,%.4g,%.4g> rotate z*degrees" \
|
|
# "(atan((camLocation - camLookAt).x/(camLocation - " \
|
|
# "camLookAt).y)) rotate x*degrees(atan((camLocation - " \
|
|
# "camLookAt).y/(camLocation - camLookAt).z)) rotate y*" \
|
|
# "degrees(atan((camLocation - camLookAt).z/(camLocation - " \
|
|
# "camLookAt).x)) scale <%.4g,%.4g,%.4g>b" % \
|
|
# (t_blend.offset.x / 10 , t_blend.offset.y / 10 ,
|
|
# t_blend.offset.z / 10, t_blend.scale.x ,
|
|
# t_blend.scale.y , t_blend.scale.z))
|
|
# using camera rotation valuesdirectly from blender seems much easier
|
|
if t_blend.texture_coords == "ANGMAP":
|
|
mapping_blend = ""
|
|
else:
|
|
# POV-Ray "scale" is not a number of repetitions factor, but its
|
|
# inverse, a standard scale factor.
|
|
# 0.5 Offset is needed relatively to scale because center of the
|
|
# UV scale is 0.5,0.5 in blender and 0,0 in POV
|
|
# Further Scale by 2 and translate by -1 are
|
|
# required for the sky_sphere not to repeat
|
|
|
|
mapping_blend = (
|
|
"scale 2 scale <%.4g,%.4g,%.4g> translate -1 "
|
|
"translate <%.4g,%.4g,%.4g> rotate<0,0,0> "
|
|
% (
|
|
(1.0 / t_blend.scale.x),
|
|
(1.0 / t_blend.scale.y),
|
|
(1.0 / t_blend.scale.z),
|
|
0.5 - (0.5 / t_blend.scale.x) - t_blend.offset.x,
|
|
0.5 - (0.5 / t_blend.scale.y) - t_blend.offset.y,
|
|
t_blend.offset.z,
|
|
)
|
|
)
|
|
|
|
# The initial position and rotation of the pov camera is probably creating
|
|
# the rotation offset should look into it someday but at least background
|
|
# won't rotate with the camera now.
|
|
# Putting the map on a plane would not introduce the skysphere distortion and
|
|
# allow for better image scale matching but also some waay to chose depth and
|
|
# size of the plane relative to camera.
|
|
tab_write(file, "sky_sphere {\n")
|
|
tab_write(file, "pigment {\n")
|
|
tab_write(
|
|
file,
|
|
'image_map{%s "%s" %s}\n'
|
|
% (image_format(textures_blend), textures_blend, img_map_bg(t_blend)),
|
|
)
|
|
tab_write(file, "}\n")
|
|
tab_write(file, "%s\n" % mapping_blend)
|
|
# The following layered pigment opacifies to black over the texture for
|
|
# transmit below 1 or otherwise adds to itself
|
|
tab_write(file, "pigment {rgb 0 transmit %s}\n" % tex.intensity)
|
|
tab_write(file, "}\n")
|
|
# tab_write(file, "scale 2\n")
|
|
# tab_write(file, "translate -1\n")
|
|
|
|
# For only Background gradient
|
|
|
|
if world_tex_count == 0 and world.pov.use_sky_blend:
|
|
tab_write(file, "sky_sphere {\n")
|
|
tab_write(file, "pigment {\n")
|
|
# maybe Should follow the advice of POV doc about replacing gradient
|
|
# for skysphere..5.5
|
|
tab_write(file, "gradient y\n")
|
|
tab_write(file, "color_map {\n")
|
|
|
|
if render.alpha_mode == "TRANSPARENT":
|
|
tab_write(
|
|
file,
|
|
"[0.0 rgbft<%.3g, %.3g, %.3g, %.3g, 0>]\n"
|
|
% (
|
|
world.pov.horizon_color[0],
|
|
world.pov.horizon_color[1],
|
|
world.pov.horizon_color[2],
|
|
render.alpha_filter,
|
|
),
|
|
)
|
|
tab_write(
|
|
file,
|
|
"[1.0 rgbft<%.3g, %.3g, %.3g, %.3g, 0>]\n"
|
|
% (
|
|
world.pov.zenith_color[0],
|
|
world.pov.zenith_color[1],
|
|
world.pov.zenith_color[2],
|
|
render.alpha_filter,
|
|
),
|
|
)
|
|
if agnosticrender.film_transparent or render.alpha_mode == "STRAIGHT":
|
|
tab_write(file, "[0.0 rgbt<%.3g, %.3g, %.3g, 0.99>]\n" % (world.pov.horizon_color[:]))
|
|
# aa premult not solved with transmit 1
|
|
tab_write(file, "[1.0 rgbt<%.3g, %.3g, %.3g, 0.99>]\n" % (world.pov.zenith_color[:]))
|
|
else:
|
|
tab_write(file, "[0.0 rgbt<%.3g, %.3g, %.3g, 0>]\n" % (world.pov.horizon_color[:]))
|
|
tab_write(file, "[1.0 rgbt<%.3g, %.3g, %.3g, 0>]\n" % (world.pov.zenith_color[:]))
|
|
tab_write(file, "}\n")
|
|
tab_write(file, "}\n")
|
|
tab_write(file, "}\n")
|
|
# Sky_sphere alpha (transmit) is not translating into image alpha the same
|
|
# way as 'background'
|
|
|
|
# if world.pov.light_settings.use_indirect_light:
|
|
# scene.pov.radio_enable=1
|
|
|
|
# Maybe change the above to a function copyInternalRenderer settings when
|
|
# user pushes a button, then:
|
|
# scene.pov.radio_enable = world.pov.light_settings.use_indirect_light
|
|
# and other such translations but maybe this would not be allowed either?
|
|
|
|
# -----------------------------------------------------------------------------
|
|
|
|
mist = world.mist_settings
|
|
|
|
if mist.use_mist:
|
|
tab_write(file, "fog {\n")
|
|
if mist.falloff == "LINEAR":
|
|
tab_write(file, "distance %.6f\n" % ((mist.start + mist.depth) * 0.368))
|
|
elif mist.falloff in ["QUADRATIC", "INVERSE_QUADRATIC"]: # n**2 or squrt(n)?
|
|
tab_write(file, "distance %.6f\n" % ((mist.start + mist.depth) ** 2 * 0.368))
|
|
tab_write(
|
|
file,
|
|
"color rgbt<%.3g, %.3g, %.3g, %.3g>\n"
|
|
% (*world.pov.horizon_color, (1.0 - mist.intensity)),
|
|
)
|
|
# tab_write(file, "fog_offset %.6f\n" % mist.start) #create a pov property to prepend
|
|
# tab_write(file, "fog_alt %.6f\n" % mist.height) #XXX right?
|
|
# tab_write(file, "turbulence 0.2\n")
|
|
# tab_write(file, "turb_depth 0.3\n")
|
|
tab_write(file, "fog_type 1\n") # type2 for height
|
|
tab_write(file, "}\n")
|
|
if scene.pov.media_enable:
|
|
tab_write(file, "media {\n")
|
|
tab_write(
|
|
file,
|
|
"scattering { %d, rgb %.12f*<%.4g, %.4g, %.4g>\n"
|
|
% (
|
|
int(scene.pov.media_scattering_type),
|
|
scene.pov.media_diffusion_scale,
|
|
*(scene.pov.media_diffusion_color[:]),
|
|
),
|
|
)
|
|
if scene.pov.media_scattering_type == "5":
|
|
tab_write(file, "eccentricity %.3g\n" % scene.pov.media_eccentricity)
|
|
tab_write(file, "}\n")
|
|
tab_write(
|
|
file,
|
|
"absorption %.12f*<%.4g, %.4g, %.4g>\n"
|
|
% (scene.pov.media_absorption_scale, *(scene.pov.media_absorption_color[:])),
|
|
)
|
|
tab_write(file, "\n")
|
|
tab_write(file, "samples %.d\n" % scene.pov.media_samples)
|
|
tab_write(file, "}\n")
|
|
|
|
|
|
# -----------------------------------------------------------------------------
|
|
def export_rainbows(rainbows, file, scene, global_matrix, tab_write):
|
|
"""write all POV rainbows primitives to exported file"""
|
|
|
|
from .render import write_matrix, tab_write
|
|
|
|
pov_mat_name = "Default_texture"
|
|
for ob in rainbows:
|
|
povdataname = ob.data.name # enough? XXX not used nor matrix fn?
|
|
angle = degrees(ob.data.spot_size / 2.5) # radians in blender (2
|
|
width = ob.data.spot_blend * 10
|
|
distance = ob.data.shadow_buffer_clip_start
|
|
# eps=0.0000001
|
|
# angle = br/(cr+eps) * 10 #eps is small epsilon variable to avoid dividing by zero
|
|
# width = ob.dimensions[2] #now let's say width of rainbow is the actual proxy height
|
|
# formerly:
|
|
# cz-bz # let's say width of the rainbow is height of the cone (interfacing choice
|
|
|
|
# v(A,B) rotates vector A about origin by vector B.
|
|
# and avoid a 0 length vector by adding 1
|
|
|
|
# file.write("#declare %s_Target= vrotate(<%.6g,%.6g,%.6g>,<%.4g,%.4g,%.4g>);\n" % \
|
|
# (povdataname, -(ob.location.x+0.1), -(ob.location.y+0.1), -(ob.location.z+0.1),
|
|
# ob.rotation_euler.x, ob.rotation_euler.y, ob.rotation_euler.z))
|
|
|
|
direction = ( # XXX currently not used (replaced by track to?)
|
|
ob.location.x,
|
|
ob.location.y,
|
|
ob.location.z,
|
|
) # not taking matrix into account
|
|
rmatrix = global_matrix @ ob.matrix_world
|
|
|
|
# ob.rotation_euler.to_matrix().to_4x4() * mathutils.Vector((0,0,1))
|
|
# XXX Is result of the below offset by 90 degrees?
|
|
up = ob.matrix_world.to_3x3()[1].xyz # * global_matrix
|
|
|
|
# XXX TO CHANGE:
|
|
# formerly:
|
|
# tab_write(file, "#declare %s = rainbow {\n"%povdataname)
|
|
|
|
# clumsy for now but remove the rainbow from instancing
|
|
# system because not an object. use lamps later instead of meshes
|
|
|
|
# del data_ref[dataname]
|
|
tab_write(file, "rainbow {\n")
|
|
|
|
tab_write(file, "angle %.4f\n" % angle)
|
|
tab_write(file, "width %.4f\n" % width)
|
|
tab_write(file, "distance %.4f\n" % distance)
|
|
tab_write(file, "arc_angle %.4f\n" % ob.pov.arc_angle)
|
|
tab_write(file, "falloff_angle %.4f\n" % ob.pov.falloff_angle)
|
|
tab_write(file, "direction <%.4f,%.4f,%.4f>\n" % rmatrix.translation[:])
|
|
tab_write(file, "up <%.4f,%.4f,%.4f>\n" % (up[0], up[1], up[2]))
|
|
tab_write(file, "color_map {\n")
|
|
tab_write(file, "[0.000 color srgbt<1.0, 0.5, 1.0, 1.0>]\n")
|
|
tab_write(file, "[0.130 color srgbt<0.5, 0.5, 1.0, 0.9>]\n")
|
|
tab_write(file, "[0.298 color srgbt<0.2, 0.2, 1.0, 0.7>]\n")
|
|
tab_write(file, "[0.412 color srgbt<0.2, 1.0, 1.0, 0.4>]\n")
|
|
tab_write(file, "[0.526 color srgbt<0.2, 1.0, 0.2, 0.4>]\n")
|
|
tab_write(file, "[0.640 color srgbt<1.0, 1.0, 0.2, 0.4>]\n")
|
|
tab_write(file, "[0.754 color srgbt<1.0, 0.5, 0.2, 0.6>]\n")
|
|
tab_write(file, "[0.900 color srgbt<1.0, 0.2, 0.2, 0.7>]\n")
|
|
tab_write(file, "[1.000 color srgbt<1.0, 0.2, 0.2, 1.0>]\n")
|
|
tab_write(file, "}\n")
|
|
|
|
# tab_write(file, "texture {%s}\n"%pov_mat_name)
|
|
write_object_modifiers(ob, file)
|
|
# tab_write(file, "rotate x*90\n")
|
|
# matrix = global_matrix @ ob.matrix_world
|
|
# write_matrix(file, matrix)
|
|
tab_write(file, "}\n")
|
|
# continue #Don't render proxy mesh, skip to next object
|
|
|
|
|
|
def export_smoke(file, smoke_obj_name, smoke_path, comments, global_matrix):
|
|
"""export Blender smoke type fluids to pov media using df3 library"""
|
|
|
|
from .render import write_matrix, tab_write
|
|
|
|
flowtype = -1 # XXX todo: not used yet? should trigger emissive for fire type
|
|
depsgraph = bpy.context.evaluated_depsgraph_get()
|
|
smoke_obj = bpy.data.objects[smoke_obj_name].evaluated_get(depsgraph)
|
|
domain = None
|
|
smoke_modifier = None
|
|
# Search smoke domain target for smoke modifiers
|
|
for mod in smoke_obj.modifiers:
|
|
if mod.type == "FLUID":
|
|
if mod.fluid_type == "DOMAIN":
|
|
domain = smoke_obj
|
|
smoke_modifier = mod
|
|
|
|
elif mod.fluid_type == "FLOW":
|
|
if mod.flow_settings.flow_type == "BOTH":
|
|
flowtype = 2
|
|
elif mod.flow_settings.flow_type == "FIRE":
|
|
flowtype = 1
|
|
elif mod.flow_settings.flow_type == "SMOKE":
|
|
flowtype = 0
|
|
eps = 0.000001 # XXX not used currently. restore from corner case ... zero div?
|
|
if domain is not None:
|
|
mod_set = smoke_modifier.domain_settings
|
|
channeldata = []
|
|
for v in mod_set.density_grid:
|
|
channeldata.append(v.real)
|
|
print(v.real)
|
|
# -------- Usage in voxel texture:
|
|
# channeldata = []
|
|
# if channel == 'density':
|
|
# for v in mod_set.density_grid:
|
|
# channeldata.append(v.real)
|
|
|
|
# if channel == 'fire':
|
|
# for v in mod_set.flame_grid:
|
|
# channeldata.append(v.real)
|
|
|
|
resolution = mod_set.resolution_max
|
|
big_res = [
|
|
mod_set.domain_resolution[0],
|
|
mod_set.domain_resolution[1],
|
|
mod_set.domain_resolution[2],
|
|
]
|
|
|
|
if mod_set.use_noise:
|
|
big_res[0] = big_res[0] * (mod_set.noise_scale + 1)
|
|
big_res[1] = big_res[1] * (mod_set.noise_scale + 1)
|
|
big_res[2] = big_res[2] * (mod_set.noise_scale + 1)
|
|
# else:
|
|
# p = []
|
|
# -------- gather smoke domain settings
|
|
# BBox = domain.bound_box
|
|
# p.append([BBox[0][0], BBox[0][1], BBox[0][2]])
|
|
# p.append([BBox[6][0], BBox[6][1], BBox[6][2]])
|
|
# mod_set = smoke_modifier.domain_settings
|
|
# resolution = mod_set.resolution_max
|
|
# smokecache = mod_set.point_cache
|
|
# ret = read_cache(smokecache, mod_set.use_noise, mod_set.noise_scale + 1, flowtype)
|
|
# res_x = ret[0]
|
|
# res_y = ret[1]
|
|
# res_z = ret[2]
|
|
# density = ret[3]
|
|
# fire = ret[4]
|
|
|
|
# if res_x * res_y * res_z > 0:
|
|
# -------- new cache format
|
|
# big_res = []
|
|
# big_res.append(res_x)
|
|
# big_res.append(res_y)
|
|
# big_res.append(res_z)
|
|
# else:
|
|
# max = domain.dimensions[0]
|
|
# if (max - domain.dimensions[1]) < -eps:
|
|
# max = domain.dimensions[1]
|
|
|
|
# if (max - domain.dimensions[2]) < -eps:
|
|
# max = domain.dimensions[2]
|
|
|
|
# big_res = [int(round(resolution * domain.dimensions[0] / max, 0)),
|
|
# int(round(resolution * domain.dimensions[1] / max, 0)),
|
|
# int(round(resolution * domain.dimensions[2] / max, 0))]
|
|
|
|
# if mod_set.use_noise:
|
|
# big_res = [big_res[0] * (mod_set.noise_scale + 1),
|
|
# big_res[1] * (mod_set.noise_scale + 1),
|
|
# big_res[2] * (mod_set.noise_scale + 1)]
|
|
|
|
# if channel == 'density':
|
|
# channeldata = density
|
|
|
|
# if channel == 'fire':
|
|
# channeldata = fire
|
|
|
|
# sc_fr = '%s/%s/%s/%05d' % (
|
|
# efutil.export_path,
|
|
# efutil.scene_filename(),
|
|
# bpy.context.scene.name,
|
|
# bpy.context.scene.frame_current
|
|
# )
|
|
# if not os.path.exists( sc_fr ):
|
|
# os.makedirs(sc_fr)
|
|
#
|
|
# smoke_filename = '%s.smoke' % bpy.path.clean_name(domain.name)
|
|
# smoke_path = '/'.join([sc_fr, smoke_filename])
|
|
#
|
|
# with open(smoke_path, 'wb') as smoke_file:
|
|
# # Binary densitygrid file format
|
|
# #
|
|
# # File header
|
|
# smoke_file.write(b'SMOKE') #magic number
|
|
# smoke_file.write(struct.pack('<I', big_res[0]))
|
|
# smoke_file.write(struct.pack('<I', big_res[1]))
|
|
# smoke_file.write(struct.pack('<I', big_res[2]))
|
|
# Density data
|
|
# smoke_file.write(struct.pack('<%df'%len(channeldata), *channeldata))
|
|
#
|
|
# LuxLog('Binary SMOKE file written: %s' % (smoke_path))
|
|
|
|
# return big_res[0], big_res[1], big_res[2], channeldata
|
|
|
|
mydf3 = voxel_lib.df3(big_res[0], big_res[1], big_res[2])
|
|
sim_sizeX, sim_sizeY, sim_sizeZ = mydf3.size()
|
|
for x in range(sim_sizeX):
|
|
for y in range(sim_sizeY):
|
|
for z in range(sim_sizeZ):
|
|
mydf3.set(x, y, z, channeldata[((z * sim_sizeY + y) * sim_sizeX + x)])
|
|
try:
|
|
mydf3.exportDF3(smoke_path)
|
|
except ZeroDivisionError:
|
|
print("Show smoke simulation in 3D view before export")
|
|
print("Binary smoke.df3 file written in preview directory")
|
|
if comments:
|
|
file.write("\n//--Smoke--\n\n")
|
|
|
|
# Note: We start with a default unit cube.
|
|
# This is mandatory to read correctly df3 data - otherwise we could just directly use
|
|
# bbox coordinates from the start, and avoid scale/translate operations at the end...
|
|
file.write("box{<0,0,0>, <1,1,1>\n")
|
|
file.write(" pigment{ rgbt 1 }\n")
|
|
file.write(" hollow\n")
|
|
file.write(" interior{ //---------------------\n")
|
|
file.write(" media{ method 3\n")
|
|
file.write(" emission <1,1,1>*1\n") # 0>1 for dark smoke to white vapour
|
|
file.write(" scattering{ 1, // Type\n")
|
|
file.write(" <1,1,1>*0.1\n")
|
|
file.write(" } // end scattering\n")
|
|
file.write(' density{density_file df3 "%s"\n' % smoke_path)
|
|
file.write(" color_map {\n")
|
|
file.write(" [0.00 rgb 0]\n")
|
|
file.write(" [0.05 rgb 0]\n")
|
|
file.write(" [0.20 rgb 0.2]\n")
|
|
file.write(" [0.30 rgb 0.6]\n")
|
|
file.write(" [0.40 rgb 1]\n")
|
|
file.write(" [1.00 rgb 1]\n")
|
|
file.write(" } // end color_map\n")
|
|
file.write(" } // end of density\n")
|
|
file.write(" samples %i // higher = more precise\n" % resolution)
|
|
file.write(" } // end of media --------------------------\n")
|
|
file.write(" } // end of interior\n")
|
|
|
|
# START OF TRANSFORMATIONS
|
|
|
|
# Size to consider here are bbox dimensions (i.e. still in object space, *before* applying
|
|
# loc/rot/scale and other transformations (like parent stuff), aka matrix_world).
|
|
bbox = smoke_obj.bound_box
|
|
dim = [
|
|
abs(bbox[6][0] - bbox[0][0]),
|
|
abs(bbox[6][1] - bbox[0][1]),
|
|
abs(bbox[6][2] - bbox[0][2]),
|
|
]
|
|
|
|
# We scale our cube to get its final size and shapes but still in *object* space (same as Blender's bbox).
|
|
file.write("scale<%.6g,%.6g,%.6g>\n" % (dim[0], dim[1], dim[2]))
|
|
|
|
# We offset our cube such that (0,0,0) coordinate matches Blender's object center.
|
|
file.write("translate<%.6g,%.6g,%.6g>\n" % (bbox[0][0], bbox[0][1], bbox[0][2]))
|
|
|
|
# We apply object's transformations to get final loc/rot/size in world space!
|
|
# Note: we could combine the two previous transformations with this matrix directly...
|
|
write_matrix(file, global_matrix @ smoke_obj.matrix_world)
|
|
|
|
# END OF TRANSFORMATIONS
|
|
|
|
file.write("}\n")
|
|
|
|
# file.write(" interpolate 1\n")
|
|
# file.write(" frequency 0\n")
|
|
# file.write(" }\n")
|
|
# file.write("}\n")
|