# SPDX-License-Identifier: GPL-2.0-or-later """ Get POV-Ray specific objects In and Out of Blender """ from math import pi, cos, sin import os.path import bpy from bpy_extras.object_utils import object_data_add from bpy_extras.io_utils import ImportHelper from bpy.utils import register_class, unregister_class from bpy.types import Operator from bpy.props import ( StringProperty, BoolProperty, IntProperty, FloatProperty, FloatVectorProperty, EnumProperty, ) from mathutils import Vector, Matrix from . import model_primitives class POV_OT_lathe_add(Operator): """Add the representation of POV lathe using a screw modifier.""" bl_idname = "pov.addlathe" bl_label = "Lathe" bl_description = "adds lathe" bl_options = {'REGISTER', 'UNDO'} COMPAT_ENGINES = {"POVRAY_RENDER"} def execute(self, context): # ayers=[False]*20 # layers[0]=True bpy.ops.curve.primitive_bezier_curve_add( location=context.scene.cursor.location, rotation=(0, 0, 0), # layers=layers, ) ob = context.view_layer.objects.active ob_data = ob.data ob.name = ob_data.name = "PovLathe" ob_data.dimensions = "2D" ob_data.transform(Matrix.Rotation(-pi / 2.0, 4, "Z")) ob.pov.object_as = "LATHE" self.report( {"INFO"}, "This native POV-Ray primitive" "won't have any vertex to show in edit mode" ) ob.pov.curveshape = "lathe" bpy.ops.object.modifier_add(type="SCREW") mod = ob.modifiers[-1] mod.axis = "Y" mod.show_render = False ob.update_tag() # as prop set via python not updated in depsgraph return {"FINISHED"} def pov_superellipsoid_define(context, op, ob): """Create the proxy mesh of a POV superellipsoid using pov_superellipsoid_define().""" if op: mesh = None u = op.se_u v = op.se_v n1 = op.se_n1 n2 = op.se_n2 edit = op.se_edit se_param1 = n2 # op.se_param1 se_param2 = n1 # op.se_param2 else: assert ob mesh = ob.data u = ob.pov.se_u v = ob.pov.se_v n1 = ob.pov.se_n1 n2 = ob.pov.se_n2 edit = ob.pov.se_edit se_param1 = ob.pov.se_param1 se_param2 = ob.pov.se_param2 verts = [] r = 1 stepSegment = 360 / v * pi / 180 stepRing = pi / u angSegment = 0 angRing = -pi / 2 step = 0 for ring in range(0, u - 1): angRing += stepRing for segment in range(0, v): step += 1 angSegment += stepSegment x = r * (abs(cos(angRing)) ** n1) * (abs(cos(angSegment)) ** n2) if (cos(angRing) < 0 < cos(angSegment)) or (cos(angRing) > 0 > cos(angSegment)): x = -x y = r * (abs(cos(angRing)) ** n1) * (abs(sin(angSegment)) ** n2) if (cos(angRing) < 0 < sin(angSegment)) or (cos(angRing) > 0 > sin(angSegment)): y = -y z = r * (abs(sin(angRing)) ** n1) if sin(angRing) < 0: z = -z x = round(x, 4) y = round(y, 4) z = round(z, 4) verts.append((x, y, z)) if edit == "TRIANGLES": verts.extend([(0, 0, 1),(0, 0, -1)]) faces = [] for i in range(0, u - 2): m = i * v for p in range(0, v): if p < v - 1: face = (m + p, 1 + m + p, v + 1 + m + p, v + m + p) if p == v - 1: face = (m + p, m, v + m, v + m + p) faces.append(face) if edit == "TRIANGLES": indexUp = len(verts) - 2 indexDown = len(verts) - 1 indexStartDown = len(verts) - 2 - v for i in range(0, v): if i < v - 1: face = (indexDown, i, i + 1) faces.append(face) if i == v - 1: face = (indexDown, i, 0) faces.append(face) for i in range(0, v): if i < v - 1: face = (indexUp, i + indexStartDown, i + indexStartDown + 1) faces.append(face) if i == v - 1: face = (indexUp, i + indexStartDown, indexStartDown) faces.append(face) if edit == "NGONS": face = list(range(v)) faces.append(face) face = [] indexUp = len(verts) - 1 for i in range(0, v): face.append(indexUp - i) faces.append(face) mesh = model_primitives.pov_define_mesh(mesh, verts, [], faces, "SuperEllipsoid") if not ob: ob = object_data_add(context, mesh, operator=None) # engine = context.scene.render.engine what for? ob = context.object ob.name = ob.data.name = "PovSuperellipsoid" ob.pov.se_param1 = n2 ob.pov.se_param2 = n1 ob.pov.se_u = u ob.pov.se_v = v ob.pov.se_n1 = n1 ob.pov.se_n2 = n2 ob.pov.se_edit = edit bpy.ops.object.mode_set(mode="EDIT") bpy.ops.mesh.hide(unselected=False) bpy.ops.object.mode_set(mode="OBJECT") ob.data.auto_smooth_angle = 1.3 bpy.ops.object.shade_smooth() ob.pov.object_as = "SUPERELLIPSOID" ob.update_tag() # as prop set via python not updated in depsgraph class POV_OT_superellipsoid_add(Operator): """Add the representation of POV superellipsoid using the pov_superellipsoid_define().""" bl_idname = "pov.addsuperellipsoid" bl_label = "Add SuperEllipsoid" bl_description = "Create a SuperEllipsoid" bl_options = {'REGISTER', 'UNDO'} COMPAT_ENGINES = {"POVRAY_RENDER"} # Keep in sync within model_properties.py section Superellipsoid # as this allows interactive update # If someone knows how to define operators' props from a func, I'd be delighted to learn it! # XXX ARE the first two used for import ? could we hide or suppress them otherwise? se_param1: FloatProperty(name="Parameter 1", description="", min=0.00, max=10.0, default=0.04) se_param2: FloatProperty(name="Parameter 2", description="", min=0.00, max=10.0, default=0.04) se_u: IntProperty( name="U-segments", description="radial segmentation", default=20, min=4, max=265 ) se_v: IntProperty( name="V-segments", description="lateral segmentation", default=20, min=4, max=265 ) se_n1: FloatProperty( name="Ring manipulator", description="Manipulates the shape of the Ring", default=1.0, min=0.01, max=100.0, ) se_n2: FloatProperty( name="Cross manipulator", description="Manipulates the shape of the cross-section", default=1.0, min=0.01, max=100.0, ) se_edit: EnumProperty( items=[("NOTHING", "Nothing", ""), ("NGONS", "N-Gons", ""), ("TRIANGLES", "Triangles", "")], name="Fill up and down", description="", default="TRIANGLES", ) @classmethod def poll(cls, context): engine = context.scene.render.engine return engine in cls.COMPAT_ENGINES def execute(self, context): pov_superellipsoid_define(context, self, None) self.report( {"INFO"}, "This native POV-Ray primitive" "won't have any vertex to show in edit mode" ) return {"FINISHED"} class POV_OT_superellipsoid_update(Operator): """Update the superellipsoid. Delete its previous proxy geometry and rerun pov_superellipsoid_define() function with the new parameters""" bl_idname = "pov.superellipsoid_update" bl_label = "Update" bl_description = "Update Superellipsoid" bl_options = {'REGISTER', 'UNDO'} COMPAT_ENGINES = {"POVRAY_RENDER"} @classmethod def poll(cls, context): engine = context.scene.render.engine ob = context.object return ob and ob.data and ob.type == "MESH" and engine in cls.COMPAT_ENGINES def execute(self, context): bpy.ops.object.mode_set(mode="EDIT") bpy.ops.mesh.reveal() bpy.ops.mesh.select_all(action="SELECT") bpy.ops.mesh.delete(type="VERT") bpy.ops.object.mode_set(mode="OBJECT") pov_superellipsoid_define(context, None, context.object) return {"FINISHED"} def create_faces(vert_idx_1, vert_idx_2, closed=False, flipped=False): """Generate viewport proxy mesh data for some pov primitives""" faces = [] if not vert_idx_1 or not vert_idx_2: return None if len(vert_idx_1) < 2 and len(vert_idx_2) < 2: return None fan = False if len(vert_idx_1) != len(vert_idx_2): if len(vert_idx_1) == 1 and len(vert_idx_2) > 1: fan = True else: return None total = len(vert_idx_2) if closed: if flipped: face = [vert_idx_1[0], vert_idx_2[0], vert_idx_2[total - 1]] if not fan: face.append(vert_idx_1[total - 1]) else: face = [vert_idx_2[0], vert_idx_1[0]] if not fan: face.append(vert_idx_1[total - 1]) face.append(vert_idx_2[total - 1]) faces.append(face) for num in range(total - 1): if flipped: if fan: face = [vert_idx_2[num], vert_idx_1[0], vert_idx_2[num + 1]] else: face = [vert_idx_2[num], vert_idx_1[num], vert_idx_1[num + 1], vert_idx_2[num + 1]] elif fan: face = [vert_idx_1[0], vert_idx_2[num], vert_idx_2[num + 1]] else: face = [vert_idx_1[num], vert_idx_2[num], vert_idx_2[num + 1], vert_idx_1[num + 1]] faces.append(face) return faces def power(a, b): """Workaround to negative a, where the math.pow() method would return a ValueError.""" return -((-a) ** b) if a < 0 else a**b def supertoroid(R, r, u, v, n1, n2): a = 2 * pi / u b = 2 * pi / v verts = [] faces = [] for i in range(u): s = power(sin(i * a), n1) c = power(cos(i * a), n1) for j in range(v): c2 = R + r * power(cos(j * b), n2) s2 = r * power(sin(j * b), n2) verts.append((c * c2, s * c2, s2)) # type as a (mathutils.Vector(c*c2,s*c2,s2))? if i > 0: f = create_faces(range((i - 1) * v, i * v), range(i * v, (i + 1) * v), closed=True) faces.extend(f) f = create_faces(range((u - 1) * v, u * v), range(v), closed=True) faces.extend(f) return verts, faces def pov_supertorus_define(context, op, ob): """Get POV supertorus properties from operator (object creation/import) or data update.""" if op: mesh = None st_R = op.st_R st_r = op.st_r st_u = op.st_u st_v = op.st_v st_n1 = op.st_n1 st_n2 = op.st_n2 st_ie = op.st_ie st_edit = op.st_edit else: assert ob mesh = ob.data st_R = ob.pov.st_major_radius st_r = ob.pov.st_minor_radius st_u = ob.pov.st_u st_v = ob.pov.st_v st_n1 = ob.pov.st_ring st_n2 = ob.pov.st_cross st_ie = ob.pov.st_ie st_edit = ob.pov.st_edit if st_ie: rad1 = (st_R + st_r) / 2 rad2 = (st_R - st_r) / 2 if rad2 > rad1: [rad1, rad2] = [rad2, rad1] else: rad1 = st_R rad2 = st_r if rad2 > rad1: rad1 = rad2 verts, faces = supertoroid(rad1, rad2, st_u, st_v, st_n1, st_n2) mesh = model_primitives.pov_define_mesh(mesh, verts, [], faces, "PovSuperTorus", True) if not ob: ob = object_data_add(context, mesh, operator=None) ob.pov.object_as = "SUPERTORUS" ob.pov.st_major_radius = st_R ob.pov.st_minor_radius = st_r ob.pov.st_u = st_u ob.pov.st_v = st_v ob.pov.st_ring = st_n1 ob.pov.st_cross = st_n2 ob.pov.st_ie = st_ie ob.pov.st_edit = st_edit ob.update_tag() # as prop set via python not updated in depsgraph class POV_OT_supertorus_add(Operator): """Add the representation of POV supertorus using the pov_supertorus_define() function.""" bl_idname = "pov.addsupertorus" bl_label = "Add Supertorus" bl_description = "Create a SuperTorus" bl_options = {'REGISTER', 'UNDO'} COMPAT_ENGINES = {"POVRAY_RENDER"} st_R: FloatProperty( name="big radius", description="The radius inside the tube", default=1.0, min=0.01, max=100.0, ) st_r: FloatProperty( name="small radius", description="The radius of the tube", default=0.3, min=0.01, max=100.0 ) st_u: IntProperty( name="U-segments", description="radial segmentation", default=16, min=3, max=265 ) st_v: IntProperty( name="V-segments", description="lateral segmentation", default=8, min=3, max=265 ) st_n1: FloatProperty( name="Ring manipulator", description="Manipulates the shape of the Ring", default=1.0, min=0.01, max=100.0, ) st_n2: FloatProperty( name="Cross manipulator", description="Manipulates the shape of the cross-section", default=1.0, min=0.01, max=100.0, ) st_ie: BoolProperty( name="Use Int.+Ext. radii", description="Use internal and external radii", default=False ) st_edit: BoolProperty(name="", description="", default=False, options={"HIDDEN"}) @classmethod def poll(cls, context): engine = context.scene.render.engine return engine in cls.COMPAT_ENGINES def execute(self, context): pov_supertorus_define(context, self, None) self.report( {"INFO"}, "This native POV-Ray primitive" "won't have any vertex to show in edit mode" ) return {"FINISHED"} class POV_OT_supertorus_update(Operator): """Update the supertorus. Delete its previous proxy geometry and rerun pov_supetorus_define() function with the new parameters""" bl_idname = "pov.supertorus_update" bl_label = "Update" bl_description = "Update SuperTorus" bl_options = {'REGISTER', 'UNDO'} COMPAT_ENGINES = {"POVRAY_RENDER"} @classmethod def poll(cls, context): engine = context.scene.render.engine ob = context.object return ob and ob.data and ob.type == "MESH" and engine in cls.COMPAT_ENGINES def execute(self, context): bpy.ops.object.mode_set(mode="EDIT") bpy.ops.mesh.reveal() bpy.ops.mesh.select_all(action="SELECT") bpy.ops.mesh.delete(type="VERT") bpy.ops.object.mode_set(mode="OBJECT") pov_supertorus_define(context, None, context.object) return {"FINISHED"} # ----------------------------------------------------------------------------- class POV_OT_loft_add(Operator): """Create the representation of POV loft using Blender curves.""" bl_idname = "pov.addloft" bl_label = "Add Loft Data" bl_description = "Create a Curve data for Meshmaker" bl_options = {'REGISTER', 'UNDO'} COMPAT_ENGINES = {"POVRAY_RENDER"} loft_n: IntProperty( name="Segments", description="Vertical segments", default=16, min=3, max=720 ) loft_rings_bottom: IntProperty( name="Bottom", description="Bottom rings", default=5, min=2, max=100 ) loft_rings_side: IntProperty(name="Side", description="Side rings", default=10, min=2, max=100) loft_thick: FloatProperty( name="Thickness", description="Manipulates the shape of the Ring", default=0.3, min=0.01, max=1.0, ) loft_r: FloatProperty(name="Radius", description="Radius", default=1, min=0.01, max=10) loft_height: FloatProperty( name="Height", description="Manipulates the shape of the Ring", default=2, min=0.01, max=10.0, ) def execute(self, context): props = self.properties loft_data = bpy.data.curves.new("Loft", type="CURVE") loft_data.dimensions = "3D" loft_data.resolution_u = 2 # loft_data.show_normal_face = False # deprecated in 2.8 n = props.loft_n thick = props.loft_thick side = props.loft_rings_side bottom = props.loft_rings_bottom h = props.loft_height r = props.loft_r distB = r / bottom r0 = 0.00001 z = -h / 2 print("New") for i in range(bottom + 1): coords = [] angle = 0 for p in range(n): x = r0 * cos(angle) y = r0 * sin(angle) coords.append((x, y, z)) angle += pi * 2 / n r0 += distB nurbs = loft_data.splines.new("NURBS") nurbs.points.add(len(coords) - 1) for c, coord in enumerate(coords): x, y, z = coord nurbs.points[c].co = (x, y, z, 1) nurbs.use_cyclic_u = True for i in range(side): z += h / side coords = [] angle = 0 for p in range(n): x = r * cos(angle) y = r * sin(angle) coords.append((x, y, z)) angle += pi * 2 / n nurbs = loft_data.splines.new("NURBS") nurbs.points.add(len(coords) - 1) for c, coord in enumerate(coords): x, y, z = coord nurbs.points[c].co = (x, y, z, 1) nurbs.use_cyclic_u = True r -= thick for i in range(side): coords = [] angle = 0 for p in range(n): x = r * cos(angle) y = r * sin(angle) coords.append((x, y, z)) angle += pi * 2 / n nurbs = loft_data.splines.new("NURBS") nurbs.points.add(len(coords) - 1) for c, coord in enumerate(coords): x, y, z = coord nurbs.points[c].co = (x, y, z, 1) nurbs.use_cyclic_u = True z -= h / side z = (-h / 2) + thick distB = (r - 0.00001) / bottom for i in range(bottom + 1): coords = [] angle = 0 for p in range(n): x = r * cos(angle) y = r * sin(angle) coords.append((x, y, z)) angle += pi * 2 / n r -= distB nurbs = loft_data.splines.new("NURBS") nurbs.points.add(len(coords) - 1) for c, coord in enumerate(coords): x, y, z = coord nurbs.points[c].co = (x, y, z, 1) nurbs.use_cyclic_u = True ob = bpy.data.objects.new("Loft_shape", loft_data) scn = bpy.context.scene scn.collection.objects.link(ob) context.view_layer.objects.active = ob ob.select_set(True) ob.pov.curveshape = "loft" return {"FINISHED"} # ----------------------------------- ISOSURFACES ----------------------------------- # def pov_isosurface_view_define(context, op, ob, loc): """create the representation of POV isosurface using a Blender empty.""" if op: eq = op.isosurface_eq loc = bpy.context.scene.cursor.location else: assert ob eq = ob.pov.isosurface_eq # keep object rotation and location for the add object operator obrot = ob.rotation_euler # obloc = ob.location obscale = ob.scale # bpy.ops.object.empty_add(type='CUBE', location=loc, rotation=obrot) bpy.ops.mesh.primitive_emptyvert_add() # bpy.ops.transform.rotate(axis=obrot,orient_type='GLOBAL') bpy.ops.transform.resize(value=obscale) # bpy.ops.transform.rotate(axis=obrot, proportional_size=1) bpy.ops.object.mode_set(mode="OBJECT") if not ob: # bpy.ops.object.empty_add(type='CUBE', location=loc) bpy.ops.mesh.primitive_emptyvert_add() ob = context.object ob.name = ob.data.name = "PovIsosurface" ob.pov.object_as = "ISOSURFACE_VIEW" ob.pov.isosurface_eq = eq ob.pov.contained_by = "box" bpy.ops.object.mode_set(mode="OBJECT") ob.update_tag() # as prop set via python not updated in depsgraph class POV_OT_isosurface_add(Operator): """Add the representation of POV isosurface sphere by a Blender mesh icosphere. Flag its primitive type with a specific pov.object_as attribute and lock edit mode to keep proxy consistency by hiding edit geometry.""" bl_idname = "pov.addisosurface" bl_label = "Generic Isosurface" bl_description = "Add Isosurface" bl_options = {'REGISTER', 'UNDO'} COMPAT_ENGINES = {"POVRAY_RENDER"} # Keep in sync within model_properties.py section Sphere # as this allows interactive update isosurface_eq: StringProperty( name="f(x,y,z)=", description="Type the POV Isosurface function syntax for equation, " "pattern,etc. ruling an implicit surface to be rendered", default="sqrt(pow(x,2) + pow(y,2) + pow(z,2)) - 1.5", ) imported_loc: FloatVectorProperty( name="Imported Pov location", precision=6, default=(0.0, 0.0, 0.0) ) def execute(self, context): # layers = 20*[False] # layers[0] = True props = self.properties if ob := context.object: if ob.pov.imported_loc: LOC = ob.pov.imported_loc elif not props.imported_loc: LOC = bpy.context.scene.cursor.location else: LOC = props.imported_loc try: pov_isosurface_view_define(context, self, None, LOC) self.report( {"INFO"}, "This native POV-Ray primitive " "is only an abstract proxy in Blender" ) except AttributeError: self.report({"INFO"}, "Please enable Add Mesh: Extra Objects addon") return {"FINISHED"} class POV_OT_isosurface_update(Operator): """Update the POV isosurface. Rerun pov_isosurface_view_define() function with the new parameters""" bl_idname = "pov.isosurface_update" bl_label = "Update" bl_description = "Update Isosurface" bl_options = {'REGISTER', 'UNDO'} COMPAT_ENGINES = {"POVRAY_RENDER"} @classmethod def poll(cls, context): engine = context.scene.render.engine ob = context.object return ob and ob.data and ob.type == "ISOSURFACE_VIEW" and engine in cls.COMPAT_ENGINES def execute(self, context): pov_isosurface_view_define(context, None, context.object, context.object.location) return {"FINISHED"} class POV_OT_isosurface_box_add(Operator): """Add the representation of POV isosurface box using also just a Blender mesh cube. Flag its primitive type with a specific pov.object_as attribute and lock edit mode to keep proxy consistency by hiding edit geometry.""" bl_idname = "pov.addisosurfacebox" bl_label = "Isosurface Box" bl_description = "Add Isosurface contained by Box" bl_options = {'REGISTER', 'UNDO'} COMPAT_ENGINES = {"POVRAY_RENDER"} def execute(self, context): # layers = 20*[False] # layers[0] = True bpy.ops.mesh.primitive_cube_add() ob = context.object bpy.ops.object.mode_set(mode="EDIT") self.report( {"INFO"}, "This native POV-Ray primitive " "won't have any vertex to show in edit mode" ) bpy.ops.mesh.hide(unselected=False) bpy.ops.object.mode_set(mode="OBJECT") ob.pov.object_as = "ISOSURFACE_NODE" ob.pov.contained_by = "box" ob.name = "PovIsosurfaceBox" ob.update_tag() # as prop set via python not updated in depsgraph return {"FINISHED"} class POV_OT_isosurface_sphere_add(Operator): """Add the representation of POV isosurface sphere by a Blender mesh icosphere. Flag its primitive type with a specific pov.object_as attribute and lock edit mode to keep proxy consistency by hiding edit geometry.""" bl_idname = "pov.addisosurfacesphere" bl_label = "Isosurface Sphere" bl_description = "Add Isosurface contained by Sphere" bl_options = {'REGISTER', 'UNDO'} COMPAT_ENGINES = {"POVRAY_RENDER"} def execute(self, context): # layers = 20*[False] # layers[0] = True bpy.ops.mesh.primitive_ico_sphere_add(subdivisions=4) ob = context.object bpy.ops.object.mode_set(mode="EDIT") self.report( {"INFO"}, "This native POV-Ray primitive " "won't have any vertex to show in edit mode" ) bpy.ops.mesh.hide(unselected=False) bpy.ops.object.mode_set(mode="OBJECT") bpy.ops.object.shade_smooth() ob.pov.object_as = "ISOSURFACE_NODE" ob.pov.contained_by = "sphere" ob.name = "PovIsosurfaceSphere" ob.update_tag() # as prop set via python not updated in depsgraph return {"FINISHED"} class POV_OT_sphere_sweep_add(Operator): """Add the representation of POV sphere_sweep using a Blender NURBS curve. Flag its primitive type with a specific ob.pov.curveshape attribute and leave access to edit mode to keep user editable handles.""" bl_idname = "pov.addspheresweep" bl_label = "Sphere Sweep" bl_description = "Create Sphere Sweep along curve" bl_options = {'REGISTER', 'UNDO'} COMPAT_ENGINES = {"POVRAY_RENDER"} def execute(self, context): # layers = 20*[False] # layers[0] = True bpy.ops.curve.primitive_nurbs_curve_add() ob = context.object ob.name = ob.data.name = "PovSphereSweep" ob.pov.curveshape = "sphere_sweep" ob.data.bevel_depth = 0.02 ob.data.bevel_resolution = 4 ob.data.fill_mode = "FULL" # ob.data.splines[0].order_u = 4 return {"FINISHED"} class POV_OT_blobsphere_add(Operator): """Add the representation of POV blob using a Blender meta ball. No need to flag its primitive type as meta are exported to blobs and leave access to edit mode to keep user editable thresholds.""" bl_idname = "pov.addblobsphere" bl_label = "Blob Sphere" bl_description = "Add Blob Sphere" bl_options = {'REGISTER', 'UNDO'} COMPAT_ENGINES = {"POVRAY_RENDER"} def execute(self, context): # layers = 20*[False] # layers[0] = True bpy.ops.object.metaball_add(type="BALL") ob = context.object ob.name = "PovBlob" return {"FINISHED"} class POV_OT_blobcapsule_add(Operator): """Add the representation of POV blob using a Blender meta ball. No need to flag its primitive type as meta are exported to blobs and leave access to edit mode to keep user editable thresholds.""" bl_idname = "pov.addblobcapsule" bl_label = "Blob Capsule" bl_description = "Add Blob Capsule" bl_options = {'REGISTER', 'UNDO'} COMPAT_ENGINES = {"POVRAY_RENDER"} def execute(self, context): # layers = 20*[False] # layers[0] = True bpy.ops.object.metaball_add(type="CAPSULE") ob = context.object ob.name = "PovBlob" return {"FINISHED"} class POV_OT_blobplane_add(Operator): """Add the representation of POV blob using a Blender meta ball. No need to flag its primitive type as meta are exported to blobs and leave access to edit mode to keep user editable thresholds.""" bl_idname = "pov.addblobplane" bl_label = "Blob Plane" bl_description = "Add Blob Plane" bl_options = {'REGISTER', 'UNDO'} COMPAT_ENGINES = {"POVRAY_RENDER"} def execute(self, context): # layers = 20*[False] # layers[0] = True bpy.ops.object.metaball_add(type="PLANE") ob = context.object ob.name = "PovBlob" return {"FINISHED"} class POV_OT_blobellipsoid_add(Operator): """Add the representation of POV blob using a Blender meta ball. No need to flag its primitive type as meta are exported to blobs and leave access to edit mode to keep user editable thresholds.""" bl_idname = "pov.addblobellipsoid" bl_label = "Blob Ellipsoid" bl_description = "Add Blob Ellipsoid" def execute(self, context): # layers = 20*[False] # layers[0] = True bpy.ops.object.metaball_add(type="ELLIPSOID") ob = context.object ob.name = "PovBlob" return {"FINISHED"} class POV_OT_blobcube_add(Operator): """Add the representation of POV blob using a Blender meta ball. No need to flag its primitive type as meta are exported to blobs and leave access to edit mode to keep user editable thresholds.""" bl_idname = "pov.addblobcube" bl_label = "Blob Cube" bl_description = "Add Blob Cube" bl_options = {'REGISTER', 'UNDO'} COMPAT_ENGINES = {"POVRAY_RENDER"} def execute(self, context): # layers = 20*[False] # layers[0] = True bpy.ops.object.metaball_add(type="CUBE") ob = context.object ob.name = "PovBlob" return {"FINISHED"} class POV_OT_height_field_add(bpy.types.Operator, ImportHelper): """Add the representation of POV height_field using a displaced grid. texture slot fix and displace modifier will be needed because noise displace operator was deprecated in 2.8""" bl_idname = "pov.addheightfield" bl_label = "Height Field" bl_description = "Add Height Field" bl_options = {'REGISTER', 'UNDO'} COMPAT_ENGINES = {"POVRAY_RENDER"} # Keep in sync within model_properties.py section HeightFields # as this allows interactive update # filename_ext = ".png" # filter_glob = StringProperty( # default="*.exr;*.gif;*.hdr;*.iff;*.jpeg;*.jpg;*.pgm;*.png;*.pot;*.ppm;*.sys;*.tga;*.tiff;*.EXR;*.GIF;*.HDR;*.IFF;*.JPEG;*.JPG;*.PGM;*.PNG;*.POT;*.PPM;*.SYS;*.TGA;*.TIFF", # options={'HIDDEN'}, # ) quality: IntProperty(name="Quality", description="", default=100, min=1, max=100) hf_filename: StringProperty(maxlen=1024) hf_gamma: FloatProperty(name="Gamma", description="Gamma", min=0.0001, max=20.0, default=1.0) hf_premultiplied: BoolProperty(name="Premultiplied", description="Premultiplied", default=True) hf_smooth: BoolProperty(name="Smooth", description="Smooth", default=False) hf_water: FloatProperty( name="Water Level", description="Wather Level", min=0.00, max=1.00, default=0.0 ) hf_hierarchy: BoolProperty(name="Hierarchy", description="Height field hierarchy", default=True) def execute(self, context): props = self.properties impath = bpy.path.abspath(self.filepath) img = bpy.data.images.load(impath) im_name = img.name im_name, file_extension = os.path.splitext(im_name) hf_tex = bpy.data.textures.new("%s_hf_image" % im_name, type="IMAGE") hf_tex.image = img mat = bpy.data.materials.new("Tex_%s_hf" % im_name) hf_slot = mat.pov_texture_slots.add() hf_slot.texture = hf_tex.name # layers = 20*[False] # layers[0] = True quality = props.quality res = 100 / quality w, h = hf_tex.image.size[:] w = int(w / res) h = int(h / res) bpy.ops.mesh.primitive_grid_add(x_subdivisions=w, y_subdivisions=h, size=0.5) ob = context.object ob.name = ob.data.name = "%s" % im_name ob.data.materials.append(mat) bpy.ops.object.mode_set(mode="EDIT") # bpy.ops.mesh.noise(factor=1) # TODO replace by displace modifier, noise deprecated in 2.8 bpy.ops.object.mode_set(mode="OBJECT") # needs a loop to select by index? # bpy.ops.object.material_slot_remove() # material just left there for now mat.pov_texture_slots.clear() bpy.ops.object.mode_set(mode="EDIT") bpy.ops.mesh.hide(unselected=False) bpy.ops.object.mode_set(mode="OBJECT") ob.pov.object_as = "HEIGHT_FIELD" # POV-Ray will soon use only forwards slashes on every OS and already can forward_impath = impath.replace(os.sep, "/") ob.pov.hf_filename = forward_impath ob.update_tag() # as prop set via python not updated in depsgraph return {"FINISHED"} # ----------------------------------- PARAMETRIC ----------------------------------- # def pov_parametric_define(context, op, ob): """Add the representation of POV parametric surfaces by math surface from add mesh extra objects addon. Picking properties either from creation operator, import, or data update. But flag its primitive type with a specific pov.object_as attribute and lock edit mode to keep proxy consistency by hiding edit geometry.""" if op: u_min = op.u_min u_max = op.u_max v_min = op.v_min v_max = op.v_max x_eq = op.x_eq y_eq = op.y_eq z_eq = op.z_eq else: assert ob u_min = ob.pov.u_min u_max = ob.pov.u_max v_min = ob.pov.v_min v_max = ob.pov.v_max x_eq = ob.pov.x_eq y_eq = ob.pov.y_eq z_eq = ob.pov.z_eq # keep object rotation and location for the updated object obloc = ob.location obrot = ob.rotation_euler # In radians # Parametric addon has no loc rot, some extra work is needed # in case cursor has moved curloc = bpy.context.scene.cursor.location bpy.ops.object.mode_set(mode="EDIT") bpy.ops.mesh.reveal() bpy.ops.mesh.select_all(action="SELECT") bpy.ops.mesh.delete(type="VERT") bpy.ops.mesh.primitive_xyz_function_surface( x_eq=x_eq, y_eq=y_eq, z_eq=z_eq, range_u_min=u_min, range_u_max=u_max, range_v_min=v_min, range_v_max=v_max, ) bpy.ops.mesh.select_all(action="SELECT") # extra work: bpy.ops.transform.translate(value=(obloc - curloc), proportional_size=1) # XXX TODO : https://devtalk.blender.org/t/bpy-ops-transform-rotate-option-axis/6235/7 # to complete necessary extra work rotation, after updating from blender version > 2.92 # update and uncomment below, but simple axis deprecated since 2.8 # bpy.ops.transform.rotate(axis=obrot, proportional_size=1) bpy.ops.mesh.hide(unselected=False) bpy.ops.object.mode_set(mode="OBJECT") if not ob: bpy.ops.mesh.primitive_xyz_function_surface( x_eq=x_eq, y_eq=y_eq, z_eq=z_eq, range_u_min=u_min, range_u_max=u_max, range_v_min=v_min, range_v_max=v_max, ) ob = context.object ob.name = ob.data.name = "PovParametric" ob.pov.u_min = u_min ob.pov.u_max = u_max ob.pov.v_min = v_min ob.pov.v_max = v_max ob.pov.x_eq = x_eq ob.pov.y_eq = y_eq ob.pov.z_eq = z_eq bpy.ops.object.mode_set(mode="EDIT") bpy.ops.mesh.hide(unselected=False) bpy.ops.object.mode_set(mode="OBJECT") ob.data.auto_smooth_angle = 0.6 bpy.ops.object.shade_smooth() ob.pov.object_as = "PARAMETRIC" ob.update_tag() # as prop set via python not updated in depsgraph return{'FINISHED'} class POV_OT_parametric_add(Operator): """Add the representation of POV parametric surfaces using pov_parametric_define() function.""" bl_idname = "pov.addparametric" bl_label = "Parametric" bl_description = "Add Paramertic" bl_options = {'REGISTER', 'UNDO'} COMPAT_ENGINES = {"POVRAY_RENDER"} # Keep in sync within model_properties.py section Parametric primitive # as this allows interactive update u_min: FloatProperty(name="U Min", description="", default=0.0) v_min: FloatProperty(name="V Min", description="", default=0.0) u_max: FloatProperty(name="U Max", description="", default=6.28) v_max: FloatProperty(name="V Max", description="", default=12.57) x_eq: StringProperty(maxlen=1024, default="cos(v)*(1+cos(u))*sin(v/8)") y_eq: StringProperty(maxlen=1024, default="sin(u)*sin(v/8)+cos(v/8)*1.5") z_eq: StringProperty(maxlen=1024, default="sin(v)*(1+cos(u))*sin(v/8)") def execute(self, context): props = self.properties u_min = props.u_min v_min = props.v_min u_max = props.u_max v_max = props.v_max x_eq = props.x_eq y_eq = props.y_eq z_eq = props.z_eq try: pov_parametric_define(context, self, None) self.report( {"INFO"}, "This native POV-Ray primitive " "won't have any vertex to show in edit mode", ) except AttributeError: self.report({"INFO"}, "Please enable Add Mesh: Extra Objects addon") return {"FINISHED"} class POV_OT_parametric_update(Operator): """Update the representation of POV parametric surfaces. Delete its previous proxy geometry and rerun pov_parametric_define() function with the new parameters""" bl_idname = "pov.parametric_update" bl_label = "Update" bl_description = "Update parametric object" bl_options = {'REGISTER', 'UNDO'} COMPAT_ENGINES = {"POVRAY_RENDER"} @classmethod def poll(cls, context): engine = context.scene.render.engine ob = context.object return ob and ob.data and ob.type == "MESH" and engine in cls.COMPAT_ENGINES def execute(self, context): pov_parametric_define(context, None, context.object) return {"FINISHED"} # ----------------------------------------------------------------------------- class POV_OT_polygon_to_circle_add(Operator): """Add the proxy mesh for POV Polygon to circle lofting macro""" bl_idname = "pov.addpolygontocircle" bl_label = "Polygon To Circle Blending" bl_description = "Add Polygon To Circle Blending Surface" bl_options = {'REGISTER', 'UNDO'} COMPAT_ENGINES = {"POVRAY_RENDER"} # Keep in sync within model_properties.py section PolygonToCircle properties # as this allows interactive update polytocircle_resolution: IntProperty( name="Resolution", description="", default=3, min=0, max=256 ) polytocircle_ngon: IntProperty(name="NGon", description="", min=3, max=64, default=5) polytocircle_ngonR: FloatProperty(name="NGon Radius", description="", default=0.3) polytocircle_circleR: FloatProperty(name="Circle Radius", description="", default=1.0) def execute(self, context): props = self.properties ngon = props.polytocircle_ngon ngonR = props.polytocircle_ngonR circleR = props.polytocircle_circleR resolution = props.polytocircle_resolution # layers = 20*[False] # layers[0] = True bpy.ops.mesh.primitive_circle_add( vertices=ngon, radius=ngonR, fill_type="NGON", enter_editmode=True ) bpy.ops.transform.translate(value=(0, 0, 1)) bpy.ops.mesh.subdivide(number_cuts=resolution) numCircleVerts = ngon + (ngon * resolution) bpy.ops.mesh.select_all(action="DESELECT") bpy.ops.mesh.primitive_circle_add( vertices=numCircleVerts, radius=circleR, fill_type="NGON", enter_editmode=True ) bpy.ops.transform.translate(value=(0, 0, -1)) bpy.ops.mesh.select_all(action="SELECT") bpy.ops.mesh.bridge_edge_loops() if ngon < 5: bpy.ops.mesh.select_all(action="DESELECT") bpy.ops.mesh.primitive_circle_add( vertices=ngon, radius=ngonR, fill_type="TRIFAN", enter_editmode=True ) bpy.ops.transform.translate(value=(0, 0, 1)) bpy.ops.mesh.select_all(action="SELECT") bpy.ops.mesh.remove_doubles() bpy.ops.object.mode_set(mode="OBJECT") ob = context.object ob.name = "Polygon_To_Circle" ob.pov.ngon = ngon ob.pov.ngonR = ngonR ob.pov.circleR = circleR bpy.ops.object.mode_set(mode="EDIT") bpy.ops.mesh.hide(unselected=False) bpy.ops.object.mode_set(mode="OBJECT") #ob.data.auto_smooth_angle = 0.1 #bpy.ops.object.shade_smooth() ob.pov.object_as = "POLYCIRCLE" ob.update_tag() # as prop set via python not updated in depsgraph return {"FINISHED"} classes = ( POV_OT_lathe_add, POV_OT_superellipsoid_add, POV_OT_superellipsoid_update, POV_OT_supertorus_add, POV_OT_supertorus_update, POV_OT_loft_add, POV_OT_isosurface_add, POV_OT_isosurface_update, POV_OT_isosurface_box_add, POV_OT_isosurface_sphere_add, POV_OT_sphere_sweep_add, POV_OT_blobsphere_add, POV_OT_blobcapsule_add, POV_OT_blobplane_add, POV_OT_blobellipsoid_add, POV_OT_blobcube_add, POV_OT_height_field_add, POV_OT_parametric_add, POV_OT_parametric_update, POV_OT_polygon_to_circle_add, ) def register(): for cls in classes: register_class(cls) def unregister(): for cls in reversed(classes): unregister_class(cls)