diff options
| author | Maurice Raybaud <mauriceraybaud@hotmail.fr> | 2019-12-20 21:17:40 +0300 |
|---|---|---|
| committer | Maurice Raybaud <mauriceraybaud@hotmail.fr> | 2019-12-22 02:27:59 +0300 |
| commit | 0046ef0652382b948d34fea8a33a94e92e6350db (patch) | |
| tree | 34a661fdbcc9ee1ffc4ab776b4e6f2d5c4ef2700 /render_povray/primitives.py | |
| parent | b3600e4e5bcee6e2c25c7442c49f612a7182111f (diff) | |
POV: Improve Line endings and general formatting
used black on some files to dust up old formatting
Diffstat (limited to 'render_povray/primitives.py')
| -rw-r--r-- | render_povray/primitives.py | 1638 |
1 files changed, 974 insertions, 664 deletions
diff --git a/render_povray/primitives.py b/render_povray/primitives.py index 4d109958..a9d68d44 100644 --- a/render_povray/primitives.py +++ b/render_povray/primitives.py @@ -18,7 +18,7 @@ # <pep8 compliant> -############ To get POV-Ray specific objects In and Out of Blender ########### +""" Get POV-Ray specific objects In and Out of Blender """ import bpy import os.path @@ -29,22 +29,20 @@ from math import atan, pi, degrees, sqrt, cos, sin from bpy.props import ( - StringProperty, - BoolProperty, - IntProperty, - FloatProperty, - FloatVectorProperty, - EnumProperty, - PointerProperty, - CollectionProperty, - ) - -from mathutils import ( - Vector, - Matrix, + StringProperty, + BoolProperty, + IntProperty, + FloatProperty, + FloatVectorProperty, + EnumProperty, + PointerProperty, + CollectionProperty, ) -#import collections +from mathutils import Vector, Matrix + +# import collections + def pov_define_mesh(mesh, verts, edges, faces, name, hide_geometry=True): """Generate proxy mesh.""" @@ -52,7 +50,9 @@ def pov_define_mesh(mesh, verts, edges, faces, name, hide_geometry=True): mesh = bpy.data.meshes.new(name) mesh.from_pydata(verts, edges, faces) mesh.update() - mesh.validate(verbose = False) # Set it to True to see debug messages (helps ensure you generate valid geometry). + mesh.validate( + verbose=False + ) # Set it to True to see debug messages (helps ensure you generate valid geometry). if hide_geometry: mesh.vertices.foreach_set("hide", [True] * len(mesh.vertices)) mesh.edges.foreach_set("hide", [True] * len(mesh.edges)) @@ -62,26 +62,26 @@ def pov_define_mesh(mesh, verts, edges, faces, name, hide_geometry=True): class POVRAY_OT_lathe_add(bpy.types.Operator): """Add the representation of POV lathe using a screw modifier.""" + bl_idname = "pov.addlathe" bl_label = "Lathe" - bl_options = {'REGISTER','UNDO'} + bl_options = {'REGISTER', 'UNDO'} bl_description = "adds lathe" - def execute(self, context): - #ayers=[False]*20 - #layers[0]=True + # ayers=[False]*20 + # layers[0]=True bpy.ops.curve.primitive_bezier_curve_add( location=context.scene.cursor.location, rotation=(0, 0, 0), - #layers=layers, + # 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' + ob.pov.object_as = 'LATHE' self.report({'INFO'}, "This native POV-Ray primitive") ob.pov.curveshape = "lathe" bpy.ops.object.modifier_add(type='SCREW') @@ -91,7 +91,6 @@ class POVRAY_OT_lathe_add(bpy.types.Operator): return {'FINISHED'} - def pov_superellipsoid_define(context, op, ob): """Create the proxy mesh of a POV superellipsoid using the pov_superellipsoid_define() function.""" @@ -103,11 +102,11 @@ def pov_superellipsoid_define(context, op, ob): n1 = op.se_n1 n2 = op.se_n2 edit = op.se_edit - se_param1 = n2 # op.se_param1 - se_param2 = n1 # op.se_param2 + se_param1 = n2 # op.se_param1 + se_param2 = n1 # op.se_param2 else: - assert(ob) + assert ob mesh = ob.data u = ob.pov.se_u @@ -119,83 +118,85 @@ def pov_superellipsoid_define(context, op, ob): se_param2 = ob.pov.se_param2 verts = [] - r=1 + r = 1 - stepSegment=360/v*pi/180 - stepRing=pi/u - angSegment=0 - angRing=-pi/2 + stepSegment = 360 / v * pi / 180 + stepRing = pi / u + angSegment = 0 + angRing = -pi / 2 - step=0 - for ring in range(0,u-1): + step = 0 + for ring in range(0, u - 1): angRing += stepRing - for segment in range(0,v): + for segment in range(0, v): step += 1 angSegment += stepSegment - x = r*(abs(cos(angRing))**n1)*(abs(cos(angSegment))**n2) - if (cos(angRing) < 0 and cos(angSegment) > 0) or \ - (cos(angRing) > 0 and cos(angSegment) < 0): + x = r * (abs(cos(angRing)) ** n1) * (abs(cos(angSegment)) ** n2) + if (cos(angRing) < 0 and cos(angSegment) > 0) or ( + cos(angRing) > 0 and cos(angSegment) < 0 + ): x = -x - y = r*(abs(cos(angRing))**n1)*(abs(sin(angSegment))**n2) - if (cos(angRing) < 0 and sin(angSegment) > 0) or \ - (cos(angRing) > 0 and sin(angSegment) < 0): + y = r * (abs(cos(angRing)) ** n1) * (abs(sin(angSegment)) ** n2) + if (cos(angRing) < 0 and sin(angSegment) > 0) or ( + cos(angRing) > 0 and sin(angSegment) < 0 + ): y = -y - z = r*(abs(sin(angRing))**n1) + 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)) + x = round(x, 4) + y = round(y, 4) + z = round(z, 4) + verts.append((x, y, z)) if edit == 'TRIANGLES': - verts.append((0,0,1)) - verts.append((0,0,-1)) + verts.append((0, 0, 1)) + verts.append((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) + 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) + 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) + 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) + 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) + if i == v - 1: + face = (indexUp, i + indexStartDown, indexStartDown) faces.append(face) if edit == 'NGONS': - face=[] - for i in range(0,v): + face = [] + for i in range(0, v): face.append(i) faces.append(face) - face=[] - indexUp=len(verts)-1 - for i in range(0,v): - face.append(indexUp-i) + face = [] + indexUp = len(verts) - 1 + for i in range(0, v): + face.append(indexUp - i) faces.append(face) mesh = pov_define_mesh(mesh, verts, [], faces, "SuperEllipsoid") if not ob: ob = object_utils.object_data_add(context, mesh, operator=None) - #engine = context.scene.render.engine what for? + # engine = context.scene.render.engine what for? ob = context.object - ob.name = ob.data.name = "PovSuperellipsoid" + ob.name = ob.data.name = "PovSuperellipsoid" ob.pov.object_as = 'SUPERELLIPSOID' ob.pov.se_param1 = n2 ob.pov.se_param2 = n1 @@ -210,8 +211,10 @@ def pov_superellipsoid_define(context, op, ob): bpy.ops.mesh.hide(unselected=False) bpy.ops.object.mode_set(mode="OBJECT") + class POVRAY_OT_superellipsoid_add(bpy.types.Operator): """Add the representation of POV superellipsoid using the pov_superellipsoid_define() function.""" + bl_idname = "pov.addsuperellipsoid" bl_label = "Add SuperEllipsoid" bl_description = "Create a SuperEllipsoid" @@ -221,46 +224,68 @@ class POVRAY_OT_superellipsoid_add(bpy.types.Operator): # XXX Keep it in sync with __init__'s RenderPovSettingsConePrimitive # If someone knows how to define operators' props from a func, I'd be delighted to learn it! se_param1: FloatProperty( - name="Parameter 1", - description="", - min=0.00, max=10.0, default=0.04) + 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') + 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) + return engine in cls.COMPAT_ENGINES - def execute(self,context): + 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") + self.report( + {'INFO'}, + "This native POV-Ray primitive won't have any vertex to show in edit mode", + ) return {'FINISHED'} + class POVRAY_OT_superellipsoid_update(bpy.types.Operator): """Update the superellipsoid. @@ -277,7 +302,12 @@ class POVRAY_OT_superellipsoid_update(bpy.types.Operator): 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) + 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") @@ -290,6 +320,7 @@ class POVRAY_OT_superellipsoid_update(bpy.types.Operator): return {'FINISHED'} + def createFaces(vertIdx1, vertIdx2, closed=False, flipped=False): faces = [] if not vertIdx1 or not vertIdx2: @@ -297,18 +328,15 @@ def createFaces(vertIdx1, vertIdx2, closed=False, flipped=False): if len(vertIdx1) < 2 and len(vertIdx2) < 2: return None fan = False - if (len(vertIdx1) != len(vertIdx2)): - if (len(vertIdx1) == 1 and len(vertIdx2) > 1): + if len(vertIdx1) != len(vertIdx2): + if len(vertIdx1) == 1 and len(vertIdx2) > 1: fan = True else: return None total = len(vertIdx2) if closed: if flipped: - face = [ - vertIdx1[0], - vertIdx2[0], - vertIdx2[total - 1]] + face = [vertIdx1[0], vertIdx2[0], vertIdx2[total - 1]] if not fan: face.append(vertIdx1[total - 1]) faces.append(face) @@ -324,95 +352,108 @@ def createFaces(vertIdx1, vertIdx2, closed=False, flipped=False): if fan: face = [vertIdx2[num], vertIdx1[0], vertIdx2[num + 1]] else: - face = [vertIdx2[num], vertIdx1[num], - vertIdx1[num + 1], vertIdx2[num + 1]] + face = [ + vertIdx2[num], + vertIdx1[num], + vertIdx1[num + 1], + vertIdx2[num + 1], + ] faces.append(face) else: if fan: face = [vertIdx1[0], vertIdx2[num], vertIdx2[num + 1]] else: - face = [vertIdx1[num], vertIdx2[num], - vertIdx2[num + 1], vertIdx1[num + 1]] + face = [ + vertIdx1[num], + vertIdx2[num], + vertIdx2[num + 1], + vertIdx1[num + 1], + ] faces.append(face) return faces -def power(a,b): + +def power(a, b): if a < 0: - return -((-a)**b) - return a**b + return -((-a) ** b) + return a ** b -def supertoroid(R,r,u,v,n1,n2): - a = 2*pi/u - b = 2*pi/v + +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) + 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))? + 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 = createFaces(range((i-1)*v,i*v),range(i*v,(i+1)*v),closed = True) + f = createFaces( + range((i - 1) * v, i * v), + range(i * v, (i + 1) * v), + closed=True, + ) faces.extend(f) - f = createFaces(range((u-1)*v,u*v),range(v),closed=True) + f = createFaces(range((u - 1) * v, u * v), range(v), closed=True) faces.extend(f) return verts, faces + def pov_supertorus_define(context, op, ob): - 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 + 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 = pov_define_mesh(mesh, verts, [], faces, "PovSuperTorus", True) + if not ob: + ob = object_utils.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 - 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 = pov_define_mesh(mesh, verts, [], faces, "PovSuperTorus", True) - if not ob: - ob = object_utils.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 class POVRAY_OT_supertorus_add(bpy.types.Operator): """Add the representation of POV supertorus using the pov_supertorus_define() function.""" @@ -423,48 +464,78 @@ class POVRAY_OT_supertorus_add(bpy.types.Operator): 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'}) + 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) + 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") + self.report( + {'INFO'}, + "This native POV-Ray primitive won't have any vertex to show in edit mode", + ) return {'FINISHED'} + class POVRAY_OT_supertorus_update(bpy.types.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" @@ -475,7 +546,12 @@ class POVRAY_OT_supertorus_update(bpy.types.Operator): 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) + 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") @@ -487,6 +563,8 @@ class POVRAY_OT_supertorus_update(bpy.types.Operator): pov_supertorus_define(context, None, context.object) return {'FINISHED'} + + ######################################################################################################### class POVRAY_OT_loft_add(bpy.types.Operator): """Create the representation of POV loft using Blender curves.""" @@ -497,103 +575,115 @@ class POVRAY_OT_loft_add(bpy.types.Operator): 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): + 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 loftData = bpy.data.curves.new('Loft', type='CURVE') loftData.dimensions = '3D' loftData.resolution_u = 2 # loftData.show_normal_face = False # deprecated in 2.8 - n=props.loft_n + 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 + distB = r / bottom r0 = 0.00001 - z = -h/2 + z = -h / 2 print("New") - for i in range(bottom+1): + 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 + x = r0 * cos(angle) + y = r0 * sin(angle) + coords.append((x, y, z)) + angle += pi * 2 / n + r0 += distB nurbs = loftData.splines.new('NURBS') - nurbs.points.add(len(coords)-1) + nurbs.points.add(len(coords) - 1) for i, coord in enumerate(coords): - x,y,z = coord + x, y, z = coord nurbs.points[i].co = (x, y, z, 1) nurbs.use_cyclic_u = True for i in range(side): - z+=h/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 + x = r * cos(angle) + y = r * sin(angle) + coords.append((x, y, z)) + angle += pi * 2 / n nurbs = loftData.splines.new('NURBS') - nurbs.points.add(len(coords)-1) + nurbs.points.add(len(coords) - 1) for i, coord in enumerate(coords): - x,y,z = coord + x, y, z = coord nurbs.points[i].co = (x, y, z, 1) nurbs.use_cyclic_u = True - r-=thick + 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 + x = r * cos(angle) + y = r * sin(angle) + coords.append((x, y, z)) + angle += pi * 2 / n nurbs = loftData.splines.new('NURBS') - nurbs.points.add(len(coords)-1) + nurbs.points.add(len(coords) - 1) for i, coord in enumerate(coords): - x,y,z = coord + x, y, z = coord nurbs.points[i].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): + 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 + x = r * cos(angle) + y = r * sin(angle) + coords.append((x, y, z)) + angle += pi * 2 / n + r -= distB nurbs = loftData.splines.new('NURBS') - nurbs.points.add(len(coords)-1) + nurbs.points.add(len(coords) - 1) for i, coord in enumerate(coords): - x,y,z = coord + x, y, z = coord nurbs.points[i].co = (x, y, z, 1) nurbs.use_cyclic_u = True ob = bpy.data.objects.new('Loft_shape', loftData) @@ -604,6 +694,7 @@ class POVRAY_OT_loft_add(bpy.types.Operator): ob.pov.curveshape = "loft" return {'FINISHED'} + class POVRAY_OT_plane_add(bpy.types.Operator): """Add the representation of POV infinite plane using just a very big Blender Plane. @@ -615,21 +706,25 @@ class POVRAY_OT_plane_add(bpy.types.Operator): bl_description = "Add Plane" bl_options = {'REGISTER', 'UNDO'} - def execute(self,context): - #layers = 20*[False] - #layers[0] = True - bpy.ops.mesh.primitive_plane_add(size = 100000) + def execute(self, context): + # layers = 20*[False] + # layers[0] = True + bpy.ops.mesh.primitive_plane_add(size=100000) ob = context.object ob.name = ob.data.name = 'PovInfinitePlane' 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") + 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 = "PLANE" return {'FINISHED'} + class POVRAY_OT_box_add(bpy.types.Operator): """Add the representation of POV box using a simple Blender mesh cube. @@ -641,15 +736,18 @@ class POVRAY_OT_box_add(bpy.types.Operator): bl_description = "Add Box" bl_options = {'REGISTER', 'UNDO'} - def execute(self,context): + def execute(self, context): # layers = 20*[False] # layers[0] = True bpy.ops.mesh.primitive_cube_add() ob = context.object ob.name = ob.data.name = 'PovBox' 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") + 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 = "BOX" @@ -662,11 +760,13 @@ def pov_cylinder_define(context, op, ob, radius, loc, loc_cap): loc = bpy.context.scene.cursor.location loc_cap[0] = loc[0] loc_cap[1] = loc[1] - loc_cap[2] = (loc[2]+2) + loc_cap[2] = loc[2] + 2 vec = Vector(loc_cap) - Vector(loc) depth = vec.length rot = Vector((0, 0, 1)).rotation_difference(vec) # Rotation from Z axis. - trans = rot @ Vector((0, 0, depth / 2)) # Such that origin is at center of the base of the cylinder. + trans = rot @ Vector( + (0, 0, depth / 2) + ) # Such that origin is at center of the base of the cylinder. roteuler = rot.to_euler() if not ob: bpy.ops.object.add(type='MESH', location=loc) @@ -682,7 +782,13 @@ def pov_cylinder_define(context, op, ob, radius, loc, loc_cap): bpy.ops.mesh.reveal() bpy.ops.mesh.select_all(action='SELECT') bpy.ops.mesh.delete(type='VERT') - bpy.ops.mesh.primitive_cylinder_add(radius=radius, depth=depth, location=loc, rotation=roteuler, end_fill_type='NGON') #'NOTHING' + bpy.ops.mesh.primitive_cylinder_add( + radius=radius, + depth=depth, + location=loc, + rotation=roteuler, + end_fill_type='NGON', + ) #'NOTHING' bpy.ops.transform.translate(value=trans) bpy.ops.mesh.hide(unselected=False) @@ -694,6 +800,7 @@ class POVRAY_OT_cylinder_add(bpy.types.Operator): """Add the representation of POV cylinder using pov_cylinder_define() function. Use imported_cyl_loc when this operator is run by POV importer.""" + bl_idname = "pov.addcylinder" bl_label = "Cylinder" bl_description = "Add Cylinder" @@ -703,21 +810,19 @@ class POVRAY_OT_cylinder_add(bpy.types.Operator): R: FloatProperty(name="Cylinder radius", min=0.00, max=10.0, default=1.0) imported_cyl_loc: FloatVectorProperty( - name="Imported Pov base location", - precision=6, - default=(0.0, 0.0, 0.0)) + name="Imported Pov base location", precision=6, default=(0.0, 0.0, 0.0) + ) imported_cyl_loc_cap: FloatVectorProperty( - name="Imported Pov cap location", - precision=6, - default=(0.0, 0.0, 2.0)) + name="Imported Pov cap location", precision=6, default=(0.0, 0.0, 2.0) + ) - def execute(self,context): + def execute(self, context): props = self.properties R = props.R ob = context.object - #layers = 20*[False] - #layers[0] = True + # layers = 20*[False] + # layers[0] = True if ob: if ob.pov.imported_cyl_loc: LOC = ob.pov.imported_cyl_loc @@ -730,8 +835,11 @@ class POVRAY_OT_cylinder_add(bpy.types.Operator): else: LOC = props.imported_cyl_loc LOC_CAP = props.imported_cyl_loc_cap - self.report({'INFO'}, "This native POV-Ray primitive " - "won't have any vertex to show in edit mode") + self.report( + {'INFO'}, + "This native POV-Ray primitive " + "won't have any vertex to show in edit mode", + ) pov_cylinder_define(context, self, None, self.R, LOC, LOC_CAP) @@ -754,7 +862,13 @@ class POVRAY_OT_cylinder_update(bpy.types.Operator): def poll(cls, context): engine = context.scene.render.engine ob = context.object - return (ob and ob.data and ob.type == 'MESH' and ob.pov.object_as == "CYLINDER" and engine in cls.COMPAT_ENGINES) + return ( + ob + and ob.data + and ob.type == 'MESH' + and ob.pov.object_as == "CYLINDER" + and engine in cls.COMPAT_ENGINES + ) def execute(self, context): ob = context.object @@ -778,39 +892,46 @@ def pov_sphere_define(context, op, ob, loc): R = op.R loc = bpy.context.scene.cursor.location else: - assert(ob) + assert ob R = ob.pov.sphere_radius - #keep object rotation and location for the add object operator + # keep object rotation and location for the add object operator obrot = ob.rotation_euler - #obloc = ob.location + # obloc = ob.location obscale = ob.scale 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_ico_sphere_add(subdivisions=4, radius=ob.pov.sphere_radius, location=loc, rotation=obrot) - #bpy.ops.transform.rotate(axis=obrot,orient_type='GLOBAL') + bpy.ops.mesh.primitive_ico_sphere_add( + subdivisions=4, + radius=ob.pov.sphere_radius, + location=loc, + rotation=obrot, + ) + # 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.transform.rotate(axis=obrot, proportional_size=1) bpy.ops.mesh.hide(unselected=False) bpy.ops.object.mode_set(mode="OBJECT") bpy.ops.object.shade_smooth() - #bpy.ops.transform.rotate(axis=obrot,orient_type='GLOBAL') + # bpy.ops.transform.rotate(axis=obrot,orient_type='GLOBAL') if not ob: - bpy.ops.mesh.primitive_ico_sphere_add(subdivisions=4, radius=R, location=loc) + bpy.ops.mesh.primitive_ico_sphere_add( + subdivisions=4, radius=R, location=loc + ) ob = context.object - ob.name = ob.data.name = "PovSphere" + ob.name = ob.data.name = "PovSphere" ob.pov.object_as = "SPHERE" ob.pov.sphere_radius = R bpy.ops.object.mode_set(mode="EDIT") bpy.ops.mesh.hide(unselected=False) bpy.ops.object.mode_set(mode="OBJECT") + class POVRAY_OT_sphere_add(bpy.types.Operator): """Add the representation of POV sphere using pov_sphere_define() function. @@ -822,20 +943,17 @@ class POVRAY_OT_sphere_add(bpy.types.Operator): bl_options = {'REGISTER', 'UNDO'} # XXX Keep it in sync with __init__'s torus Primitive - R: FloatProperty(name="Sphere radius",min=0.00, max=10.0, default=0.5) + R: FloatProperty(name="Sphere radius", min=0.00, max=10.0, default=0.5) imported_loc: FloatVectorProperty( - name="Imported Pov location", - precision=6, - default=(0.0, 0.0, 0.0)) + name="Imported Pov location", precision=6, default=(0.0, 0.0, 0.0) + ) - def execute(self,context): + def execute(self, context): props = self.properties R = props.R ob = context.object - - if ob: if ob.pov.imported_loc: LOC = ob.pov.imported_loc @@ -845,27 +963,32 @@ class POVRAY_OT_sphere_add(bpy.types.Operator): else: LOC = props.imported_loc - self.report({'INFO'}, "This native POV-Ray primitive " - "won't have any vertex to show in edit mode") + self.report( + {'INFO'}, + "This native POV-Ray primitive " + "won't have any vertex to show in edit mode", + ) pov_sphere_define(context, self, None, LOC) return {'FINISHED'} # def execute(self,context): - ## layers = 20*[False] - ## layers[0] = True - - # bpy.ops.mesh.primitive_ico_sphere_add(subdivisions=4, radius=ob.pov.sphere_radius) - # 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 = "SPHERE" - # ob.name = ob.data.name = 'PovSphere' - # return {'FINISHED'} + ## layers = 20*[False] + ## layers[0] = True + + # bpy.ops.mesh.primitive_ico_sphere_add(subdivisions=4, radius=ob.pov.sphere_radius) + # 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 = "SPHERE" + # ob.name = ob.data.name = 'PovSphere' + # return {'FINISHED'} + + class POVRAY_OT_sphere_update(bpy.types.Operator): """Update the POV sphere. @@ -882,11 +1005,18 @@ class POVRAY_OT_sphere_update(bpy.types.Operator): 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) + return ( + ob + and ob.data + and ob.type == 'MESH' + and engine in cls.COMPAT_ENGINES + ) def execute(self, context): - pov_sphere_define(context, None, context.object,context.object.location) + pov_sphere_define( + context, None, context.object, context.object.location + ) return {'FINISHED'} @@ -905,7 +1035,7 @@ def pov_cone_define(context, op, ob): seg = op.seg height = op.height else: - assert(ob) + assert ob mesh = ob.data base = ob.pov.cone_base_radius cap = ob.pov.cone_cap_radius @@ -966,27 +1096,46 @@ class POVRAY_OT_cone_add(bpy.types.Operator): # XXX Keep it in sync with __init__.py's RenderPovSettingsConePrimitive # If someone knows how to define operators' props from a func, I'd be delighted to learn it! base: FloatProperty( - name = "Base radius", description = "The first radius of the cone", - default = 1.0, min = 0.01, max = 100.0) + name="Base radius", + description="The first radius of the cone", + default=1.0, + min=0.01, + max=100.0, + ) cap: FloatProperty( - name = "Cap radius", description = "The second radius of the cone", - default = 0.3, min = 0.0, max = 100.0) + name="Cap radius", + description="The second radius of the cone", + default=0.3, + min=0.0, + max=100.0, + ) seg: IntProperty( - name = "Segments", description = "Radial segmentation of the proxy mesh", - default = 16, min = 3, max = 265) + name="Segments", + description="Radial segmentation of the proxy mesh", + default=16, + min=3, + max=265, + ) height: FloatProperty( - name = "Height", description = "Height of the cone", - default = 2.0, min = 0.01, max = 100.0) + name="Height", + description="Height of the cone", + default=2.0, + min=0.01, + max=100.0, + ) @classmethod def poll(cls, context): engine = context.scene.render.engine - return (engine in cls.COMPAT_ENGINES) + return engine in cls.COMPAT_ENGINES def execute(self, context): pov_cone_define(context, self, None) - self.report({'INFO'}, "This native POV-Ray primitive won't have any vertex to show in edit mode") + self.report( + {'INFO'}, + "This native POV-Ray primitive won't have any vertex to show in edit mode", + ) return {'FINISHED'} @@ -1006,7 +1155,12 @@ class POVRAY_OT_cone_update(bpy.types.Operator): 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) + 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") @@ -1019,8 +1173,10 @@ class POVRAY_OT_cone_update(bpy.types.Operator): return {'FINISHED'} + ########################################ISOSURFACES################################## + class POVRAY_OT_isosurface_box_add(bpy.types.Operator): """Add the representation of POV isosurface box using also just a Blender mesh cube. @@ -1032,15 +1188,17 @@ class POVRAY_OT_isosurface_box_add(bpy.types.Operator): bl_description = "Add Isosurface contained by Box" bl_options = {'REGISTER', 'UNDO'} - - def execute(self,context): - #layers = 20*[False] - #layers[0] = True + 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") + 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" @@ -1048,6 +1206,7 @@ class POVRAY_OT_isosurface_box_add(bpy.types.Operator): ob.name = 'PovIsosurfaceBox' return {'FINISHED'} + class POVRAY_OT_isosurface_sphere_add(bpy.types.Operator): """Add the representation of POV isosurface sphere by a Blender mesh icosphere. @@ -1059,15 +1218,17 @@ class POVRAY_OT_isosurface_sphere_add(bpy.types.Operator): bl_description = "Add Isosurface contained by Sphere" bl_options = {'REGISTER', 'UNDO'} - - def execute(self,context): - #layers = 20*[False] - #layers[0] = True + 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") + 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() @@ -1076,6 +1237,7 @@ class POVRAY_OT_isosurface_sphere_add(bpy.types.Operator): ob.name = 'PovIsosurfaceSphere' return {'FINISHED'} + class POVRAY_OT_sphere_sweep_add(bpy.types.Operator): """Add the representation of POV sphere_sweep using a Blender NURBS curve. @@ -1087,9 +1249,9 @@ class POVRAY_OT_sphere_sweep_add(bpy.types.Operator): bl_description = "Create Sphere Sweep along curve" bl_options = {'REGISTER', 'UNDO'} - def execute(self,context): - #layers = 20*[False] - #layers[0] = True + 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" @@ -1097,10 +1259,11 @@ class POVRAY_OT_sphere_sweep_add(bpy.types.Operator): ob.data.bevel_depth = 0.02 ob.data.bevel_resolution = 4 ob.data.fill_mode = 'FULL' - #ob.data.splines[0].order_u = 4 + # ob.data.splines[0].order_u = 4 return {'FINISHED'} + class POVRAY_OT_blob_add(bpy.types.Operator): """Add the representation of POV blob using a Blender meta ball. @@ -1112,10 +1275,10 @@ class POVRAY_OT_blob_add(bpy.types.Operator): bl_description = "Add Blob Sphere" bl_options = {'REGISTER', 'UNDO'} - def execute(self,context): - #layers = 20*[False] - #layers[0] = True - bpy.ops.object.metaball_add(type = 'BALL') + 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'} @@ -1136,34 +1299,33 @@ class POVRAY_OT_rainbow_add(bpy.types.Operator): bl_description = "Add Rainbow" bl_options = {'REGISTER', 'UNDO'} - def execute(self,context): + def execute(self, context): cam = context.scene.camera bpy.ops.object.light_add(type='SPOT', radius=1) ob = context.object ob.data.show_cone = False ob.data.spot_blend = 0.5 # ob.data.shadow_buffer_clip_end = 0 # deprecated in 2.8 - ob.data.shadow_buffer_clip_start = 4*cam.location.length + ob.data.shadow_buffer_clip_start = 4 * cam.location.length ob.data.distance = cam.location.length ob.data.energy = 0 ob.name = ob.data.name = "PovRainbow" ob.pov.object_as = "RAINBOW" - #obj = context.object + # obj = context.object bpy.ops.object.constraint_add(type='DAMPED_TRACK') - - ob.constraints["Damped Track"].target = cam ob.constraints["Damped Track"].track_axis = 'TRACK_NEGATIVE_Z' ob.location = -cam.location - #refocus on the actual rainbow + # refocus on the actual rainbow bpy.context.view_layer.objects.active = ob ob.select_set(True) return {'FINISHED'} + class POVRAY_OT_height_field_add(bpy.types.Operator, ImportHelper): """Add the representation of POV height_field using a displaced grid. @@ -1179,68 +1341,67 @@ class POVRAY_OT_height_field_add(bpy.types.Operator, ImportHelper): # 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) + # 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) + name="Gamma", description="Gamma", min=0.0001, max=20.0, default=1.0 + ) hf_premultiplied: BoolProperty( - name="Premultiplied", - description="Premultiplied", - default=True) + name="Premultiplied", description="Premultiplied", default=True + ) - hf_smooth: BoolProperty( - name="Smooth", - description="Smooth", - default=False) + 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) + 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): + 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 = 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) + 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 + # 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) + 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.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 a displace modifier as 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 - + # 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") @@ -1264,13 +1425,13 @@ def pov_torus_define(context, op, ob): mar = op.mar mir = op.mir else: - assert(ob) + assert ob mas = ob.pov.torus_major_segments mis = ob.pov.torus_minor_segments mar = ob.pov.torus_major_radius mir = ob.pov.torus_minor_radius - #keep object rotation and location for the add object operator + # keep object rotation and location for the add object operator obrot = ob.rotation_euler obloc = ob.location @@ -1278,17 +1439,27 @@ def pov_torus_define(context, op, ob): bpy.ops.mesh.reveal() bpy.ops.mesh.select_all(action='SELECT') bpy.ops.mesh.delete(type='VERT') - bpy.ops.mesh.primitive_torus_add(rotation = obrot, location = obloc, major_segments=mas, minor_segments=mis,major_radius=mar, minor_radius=mir) - + bpy.ops.mesh.primitive_torus_add( + rotation=obrot, + location=obloc, + major_segments=mas, + minor_segments=mis, + major_radius=mar, + minor_radius=mir, + ) bpy.ops.mesh.hide(unselected=False) bpy.ops.object.mode_set(mode="OBJECT") - if not ob: - bpy.ops.mesh.primitive_torus_add(major_segments=mas, minor_segments=mis,major_radius=mar, minor_radius=mir) + bpy.ops.mesh.primitive_torus_add( + major_segments=mas, + minor_segments=mis, + major_radius=mar, + minor_radius=mir, + ) ob = context.object - ob.name = ob.data.name = "PovTorus" + ob.name = ob.data.name = "PovTorus" ob.pov.object_as = "TORUS" ob.pov.torus_major_segments = mas ob.pov.torus_minor_segments = mis @@ -1298,6 +1469,7 @@ def pov_torus_define(context, op, ob): bpy.ops.mesh.hide(unselected=False) bpy.ops.object.mode_set(mode="OBJECT") + class POVRAY_OT_torus_add(bpy.types.Operator): """Add the representation of POV torus using using pov_torus_define() function.""" @@ -1307,27 +1479,27 @@ class POVRAY_OT_torus_add(bpy.types.Operator): bl_options = {'REGISTER', 'UNDO'} # XXX Keep it in sync with __init__'s torus Primitive - mas: IntProperty(name = "Major Segments", - description = "", - default = 48, min = 3, max = 720) - mis: IntProperty(name = "Minor Segments", - description = "", - default = 12, min = 3, max = 720) - mar: FloatProperty(name = "Major Radius", - description = "", - default = 1.0) - mir: FloatProperty(name = "Minor Radius", - description = "", - default = 0.25) - def execute(self,context): + mas: IntProperty( + name="Major Segments", description="", default=48, min=3, max=720 + ) + mis: IntProperty( + name="Minor Segments", description="", default=12, min=3, max=720 + ) + mar: FloatProperty(name="Major Radius", description="", default=1.0) + mir: FloatProperty(name="Minor Radius", description="", default=0.25) + + def execute(self, context): props = self.properties mar = props.mar mir = props.mir mas = props.mas mis = props.mis pov_torus_define(context, self, None) - self.report({'INFO'}, "This native POV-Ray primitive " - "won't have any vertex to show in edit mode") + self.report( + {'INFO'}, + "This native POV-Ray primitive " + "won't have any vertex to show in edit mode", + ) return {'FINISHED'} @@ -1347,7 +1519,12 @@ class POVRAY_OT_torus_update(bpy.types.Operator): 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) + return ( + ob + and ob.data + and ob.type == 'MESH' + and engine in cls.COMPAT_ENGINES + ) def execute(self, context): @@ -1355,6 +1532,7 @@ class POVRAY_OT_torus_update(bpy.types.Operator): return {'FINISHED'} + ################################################################################### @@ -1366,34 +1544,33 @@ class POVRAY_OT_prism_add(bpy.types.Operator): bl_description = "Create Prism" bl_options = {'REGISTER', 'UNDO'} - prism_n: IntProperty(name = "Sides", - description = "Number of sides", - default = 5, min = 3, max = 720) - prism_r: FloatProperty(name = "Radius", - description = "Radius", - default = 1.0) - def execute(self,context): + prism_n: IntProperty( + name="Sides", description="Number of sides", default=5, min=3, max=720 + ) + prism_r: FloatProperty(name="Radius", description="Radius", default=1.0) + + def execute(self, context): props = self.properties loftData = bpy.data.curves.new('Prism', type='CURVE') loftData.dimensions = '2D' loftData.resolution_u = 2 - #loftData.show_normal_face = False + # loftData.show_normal_face = False loftData.extrude = 2 - n=props.prism_n - r=props.prism_r + n = props.prism_n + r = props.prism_r coords = [] z = 0 angle = 0 for p in range(n): - x = r*cos(angle) - y = r*sin(angle) - coords.append((x,y,z)) - angle+=pi*2/n + x = r * cos(angle) + y = r * sin(angle) + coords.append((x, y, z)) + angle += pi * 2 / n poly = loftData.splines.new('POLY') - poly.points.add(len(coords)-1) + poly.points.add(len(coords) - 1) for i, coord in enumerate(coords): - x,y,z = coord + x, y, z = coord poly.points[i].co = (x, y, z, 1) poly.use_cyclic_u = True @@ -1406,6 +1583,7 @@ class POVRAY_OT_prism_add(bpy.types.Operator): ob.name = ob.data.name = "Prism" 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.""" @@ -1420,7 +1598,7 @@ def pov_parametric_define(context, op, ob): z_eq = op.z_eq else: - assert(ob) + assert ob u_min = ob.pov.u_min u_max = ob.pov.u_max v_min = ob.pov.v_min @@ -1429,32 +1607,46 @@ def pov_parametric_define(context, op, ob): y_eq = ob.pov.y_eq z_eq = ob.pov.z_eq - #keep object rotation and location for the updated object + # 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 + 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.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) + # extra work: + bpy.ops.transform.translate(value=(obloc - curloc), proportional_size=1) 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) + 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.name = ob.data.name = "PovParametric" ob.pov.object_as = "PARAMETRIC" ob.pov.u_min = u_min @@ -1469,6 +1661,7 @@ def pov_parametric_define(context, op, ob): bpy.ops.mesh.hide(unselected=False) bpy.ops.object.mode_set(mode="OBJECT") + class POVRAY_OT_parametric_add(bpy.types.Operator): """Add the representation of POV parametric surfaces using pov_parametric_define() function.""" @@ -1478,26 +1671,15 @@ class POVRAY_OT_parametric_add(bpy.types.Operator): bl_options = {'REGISTER', 'UNDO'} # XXX Keep it in sync with __init__'s Parametric primitive - 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): + 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 @@ -1508,10 +1690,14 @@ class POVRAY_OT_parametric_add(bpy.types.Operator): z_eq = props.z_eq pov_parametric_define(context, self, None) - self.report({'INFO'}, "This native POV-Ray primitive " - "won't have any vertex to show in edit mode") + self.report( + {'INFO'}, + "This native POV-Ray primitive " + "won't have any vertex to show in edit mode", + ) return {'FINISHED'} + class POVRAY_OT_parametric_update(bpy.types.Operator): """Update the representation of POV parametric surfaces. @@ -1528,15 +1714,23 @@ class POVRAY_OT_parametric_update(bpy.types.Operator): 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) + 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 POVRAY_OT_shape_polygon_to_circle_add(bpy.types.Operator): """Add the proxy mesh for POV Polygon to circle lofting macro""" @@ -1547,38 +1741,51 @@ class POVRAY_OT_shape_polygon_to_circle_add(bpy.types.Operator): COMPAT_ENGINES = {'POVRAY_RENDER'} # XXX Keep it in sync with __init__'s polytocircle properties - 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): + 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) + # 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) + 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.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.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() @@ -1594,10 +1801,13 @@ class POVRAY_OT_shape_polygon_to_circle_add(bpy.types.Operator): bpy.ops.object.mode_set(mode="OBJECT") return {'FINISHED'} + #############################IMPORT + class ImportPOV(bpy.types.Operator, ImportHelper): """Load Povray files""" + bl_idname = "import_scene.pov" bl_label = "POV-Ray files (.pov/.inc)" bl_options = {'PRESET', 'UNDO'} @@ -1605,32 +1815,36 @@ class ImportPOV(bpy.types.Operator, ImportHelper): # ----------- # File props. - files: CollectionProperty(type=bpy.types.OperatorFileListElement, options={'HIDDEN', 'SKIP_SAVE'}) - directory: StringProperty(maxlen=1024, subtype='FILE_PATH', options={'HIDDEN', 'SKIP_SAVE'}) - - filename_ext = {".pov",".inc"} - filter_glob: StringProperty( - default="*.pov;*.inc", - options={'HIDDEN'}, - ) - - import_at_cur: BoolProperty(name="Import at Cursor Location", - description = "Ignore Object Matrix", - default=False) + files: CollectionProperty( + type=bpy.types.OperatorFileListElement, options={'HIDDEN', 'SKIP_SAVE'} + ) + directory: StringProperty( + maxlen=1024, subtype='FILE_PATH', options={'HIDDEN', 'SKIP_SAVE'} + ) + + filename_ext = {".pov", ".inc"} + filter_glob: StringProperty(default="*.pov;*.inc", options={'HIDDEN'}) + + import_at_cur: BoolProperty( + name="Import at Cursor Location", + description="Ignore Object Matrix", + default=False, + ) def execute(self, context): from mathutils import Matrix + verts = [] faces = [] materials = [] - blendMats = [] ############## - povMats = [] ############## + blendMats = [] ############## + povMats = [] ############## colors = [] matNames = [] lenverts = None lenfaces = None suffix = -1 - name = 'Mesh2_%s'%suffix + name = 'Mesh2_%s' % suffix name_search = False verts_search = False faces_search = False @@ -1639,13 +1853,13 @@ class ImportPOV(bpy.types.Operator, ImportHelper): cylinder_search = False sphere_search = False cone_search = False - tex_search = False ################## + tex_search = False ################## cache = [] matrixes = {} writematrix = False index = None value = None - #filepov = bpy.path.abspath(self.filepath) #was used for single files + # filepov = bpy.path.abspath(self.filepath) #was used for single files def mat_search(cache): r = g = b = 0.5 @@ -1659,20 +1873,25 @@ class ImportPOV(bpy.types.Operator, ImportHelper): if value == 'pigment': - if cache[item+2] in {'rgb','srgb'}: + if cache[item + 2] in {'rgb', 'srgb'}: pass - elif cache[item+2] in {'rgbf','srgbf'}: + elif cache[item + 2] in {'rgbf', 'srgbf'}: pass - elif cache[item+2] in {'rgbt','srgbt'}: + elif cache[item + 2] in {'rgbt', 'srgbt'}: try: - r,g,b,t = float(cache[item+3]),float(cache[item+4]),float(cache[item+5]),float(cache[item+6]) + r, g, b, t = ( + float(cache[item + 3]), + float(cache[item + 4]), + float(cache[item + 5]), + float(cache[item + 6]), + ) except: - r = g = b = t = float(cache[item+2]) - color = (r,g,b,t) + r = g = b = t = float(cache[item + 2]) + color = (r, g, b, t) - elif cache[item+2] in {'rgbft','srgbft'}: + elif cache[item + 2] in {'rgbft', 'srgbft'}: pass else: @@ -1680,55 +1899,68 @@ class ImportPOV(bpy.types.Operator, ImportHelper): if colors == [] or (colors != [] and color not in colors): colors.append(color) - name = ob.name+"_mat" + name = ob.name + "_mat" matNames.append(name) mat = bpy.data.materials.new(name) - mat.diffuse_color = (r,g,b) - mat.alpha = 1-t + mat.diffuse_color = (r, g, b) + mat.alpha = 1 - t if mat.alpha != 1: - mat.use_transparency=True + mat.use_transparency = True ob.data.materials.append(mat) else: for i, value in enumerate(colors): if color == value: - ob.data.materials.append(bpy.data.materials[matNames[i]]) + ob.data.materials.append( + bpy.data.materials[matNames[i]] + ) + for file in self.files: - print ("Importing file: "+ file.name) + print("Importing file: " + file.name) filepov = self.directory + file.name for line in open(filepov): - string = line.replace("{"," ") - string = string.replace("}"," ") - string = string.replace("<"," ") - string = string.replace(">"," ") - string = string.replace(","," ") + string = line.replace("{", " ") + string = string.replace("}", " ") + string = string.replace("<", " ") + string = string.replace(">", " ") + string = string.replace(",", " ") lw = string.split() lenwords = len(lw) if lw: if lw[0] == "object": writematrix = True if writematrix: - if lw[0] not in {"object","matrix"}: + if lw[0] not in {"object", "matrix"}: index = lw[0] if lw[0] in {"matrix"}: - value = [float(lw[1]),float(lw[2]),float(lw[3]),\ - float(lw[4]),float(lw[5]),float(lw[6]),\ - float(lw[7]),float(lw[8]),float(lw[9]),\ - float(lw[10]),float(lw[11]),float(lw[12])] - matrixes[index]=value + value = [ + float(lw[1]), + float(lw[2]), + float(lw[3]), + float(lw[4]), + float(lw[5]), + float(lw[6]), + float(lw[7]), + float(lw[8]), + float(lw[9]), + float(lw[10]), + float(lw[11]), + float(lw[12]), + ] + matrixes[index] = value writematrix = False for line in open(filepov): - S = line.replace("{"," { ") - S = S.replace("}"," } ") - S = S.replace(","," ") - S = S.replace("<","") - S = S.replace(">"," ") - S = S.replace("="," = ") - S = S.replace(";"," ; ") + S = line.replace("{", " { ") + S = S.replace("}", " } ") + S = S.replace(",", " ") + S = S.replace("<", "") + S = S.replace(">", " ") + S = S.replace("=", " = ") + S = S.replace(";", " ; ") S = S.split() - lenS= len(S) - for i,word in enumerate(S): - ##################Primitives Import################## + lenS = len(S) + for i, word in enumerate(S): + ##################Primitives Import################## if word == 'cone': cone_search = True name_search = False @@ -1745,10 +1977,12 @@ class ImportPOV(bpy.types.Operator, ImportHelper): z1 = float(cache[8]) r1 = float(cache[9]) # Y is height in most pov files, not z - bpy.ops.pov.cone_add(base=r0, cap=r1, height=(y1-y0)) + bpy.ops.pov.cone_add( + base=r0, cap=r1, height=(y1 - y0) + ) ob = context.object - ob.location = (x0,y0,z0) - #ob.scale = (r,r,r) + ob.location = (x0, y0, z0) + # ob.scale = (r,r,r) mat_search(cache) except (ValueError): pass @@ -1781,9 +2015,13 @@ class ImportPOV(bpy.types.Operator, ImportHelper): x1 = float(cache[5]) y1 = float(cache[6]) z1 = float(cache[7]) - #imported_corner_1=(x0, y0, z0) - #imported_corner_2 =(x1, y1, z1) - center = ((x0 + x1)/2,(y0 + y1)/2,(z0 + z1)/2) + # imported_corner_1=(x0, y0, z0) + # imported_corner_2 =(x1, y1, z1) + center = ( + (x0 + x1) / 2, + (y0 + y1) / 2, + (z0 + z1) / 2, + ) bpy.ops.pov.addbox() ob = context.object ob.location = center @@ -1806,25 +2044,41 @@ class ImportPOV(bpy.types.Operator, ImportHelper): x1 = float(cache[5]) y1 = float(cache[6]) z1 = float(cache[7]) - imported_cyl_loc=(x0, y0, z0) - imported_cyl_loc_cap =(x1, y1, z1) + imported_cyl_loc = (x0, y0, z0) + imported_cyl_loc_cap = (x1, y1, z1) r = float(cache[8]) - - vec = Vector(imported_cyl_loc_cap ) - Vector(imported_cyl_loc) + vec = Vector(imported_cyl_loc_cap) - Vector( + imported_cyl_loc + ) depth = vec.length - rot = Vector((0, 0, 1)).rotation_difference(vec) # Rotation from Z axis. - trans = rot @ Vector((0, 0, depth / 2)) # Such that origin is at center of the base of the cylinder. - #center = ((x0 + x1)/2,(y0 + y1)/2,(z0 + z1)/2) - scaleZ = sqrt((x1-x0)**2+(y1-y0)**2+(z1-z0)**2)/2 - bpy.ops.pov.addcylinder(R=r, imported_cyl_loc=imported_cyl_loc, imported_cyl_loc_cap=imported_cyl_loc_cap) + rot = Vector((0, 0, 1)).rotation_difference( + vec + ) # Rotation from Z axis. + trans = rot @ Vector( + (0, 0, depth / 2) + ) # Such that origin is at center of the base of the cylinder. + # center = ((x0 + x1)/2,(y0 + y1)/2,(z0 + z1)/2) + scaleZ = ( + sqrt( + (x1 - x0) ** 2 + + (y1 - y0) ** 2 + + (z1 - z0) ** 2 + ) + / 2 + ) + bpy.ops.pov.addcylinder( + R=r, + imported_cyl_loc=imported_cyl_loc, + imported_cyl_loc_cap=imported_cyl_loc_cap, + ) ob = context.object ob.location = (x0, y0, z0) ob.rotation_euler = rot.to_euler() - ob.scale = (1,1,scaleZ) + ob.scale = (1, 1, scaleZ) - #scale data rather than obj? + # scale data rather than obj? # bpy.ops.object.mode_set(mode='EDIT') # bpy.ops.mesh.reveal() # bpy.ops.mesh.select_all(action='SELECT') @@ -1858,12 +2112,12 @@ class ImportPOV(bpy.types.Operator, ImportHelper): r = float(cache[3]) bpy.ops.pov.addsphere(R=r, imported_loc=(x, y, z)) ob = context.object - ob.location = (x,y,z) - ob.scale = (r,r,r) + ob.location = (x, y, z) + ob.scale = (r, r, r) mat_search(cache) cache = [] sphere_search = False -##################End Primitives Import################## + ##################End Primitives Import################## if word == '#declare': name_search = True if name_search: @@ -1873,37 +2127,53 @@ class ImportPOV(bpy.types.Operator, ImportHelper): if cache[-2] == '=': name = cache[-3] else: - suffix+=1 + suffix += 1 cache = [] - if word in {'texture',';'}: + if word in {'texture', ';'}: name_search = False cache = [] if word == 'vertex_vectors': - verts_search = True + verts_search = True if verts_search: cache.append(word) if word == '}': verts_search = False - lenverts=cache[2] + lenverts = cache[2] cache.pop() cache.pop(0) cache.pop(0) cache.pop(0) for i in range(int(lenverts)): - x=i*3 - y=(i*3)+1 - z=(i*3)+2 - verts.append((float(cache[x]),float(cache[y]),float(cache[z]))) + x = i * 3 + y = (i * 3) + 1 + z = (i * 3) + 2 + verts.append( + ( + float(cache[x]), + float(cache[y]), + float(cache[z]), + ) + ) cache = [] - #if word == 'face_indices': - #faces_search = True - if word == 'texture_list': ######## - tex_search = True ####### - if tex_search: ######### - if word not in {'texture_list','texture','{','}','face_indices'} and word.isdigit() == False: ############## - povMats.append(word) ################# + # if word == 'face_indices': + # faces_search = True + if word == 'texture_list': ######## + tex_search = True ####### + if tex_search: ######### + if ( + word + not in { + 'texture_list', + 'texture', + '{', + '}', + 'face_indices', + } + and word.isdigit() == False + ): ############## + povMats.append(word) ################# if word == 'face_indices': - tex_search = False ################ + tex_search = False ################ faces_search = True if faces_search: cache.append(word) @@ -1915,61 +2185,101 @@ class ImportPOV(bpy.types.Operator, ImportHelper): cache.pop(0) cache.pop(0) lf = int(lenfaces) - var=int(len(cache)/lf) + var = int(len(cache) / lf) for i in range(lf): if var == 3: - v0=i*3 - v1=i*3+1 - v2=i*3+2 - faces.append((int(cache[v0]),int(cache[v1]),int(cache[v2]))) + v0 = i * 3 + v1 = i * 3 + 1 + v2 = i * 3 + 2 + faces.append( + ( + int(cache[v0]), + int(cache[v1]), + int(cache[v2]), + ) + ) if var == 4: - v0=i*4 - v1=i*4+1 - v2=i*4+2 - m=i*4+3 + v0 = i * 4 + v1 = i * 4 + 1 + v2 = i * 4 + 2 + m = i * 4 + 3 materials.append((int(cache[m]))) - faces.append((int(cache[v0]),int(cache[v1]),int(cache[v2]))) + faces.append( + ( + int(cache[v0]), + int(cache[v1]), + int(cache[v2]), + ) + ) if var == 6: - v0=i*6 - v1=i*6+1 - v2=i*6+2 - m0=i*6+3 - m1=i*6+4 - m2=i*6+5 - materials.append((int(cache[m0]),int(cache[m1]),int(cache[m2]))) - faces.append((int(cache[v0]),int(cache[v1]),int(cache[v2]))) - #mesh = pov_define_mesh(None, verts, [], faces, name, hide_geometry=False) - #ob = object_utils.object_data_add(context, mesh, operator=None) - - me = bpy.data.meshes.new(name) ######## - ob = bpy.data.objects.new(name, me) ########## - bpy.context.collection.objects.link(ob) ######### - me.from_pydata(verts, [], faces) ############ - - for mat in bpy.data.materials: ############## - blendMats.append(mat.name) ############# - for mName in povMats: ##################### - if mName not in blendMats: ########### - povMat = bpy.data.materials.new(mName) ################# + v0 = i * 6 + v1 = i * 6 + 1 + v2 = i * 6 + 2 + m0 = i * 6 + 3 + m1 = i * 6 + 4 + m2 = i * 6 + 5 + materials.append( + ( + int(cache[m0]), + int(cache[m1]), + int(cache[m2]), + ) + ) + faces.append( + ( + int(cache[v0]), + int(cache[v1]), + int(cache[v2]), + ) + ) + # mesh = pov_define_mesh(None, verts, [], faces, name, hide_geometry=False) + # ob = object_utils.object_data_add(context, mesh, operator=None) + + me = bpy.data.meshes.new(name) ######## + ob = bpy.data.objects.new(name, me) ########## + bpy.context.collection.objects.link(ob) ######### + me.from_pydata(verts, [], faces) ############ + + for mat in bpy.data.materials: ############## + blendMats.append(mat.name) ############# + for mName in povMats: ##################### + if mName not in blendMats: ########### + povMat = bpy.data.materials.new( + mName + ) ################# mat_search(cache) - ob.data.materials.append(bpy.data.materials[mName]) ################### - if materials: ################## - for i,val in enumerate(materials): #################### - try: ################### - ob.data.polygons[i].material_index = val #################### - except TypeError: ################### - ob.data.polygons[i].material_index = int(val[0]) ################## - - blendMats = [] ######################### - povMats = [] ######################### - materials = [] ######################### + ob.data.materials.append( + bpy.data.materials[mName] + ) ################### + if materials: ################## + for i, val in enumerate( + materials + ): #################### + try: ################### + ob.data.polygons[ + i + ].material_index = ( + val + ) #################### + except TypeError: ################### + ob.data.polygons[ + i + ].material_index = int( + val[0] + ) ################## + + blendMats = [] ######################### + povMats = [] ######################### + materials = [] ######################### cache = [] name_search = True - if name in matrixes and self.import_at_cur==False: - global_matrix = Matrix.Rotation(pi / 2.0, 4, 'X') + if name in matrixes and self.import_at_cur == False: + global_matrix = Matrix.Rotation( + pi / 2.0, 4, 'X' + ) ob = bpy.context.object - matrix=ob.matrix_world - v=matrixes[name] + matrix = ob.matrix_world + v = matrixes[name] matrix[0][0] = v[0] matrix[1][0] = v[1] matrix[2][0] = v[2] @@ -1982,57 +2292,57 @@ class ImportPOV(bpy.types.Operator, ImportHelper): matrix[0][3] = v[9] matrix[1][3] = v[10] matrix[2][3] = v[11] - matrix = global_matrix*ob.matrix_world + matrix = global_matrix * ob.matrix_world ob.matrix_world = matrix verts = [] faces = [] - # if word == 'pigment': - # try: - # #all indices have been incremented once to fit a bad test file - # r,g,b,t = float(S[2]),float(S[3]),float(S[4]),float(S[5]) - # color = (r,g,b,t) - - # except (IndexError): - # #all indices have been incremented once to fit alternate test file - # r,g,b,t = float(S[3]),float(S[4]),float(S[5]),float(S[6]) - # color = (r,g,b,t) - # except UnboundLocalError: - # # In case no transmit is specified ? put it to 0 - # r,g,b,t = float(S[2]),float(S[3]),float(S[4],0) - # color = (r,g,b,t) - - # except (ValueError): - # color = (0.8,0.8,0.8,0) - # pass - - # if colors == [] or (colors != [] and color not in colors): - # colors.append(color) - # name = ob.name+"_mat" - # matNames.append(name) - # mat = bpy.data.materials.new(name) - # mat.diffuse_color = (r,g,b) - # mat.alpha = 1-t - # if mat.alpha != 1: - # mat.use_transparency=True - # ob.data.materials.append(mat) - # print (colors) - # else: - # for i in range(len(colors)): - # if color == colors[i]: - # ob.data.materials.append(bpy.data.materials[matNames[i]]) + # try: + # #all indices have been incremented once to fit a bad test file + # r,g,b,t = float(S[2]),float(S[3]),float(S[4]),float(S[5]) + # color = (r,g,b,t) + + # except (IndexError): + # #all indices have been incremented once to fit alternate test file + # r,g,b,t = float(S[3]),float(S[4]),float(S[5]),float(S[6]) + # color = (r,g,b,t) + # except UnboundLocalError: + # # In case no transmit is specified ? put it to 0 + # r,g,b,t = float(S[2]),float(S[3]),float(S[4],0) + # color = (r,g,b,t) + + # except (ValueError): + # color = (0.8,0.8,0.8,0) + # pass + + # if colors == [] or (colors != [] and color not in colors): + # colors.append(color) + # name = ob.name+"_mat" + # matNames.append(name) + # mat = bpy.data.materials.new(name) + # mat.diffuse_color = (r,g,b) + # mat.alpha = 1-t + # if mat.alpha != 1: + # mat.use_transparency=True + # ob.data.materials.append(mat) + # print (colors) + # else: + # for i in range(len(colors)): + # if color == colors[i]: + # ob.data.materials.append(bpy.data.materials[matNames[i]]) ##To keep Avogadro Camera angle: # for obj in bpy.context.view_layer.objects: - # if obj.type == "CAMERA": - # track = obj.constraints.new(type = "TRACK_TO") - # track.target = ob - # track.track_axis ="TRACK_NEGATIVE_Z" - # track.up_axis = "UP_Y" - # obj.location = (0,0,0) + # if obj.type == "CAMERA": + # track = obj.constraints.new(type = "TRACK_TO") + # track.target = ob + # track.track_axis ="TRACK_NEGATIVE_Z" + # track.up_axis = "UP_Y" + # obj.location = (0,0,0) return {'FINISHED'} + classes = ( POVRAY_OT_lathe_add, POVRAY_OT_superellipsoid_add, @@ -2065,7 +2375,7 @@ classes = ( def register(): - #from bpy.utils import register_class + # from bpy.utils import register_class for cls in classes: register_class(cls) |