render_povray/nodes_fn.py

   1 # SPDX-License-Identifier: GPL-2.0-or-later
   2
   3 """Translate complex shaders to exported POV textures."""
   4
   5 import bpy
   6
   7 # WARNING!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
   8 def write_nodes(pov_mat_name, ntree, file):
   9     """Translate Blender node trees to pov and write them to file."""
  10     # such function local inlined import are official guidelines
  11     # of Blender Foundation to lighten addons footprint at startup
  12     from os import path
  13     from .render import string_strip_hyphen
  14
  15     declare_nodes = []
  16     scene = bpy.context.scene
  17     for node in ntree.nodes:
  18         pov_node_name = string_strip_hyphen(bpy.path.clean_name(node.name)) + "_%s" % pov_mat_name
  19         if node.bl_idname == "PovrayFinishNode" and node.outputs["Finish"].is_linked:
  20             file.write("#declare %s = finish {\n" % pov_node_name)
  21             emission = node.inputs["Emission"].default_value
  22             if node.inputs["Emission"].is_linked:
  23                 pass
  24             file.write("    emission %.4g\n" % emission)
  25             for link in ntree.links:
  26                 if link.to_node == node:
  27
  28                     if link.from_node.bl_idname == "PovrayDiffuseNode":
  29                         intensity = 0
  30                         albedo = ""
  31                         brilliance = 0
  32                         crand = 0
  33                         if link.from_node.inputs["Intensity"].is_linked:
  34                             pass
  35                         else:
  36                             intensity = link.from_node.inputs["Intensity"].default_value
  37                         if link.from_node.inputs["Albedo"].is_linked:
  38                             pass
  39                         else:
  40                             if link.from_node.inputs["Albedo"].default_value:
  41                                 albedo = "albedo"
  42                         file.write("    diffuse %s %.4g\n" % (albedo, intensity))
  43                         if link.from_node.inputs["Brilliance"].is_linked:
  44                             pass
  45                         else:
  46                             brilliance = link.from_node.inputs["Brilliance"].default_value
  47                         file.write("    brilliance %.4g\n" % brilliance)
  48                         if link.from_node.inputs["Crand"].is_linked:
  49                             pass
  50                         else:
  51                             crand = link.from_node.inputs["Crand"].default_value
  52                         if crand > 0:
  53                             file.write("    crand %.4g\n" % crand)
  54
  55                     if link.from_node.bl_idname == "PovraySubsurfaceNode":
  56                         if scene.povray.sslt_enable:
  57                             energy = 0
  58                             r = g = b = 0
  59                             if link.from_node.inputs["Translucency"].is_linked:
  60                                 pass
  61                             else:
  62                                 r, g, b, a = link.from_node.inputs["Translucency"].default_value[:]
  63                             if link.from_node.inputs["Energy"].is_linked:
  64                                 pass
  65                             else:
  66                                 energy = link.from_node.inputs["Energy"].default_value
  67                             file.write(
  68                                 "    subsurface { translucency <%.4g,%.4g,%.4g>*%s }\n"
  69                                 % (r, g, b, energy)
  70                             )
  71
  72                     if link.from_node.bl_idname in {"PovraySpecularNode", "PovrayPhongNode"}:
  73                         intensity = 0
  74                         albedo = ""
  75                         roughness = 0
  76                         metallic = 0
  77                         phong_size = 0
  78                         highlight = "specular"
  79                         if link.from_node.inputs["Intensity"].is_linked:
  80                             pass
  81                         else:
  82                             intensity = link.from_node.inputs["Intensity"].default_value
  83
  84                         if link.from_node.inputs["Albedo"].is_linked:
  85                             pass
  86                         else:
  87                             if link.from_node.inputs["Albedo"].default_value:
  88                                 albedo = "albedo"
  89                         if link.from_node.bl_idname in {"PovrayPhongNode"}:
  90                             highlight = "phong"
  91                         file.write("    %s %s %.4g\n" % (highlight, albedo, intensity))
  92
  93                         if link.from_node.bl_idname in {"PovraySpecularNode"}:
  94                             if link.from_node.inputs["Roughness"].is_linked:
  95                                 pass
  96                             else:
  97                                 roughness = link.from_node.inputs["Roughness"].default_value
  98                             file.write("    roughness %.6g\n" % roughness)
  99
 100                         if link.from_node.bl_idname in {"PovrayPhongNode"}:
 101                             if link.from_node.inputs["Size"].is_linked:
 102                                 pass
 103                             else:
 104                                 phong_size = link.from_node.inputs["Size"].default_value
 105                             file.write("    phong_size %s\n" % phong_size)
 106
 107                         if link.from_node.inputs["Metallic"].is_linked:
 108                             pass
 109                         else:
 110                             metallic = link.from_node.inputs["Metallic"].default_value
 111                         file.write("    metallic %.4g\n" % metallic)
 112
 113                     if link.from_node.bl_idname in {"PovrayMirrorNode"}:
 114                         file.write("    reflection {\n")
 115                         color = None
 116                         exponent = 0
 117                         metallic = 0
 118                         falloff = 0
 119                         fresnel = ""
 120                         conserve = ""
 121                         if link.from_node.inputs["Color"].is_linked:
 122                             pass
 123                         else:
 124                             color = link.from_node.inputs["Color"].default_value[:]
 125                         file.write("    <%.4g,%.4g,%.4g>\n" % (color[0], color[1], color[2]))
 126
 127                         if link.from_node.inputs["Exponent"].is_linked:
 128                             pass
 129                         else:
 130                             exponent = link.from_node.inputs["Exponent"].default_value
 131                         file.write("    exponent %.4g\n" % exponent)
 132
 133                         if link.from_node.inputs["Falloff"].is_linked:
 134                             pass
 135                         else:
 136                             falloff = link.from_node.inputs["Falloff"].default_value
 137                         file.write("    falloff %.4g\n" % falloff)
 138
 139                         if link.from_node.inputs["Metallic"].is_linked:
 140                             pass
 141                         else:
 142                             metallic = link.from_node.inputs["Metallic"].default_value
 143                         file.write("    metallic %.4g" % metallic)
 144
 145                         if link.from_node.inputs["Fresnel"].is_linked:
 146                             pass
 147                         else:
 148                             if link.from_node.inputs["Fresnel"].default_value:
 149                                 fresnel = "fresnel"
 150
 151                         if link.from_node.inputs["Conserve energy"].is_linked:
 152                             pass
 153                         else:
 154                             if link.from_node.inputs["Conserve energy"].default_value:
 155                                 conserve = "conserve_energy"
 156
 157                         file.write("    %s}\n    %s\n" % (fresnel, conserve))
 158
 159                     if link.from_node.bl_idname == "PovrayAmbientNode":
 160                         ambient = (0, 0, 0)
 161                         if link.from_node.inputs["Ambient"].is_linked:
 162                             pass
 163                         else:
 164                             ambient = link.from_node.inputs["Ambient"].default_value[:]
 165                         file.write("    ambient <%.4g,%.4g,%.4g>\n" % ambient)
 166
 167                     if link.from_node.bl_idname in {"PovrayIridescenceNode"}:
 168                         file.write("    irid {\n")
 169                         amount = 0
 170                         thickness = 0
 171                         turbulence = 0
 172                         if link.from_node.inputs["Amount"].is_linked:
 173                             pass
 174                         else:
 175                             amount = link.from_node.inputs["Amount"].default_value
 176                         file.write("    %.4g\n" % amount)
 177
 178                         if link.from_node.inputs["Thickness"].is_linked:
 179                             pass
 180                         else:
 181                             exponent = link.from_node.inputs["Thickness"].default_value
 182                         file.write("    thickness %.4g\n" % thickness)
 183
 184                         if link.from_node.inputs["Turbulence"].is_linked:
 185                             pass
 186                         else:
 187                             falloff = link.from_node.inputs["Turbulence"].default_value
 188                         file.write("    turbulence %.4g}\n" % turbulence)
 189
 190             file.write("}\n")
 191
 192     for node in ntree.nodes:
 193         pov_node_name = string_strip_hyphen(bpy.path.clean_name(node.name)) + "_%s" % pov_mat_name
 194         if node.bl_idname == "PovrayTransformNode" and node.outputs["Transform"].is_linked:
 195             tx = node.inputs["Translate x"].default_value
 196             ty = node.inputs["Translate y"].default_value
 197             tz = node.inputs["Translate z"].default_value
 198             rx = node.inputs["Rotate x"].default_value
 199             ry = node.inputs["Rotate y"].default_value
 200             rz = node.inputs["Rotate z"].default_value
 201             sx = node.inputs["Scale x"].default_value
 202             sy = node.inputs["Scale y"].default_value
 203             sz = node.inputs["Scale z"].default_value
 204             file.write(
 205                 "#declare %s = transform {\n"
 206                 "    translate<%.4g,%.4g,%.4g>\n"
 207                 "    rotate<%.4g,%.4g,%.4g>\n"
 208                 "    scale<%.4g,%.4g,%.4g>}\n" % (pov_node_name, tx, ty, tz, rx, ry, rz, sx, sy, sz)
 209             )
 210
 211     for node in ntree.nodes:
 212         pov_node_name = string_strip_hyphen(bpy.path.clean_name(node.name)) + "_%s" % pov_mat_name
 213         if node.bl_idname == "PovrayColorImageNode" and node.outputs["Pigment"].is_linked:
 214             declare_nodes.append(node.name)
 215             if node.image == "":
 216                 file.write("#declare %s = pigment { color rgb 0.8}\n" % pov_node_name)
 217             else:
 218                 im = bpy.data.images[node.image]
 219                 if im.filepath and path.exists(bpy.path.abspath(im.filepath)):  # (os.path)
 220                     transform = ""
 221                     for link in ntree.links:
 222                         if (
 223                             link.from_node.bl_idname == "PovrayTransformNode"
 224                             and link.to_node == node
 225                         ):
 226                             pov_trans_name = (
 227                                 string_strip_hyphen(bpy.path.clean_name(link.from_node.name))
 228                                 + "_%s" % pov_mat_name
 229                             )
 230                             transform = "transform {%s}" % pov_trans_name
 231                     uv = ""
 232                     if node.map_type == "uv_mapping":
 233                         uv = "uv_mapping"
 234                     filepath = bpy.path.abspath(im.filepath)
 235                     file.write("#declare %s = pigment {%s image_map {\n" % (pov_node_name, uv))
 236                     premul = "off"
 237                     if node.premultiplied:
 238                         premul = "on"
 239                     once = ""
 240                     if node.once:
 241                         once = "once"
 242                     file.write(
 243                         '    "%s"\n    gamma %.6g\n    premultiplied %s\n'
 244                         % (filepath, node.inputs["Gamma"].default_value, premul)
 245                     )
 246                     file.write("    %s\n" % once)
 247                     if node.map_type != "uv_mapping":
 248                         file.write("    map_type %s\n" % node.map_type)
 249                     file.write(
 250                         "    interpolate %s\n    filter all %.4g\n    transmit all %.4g\n"
 251                         % (
 252                             node.interpolate,
 253                             node.inputs["Filter"].default_value,
 254                             node.inputs["Transmit"].default_value,
 255                         )
 256                     )
 257                     file.write("    }\n")
 258                     file.write("    %s\n" % transform)
 259                     file.write("    }\n")
 260
 261     for node in ntree.nodes:
 262         pov_node_name = string_strip_hyphen(bpy.path.clean_name(node.name)) + "_%s" % pov_mat_name
 263         if node.bl_idname == "PovrayImagePatternNode" and node.outputs["Pattern"].is_linked:
 264             declare_nodes.append(node.name)
 265             if node.image != "":
 266                 im = bpy.data.images[node.image]
 267                 if im.filepath and path.exists(bpy.path.abspath(im.filepath)):
 268                     transform = ""
 269                     for link in ntree.links:
 270                         if (
 271                             link.from_node.bl_idname == "PovrayTransformNode"
 272                             and link.to_node == node
 273                         ):
 274                             pov_trans_name = (
 275                                 string_strip_hyphen(bpy.path.clean_name(link.from_node.name))
 276                                 + "_%s" % pov_mat_name
 277                             )
 278                             transform = "transform {%s}" % pov_trans_name
 279                     uv = ""
 280                     if node.map_type == "uv_mapping":
 281                         uv = "uv_mapping"
 282                     filepath = bpy.path.abspath(im.filepath)
 283                     file.write("#macro %s() %s image_pattern {\n" % (pov_node_name, uv))
 284                     premul = "off"
 285                     if node.premultiplied:
 286                         premul = "on"
 287                     once = ""
 288                     if node.once:
 289                         once = "once"
 290                     file.write(
 291                         '    "%s"\n    gamma %.6g\n    premultiplied %s\n'
 292                         % (filepath, node.inputs["Gamma"].default_value, premul)
 293                     )
 294                     file.write("    %s\n" % once)
 295                     if node.map_type != "uv_mapping":
 296                         file.write("    map_type %s\n" % node.map_type)
 297                     file.write("    interpolate %s\n" % node.interpolate)
 298                     file.write("    }\n")
 299                     file.write("    %s\n" % transform)
 300                     file.write("#end\n")
 301
 302     for node in ntree.nodes:
 303         pov_node_name = string_strip_hyphen(bpy.path.clean_name(node.name)) + "_%s" % pov_mat_name
 304         if node.bl_idname == "PovrayBumpMapNode" and node.outputs["Normal"].is_linked:
 305             if node.image != "":
 306                 im = bpy.data.images[node.image]
 307                 if im.filepath and path.exists(bpy.path.abspath(im.filepath)):
 308                     transform = ""
 309                     for link in ntree.links:
 310                         if (
 311                             link.from_node.bl_idname == "PovrayTransformNode"
 312                             and link.to_node == node
 313                         ):
 314                             pov_trans_name = (
 315                                 string_strip_hyphen(bpy.path.clean_name(link.from_node.name))
 316                                 + "_%s" % pov_mat_name
 317                             )
 318                             transform = "transform {%s}" % pov_trans_name
 319                     uv = ""
 320                     if node.map_type == "uv_mapping":
 321                         uv = "uv_mapping"
 322                     filepath = bpy.path.abspath(im.filepath)
 323                     file.write("#declare %s = normal {%s bump_map {\n" % (pov_node_name, uv))
 324                     once = ""
 325                     if node.once:
 326                         once = "once"
 327                     file.write('    "%s"\n' % filepath)
 328                     file.write("    %s\n" % once)
 329                     if node.map_type != "uv_mapping":
 330                         file.write("    map_type %s\n" % node.map_type)
 331                     bump_size = node.inputs["Normal"].default_value
 332                     if node.inputs["Normal"].is_linked:
 333                         pass
 334                     file.write(
 335                         "    interpolate %s\n    bump_size %.4g\n" % (node.interpolate, bump_size)
 336                     )
 337                     file.write("    }\n")
 338                     file.write("    %s\n" % transform)
 339                     file.write("    }\n")
 340                     declare_nodes.append(node.name)
 341
 342     for node in ntree.nodes:
 343         pov_node_name = string_strip_hyphen(bpy.path.clean_name(node.name)) + "_%s" % pov_mat_name
 344         if node.bl_idname == "PovrayPigmentNode" and node.outputs["Pigment"].is_linked:
 345             declare_nodes.append(node.name)
 346             r, g, b = node.inputs["Color"].default_value[:]
 347             f = node.inputs["Filter"].default_value
 348             t = node.inputs["Transmit"].default_value
 349             if node.inputs["Color"].is_linked:
 350                 pass
 351             file.write(
 352                 "#declare %s = pigment{color srgbft <%.4g,%.4g,%.4g,%.4g,%.4g>}\n"
 353                 % (pov_node_name, r, g, b, f, t)
 354             )
 355
 356     for node in ntree.nodes:
 357         pov_node_name = string_strip_hyphen(bpy.path.clean_name(node.name)) + "_%s" % pov_mat_name
 358         if node.bl_idname == "PovrayTextureNode" and node.outputs["Texture"].is_linked:
 359             declare_nodes.append(node.name)
 360             r, g, b = node.inputs["Pigment"].default_value[:]
 361             pov_col_name = "color rgb <%.4g,%.4g,%.4g>" % (r, g, b)
 362             if node.inputs["Pigment"].is_linked:
 363                 for link in ntree.links:
 364                     if link.to_node == node and link.to_socket.name == "Pigment":
 365                         pov_col_name = (
 366                             string_strip_hyphen(bpy.path.clean_name(link.from_node.name))
 367                             + "_%s" % pov_mat_name
 368                         )
 369             file.write("#declare %s = texture{\n    pigment{%s}\n" % (pov_node_name, pov_col_name))
 370             if node.inputs["Normal"].is_linked:
 371                 for link in ntree.links:
 372                     if (
 373                         link.to_node == node
 374                         and link.to_socket.name == "Normal"
 375                         and link.from_node.name in declare_nodes
 376                     ):
 377                         pov_nor_name = (
 378                             string_strip_hyphen(bpy.path.clean_name(link.from_node.name))
 379                             + "_%s" % pov_mat_name
 380                         )
 381                         file.write("    normal{%s}\n" % pov_nor_name)
 382             if node.inputs["Finish"].is_linked:
 383                 for link in ntree.links:
 384                     if link.to_node == node and link.to_socket.name == "Finish":
 385                         pov_fin_name = (
 386                             string_strip_hyphen(bpy.path.clean_name(link.from_node.name))
 387                             + "_%s" % pov_mat_name
 388                         )
 389                         file.write("    finish{%s}\n" % pov_fin_name)
 390             file.write("}\n")
 391             declare_nodes.append(node.name)
 392
 393     for i in range(0, len(ntree.nodes)):
 394         for node in ntree.nodes:
 395             if node.bl_idname in {"ShaderNodeGroup", "ShaderTextureMapNode"}:
 396                 for output in node.outputs:
 397                     if (
 398                         output.name == "Texture"
 399                         and output.is_linked
 400                         and (node.name not in declare_nodes)
 401                     ):
 402                         declare = True
 403                         for link in ntree.links:
 404                             if link.to_node == node and link.to_socket.name not in {
 405                                 "",
 406                                 "Color ramp",
 407                                 "Mapping",
 408                                 "Transform",
 409                                 "Modifier",
 410                             }:
 411                                 if link.from_node.name not in declare_nodes:
 412                                     declare = False
 413                         if declare:
 414                             pov_node_name = (
 415                                 string_strip_hyphen(bpy.path.clean_name(node.name))
 416                                 + "_%s" % pov_mat_name
 417                             )
 418                             uv = ""
 419                             warp = ""
 420                             for link in ntree.links:
 421                                 if (
 422                                     link.to_node == node
 423                                     and link.from_node.bl_idname == "PovrayMappingNode"
 424                                     and link.from_node.warp_type != "NONE"
 425                                 ):
 426                                     w_type = link.from_node.warp_type
 427                                     if w_type == "uv_mapping":
 428                                         uv = "uv_mapping"
 429                                     else:
 430                                         tor = ""
 431                                         if w_type == "toroidal":
 432                                             tor = (
 433                                                 "major_radius %.4g"
 434                                                 % link.from_node.warp_tor_major_radius
 435                                             )
 436                                         orient = link.from_node.warp_orientation
 437                                         exp = link.from_node.warp_dist_exp
 438                                         warp = "warp{%s orientation %s dist_exp %.4g %s}" % (
 439                                             w_type,
 440                                             orient,
 441                                             exp,
 442                                             tor,
 443                                         )
 444                                         if link.from_node.warp_type == "planar":
 445                                             warp = "warp{%s %s %.4g}" % (w_type, orient, exp)
 446                                         if link.from_node.warp_type == "cubic":
 447                                             warp = "warp{%s}" % w_type
 448                             file.write("#declare %s = texture {%s\n" % (pov_node_name, uv))
 449                             pattern = node.inputs[0].default_value
 450                             advanced = ""
 451                             if node.inputs[0].is_linked:
 452                                 for link in ntree.links:
 453                                     if (
 454                                         link.to_node == node
 455                                         and link.from_node.bl_idname == "ShaderPatternNode"
 456                                     ):
 457                                         # ------------ advanced ------------------------- #
 458                                         lfn = link.from_node
 459                                         pattern = lfn.pattern
 460                                         if pattern == "agate":
 461                                             advanced = "agate_turb %.4g" % lfn.agate_turb
 462                                         if pattern == "crackle":
 463                                             advanced = "form <%.4g,%.4g,%.4g>" % (
 464                                                 lfn.crackle_form_x,
 465                                                 lfn.crackle_form_y,
 466                                                 lfn.crackle_form_z,
 467                                             )
 468                                             advanced += " metric %.4g" % lfn.crackle_metric
 469                                             if lfn.crackle_solid:
 470                                                 advanced += " solid"
 471                                         if pattern in {"spiral1", "spiral2"}:
 472                                             advanced = "%.4g" % lfn.spiral_arms
 473                                         if pattern in {"tiling"}:
 474                                             advanced = "%.4g" % lfn.tiling_number
 475                                         if pattern in {"gradient"}:
 476                                             advanced = "%s" % lfn.gradient_orient
 477                                     if (
 478                                         link.to_node == node
 479                                         and link.from_node.bl_idname == "PovrayImagePatternNode"
 480                                     ):
 481                                         pov_macro_name = (
 482                                             string_strip_hyphen(
 483                                                 bpy.path.clean_name(link.from_node.name)
 484                                             )
 485                                             + "_%s" % pov_mat_name
 486                                         )
 487                                         pattern = "%s()" % pov_macro_name
 488                             file.write("    %s %s %s\n" % (pattern, advanced, warp))
 489
 490                             repeat = ""
 491                             for link in ntree.links:
 492                                 if (
 493                                     link.to_node == node
 494                                     and link.from_node.bl_idname == "PovrayMultiplyNode"
 495                                 ):
 496                                     if link.from_node.amount_x > 1:
 497                                         repeat += "warp{repeat %.4g * x}" % link.from_node.amount_x
 498                                     if link.from_node.amount_y > 1:
 499                                         repeat += " warp{repeat %.4g * y}" % link.from_node.amount_y
 500                                     if link.from_node.amount_z > 1:
 501                                         repeat += " warp{repeat %.4g * z}" % link.from_node.amount_z
 502
 503                             transform = ""
 504                             for link in ntree.links:
 505                                 if (
 506                                     link.to_node == node
 507                                     and link.from_node.bl_idname == "PovrayTransformNode"
 508                                 ):
 509                                     pov_trans_name = (
 510                                         string_strip_hyphen(
 511                                             bpy.path.clean_name(link.from_node.name)
 512                                         )
 513                                         + "_%s" % pov_mat_name
 514                                     )
 515                                     transform = "transform {%s}" % pov_trans_name
 516                             x = 0
 517                             y = 0
 518                             z = 0
 519                             d = 0
 520                             e = 0
 521                             f = 0
 522                             g = 0
 523                             h = 0
 524                             modifier = False
 525                             for link in ntree.links:
 526                                 if (
 527                                     link.to_node == node
 528                                     and link.from_node.bl_idname == "PovrayModifierNode"
 529                                 ):
 530                                     modifier = True
 531                                     if link.from_node.inputs["Turb X"].is_linked:
 532                                         pass
 533                                     else:
 534                                         x = link.from_node.inputs["Turb X"].default_value
 535
 536                                     if link.from_node.inputs["Turb Y"].is_linked:
 537                                         pass
 538                                     else:
 539                                         y = link.from_node.inputs["Turb Y"].default_value
 540
 541                                     if link.from_node.inputs["Turb Z"].is_linked:
 542                                         pass
 543                                     else:
 544                                         z = link.from_node.inputs["Turb Z"].default_value
 545
 546                                     if link.from_node.inputs["Octaves"].is_linked:
 547                                         pass
 548                                     else:
 549                                         d = link.from_node.inputs["Octaves"].default_value
 550
 551                                     if link.from_node.inputs["Lambda"].is_linked:
 552                                         pass
 553                                     else:
 554                                         e = link.from_node.inputs["Lambda"].default_value
 555
 556                                     if link.from_node.inputs["Omega"].is_linked:
 557                                         pass
 558                                     else:
 559                                         f = link.from_node.inputs["Omega"].default_value
 560
 561                                     if link.from_node.inputs["Frequency"].is_linked:
 562                                         pass
 563                                     else:
 564                                         g = link.from_node.inputs["Frequency"].default_value
 565
 566                                     if link.from_node.inputs["Phase"].is_linked:
 567                                         pass
 568                                     else:
 569                                         h = link.from_node.inputs["Phase"].default_value
 570
 571                             turb = "turbulence <%.4g,%.4g,%.4g>" % (x, y, z)
 572                             octv = "octaves %s" % d
 573                             lmbd = "lambda %.4g" % e
 574                             omg = "omega %.4g" % f
 575                             freq = "frequency %.4g" % g
 576                             pha = "phase %.4g" % h
 577
 578                             file.write("\n")
 579                             if pattern not in {
 580                                 "checker",
 581                                 "hexagon",
 582                                 "square",
 583                                 "triangular",
 584                                 "brick",
 585                             }:
 586                                 file.write("    texture_map {\n")
 587                             if node.inputs["Color ramp"].is_linked:
 588                                 for link in ntree.links:
 589                                     if (
 590                                         link.to_node == node
 591                                         and link.from_node.bl_idname == "ShaderNodeValToRGB"
 592                                     ):
 593                                         els = link.from_node.color_ramp.elements
 594                                         n = -1
 595                                         for el in els:
 596                                             n += 1
 597                                             pov_in_mat_name = string_strip_hyphen(
 598                                                 bpy.path.clean_name(link.from_node.name)
 599                                             ) + "_%s_%s" % (n, pov_mat_name)
 600                                             default = True
 601                                             for ilink in ntree.links:
 602                                                 if (
 603                                                     ilink.to_node == node
 604                                                     and ilink.to_socket.name == str(n)
 605                                                 ):
 606                                                     default = False
 607                                                     pov_in_mat_name = (
 608                                                         string_strip_hyphen(
 609                                                             bpy.path.clean_name(
 610                                                                 ilink.from_node.name
 611                                                             )
 612                                                         )
 613                                                         + "_%s" % pov_mat_name
 614                                                     )
 615                                             if default:
 616                                                 r, g, b, a = el.color[:]
 617                                                 file.write(
 618                                                     "    #declare %s = texture{"
 619                                                     "pigment{"
 620                                                     "color srgbt <%.4g,%.4g,%.4g,%.4g>}};\n"
 621                                                     % (pov_in_mat_name, r, g, b, 1 - a)
 622                                                 )
 623                                             file.write(
 624                                                 "    [%s %s]\n" % (el.position, pov_in_mat_name)
 625                                             )
 626                             else:
 627                                 els = [[0, 0, 0, 0], [1, 1, 1, 1]]
 628                                 for t in range(0, 2):
 629                                     pov_in_mat_name = string_strip_hyphen(
 630                                         bpy.path.clean_name(link.from_node.name)
 631                                     ) + "_%s_%s" % (t, pov_mat_name)
 632                                     default = True
 633                                     for ilink in ntree.links:
 634                                         if ilink.to_node == node and ilink.to_socket.name == str(t):
 635                                             default = False
 636                                             pov_in_mat_name = (
 637                                                 string_strip_hyphen(
 638                                                     bpy.path.clean_name(ilink.from_node.name)
 639                                                 )
 640                                                 + "_%s" % pov_mat_name
 641                                             )
 642                                     if default:
 643                                         r, g, b = els[t][1], els[t][2], els[t][3]
 644                                         if pattern not in {
 645                                             "checker",
 646                                             "hexagon",
 647                                             "square",
 648                                             "triangular",
 649                                             "brick",
 650                                         }:
 651                                             file.write(
 652                                                 "    #declare %s = texture{pigment{color rgb <%.4g,%.4g,%.4g>}};\n"
 653                                                 % (pov_in_mat_name, r, g, b)
 654                                             )
 655                                         else:
 656                                             file.write(
 657                                                 "    texture{pigment{color rgb <%.4g,%.4g,%.4g>}}\n"
 658                                                 % (r, g, b)
 659                                             )
 660                                     if pattern not in {
 661                                         "checker",
 662                                         "hexagon",
 663                                         "square",
 664                                         "triangular",
 665                                         "brick",
 666                                     }:
 667                                         file.write("    [%s %s]\n" % (els[t][0], pov_in_mat_name))
 668                                     else:
 669                                         if not default:
 670                                             file.write("    texture{%s}\n" % pov_in_mat_name)
 671                             if pattern not in {
 672                                 "checker",
 673                                 "hexagon",
 674                                 "square",
 675                                 "triangular",
 676                                 "brick",
 677                             }:
 678                                 file.write("}\n")
 679                             if pattern == "brick":
 680                                 file.write(
 681                                     "brick_size <%.4g, %.4g, %.4g> mortar %.4g \n"
 682                                     % (
 683                                         node.brick_size_x,
 684                                         node.brick_size_y,
 685                                         node.brick_size_z,
 686                                         node.brick_mortar,
 687                                     )
 688                                 )
 689                             file.write("    %s %s" % (repeat, transform))
 690                             if modifier:
 691                                 file.write(
 692                                     " %s %s %s %s %s %s" % (turb, octv, lmbd, omg, freq, pha)
 693                                 )
 694                             file.write("}\n")
 695                             declare_nodes.append(node.name)
 696
 697     for link in ntree.links:
 698         if link.to_node.bl_idname == "PovrayOutputNode" and link.from_node.name in declare_nodes:
 699             pov_mat_node_name = (
 700                 string_strip_hyphen(bpy.path.clean_name(link.from_node.name)) + "_%s" % pov_mat_name
 701             )
 702             file.write("#declare %s = %s\n" % (pov_mat_name, pov_mat_node_name))