diff --git a/render_povray/__init__.py b/render_povray/__init__.py
index f2723550ab04a5fd784c0a534a58cc1e5a5cc2ce..31b7671b78d657b05ccf858487b1d077256cb78d 100644
--- a/render_povray/__init__.py
+++ b/render_povray/__init__.py
@@ -993,6 +993,11 @@ class RenderPovSettingsObject(PropertyGroup):
name="Imported Pov location",
precision=6,
default=(0.0, 0.0, 0.0))
+
+ imported_loc_cap = FloatVectorProperty(
+ name="Imported Pov location",
+ precision=6,
+ default=(0.0, 0.0, 2.0))
unlock_parameters = BoolProperty(name="Lock",default = False)
@@ -1061,11 +1066,7 @@ class RenderPovSettingsObject(PropertyGroup):
addboundorclip = BoolProperty(description="",default=False)
blob_threshold = FloatProperty(name="Threshold",min=0.00, max=10.0, default=0.6)
-
- cylinder_radius = FloatProperty(name="Cylinder R",min=0.00, max=10.0, default=0.04)
-
-
blob_strength = FloatProperty(name="Strength",min=-10.00, max=10.0, default=1.00)
res_u = IntProperty(name="U",min=100, max=1000, default=500)
@@ -1089,14 +1090,32 @@ class RenderPovSettingsObject(PropertyGroup):
all_intersections = BoolProperty(name="All Intersections",default=False)
max_trace = IntProperty(name="Max Trace",min=1, max=100,default=1)
-
-
-
+
+
+ def prop_update_cylinder(self, context):
+ if bpy.ops.pov.cylinder_update.poll():
+ bpy.ops.pov.cylinder_update()
+ cylinder_radius = FloatProperty(name="Cylinder R",min=0.00, max=10.0, default=0.04, update=prop_update_cylinder)
+ cylinder_location_cap = FloatVectorProperty(
+ name="Cylinder Cap Location", subtype='TRANSLATION',
+ description="The position of the 'other' end of the cylinder (relative to object location)",
+ default=(0.0, 0.0, 2.0), update=prop_update_cylinder,
+ )
+
+ imported_cyl_loc = FloatVectorProperty(
+ name="Imported Pov location",
+ precision=6,
+ default=(0.0, 0.0, 0.0))
+
+ imported_cyl_loc_cap = FloatVectorProperty(
+ name="Imported Pov location",
+ precision=6,
+ default=(0.0, 0.0, 2.0))
+
def prop_update_sphere(self, context):
bpy.ops.pov.sphere_update()
- sphere_radius = FloatProperty(name="Sphere radius",min=0.00, max=10.0, default=0.5, update=prop_update_sphere)
+ sphere_radius = FloatProperty(name="Sphere radius",min=0.00, max=10.0, default=0.5, update=prop_update_sphere)
-
def prop_update_cone(self, context):
bpy.ops.pov.cone_update()
diff --git a/render_povray/primitives.py b/render_povray/primitives.py
index c668ed2612993985dd23c5bb8271f083ad24c33f..27010baaf43965613f0d3572b5547ace193c798a 100644
--- a/render_povray/primitives.py
+++ b/render_povray/primitives.py
@@ -1,8 +1,6 @@
############ To get POV-Ray specific objects In and Out of Blender ###########
import bpy
-#from . import render
-#from render import POVRAY_RENDER
from bpy_extras.io_utils import ImportHelper
from bpy_extras import object_utils
from math import atan, pi, degrees, sqrt, cos, sin
@@ -19,6 +17,11 @@ from bpy.props import (
CollectionProperty,
)
+from mathutils import (
+ Vector,
+ )
+
+#import collections
def pov_define_mesh(mesh, verts, edges, faces, name, hide_geometry=True):
if mesh is None:
@@ -602,31 +605,115 @@ class POVRAY_OT_box_add(bpy.types.Operator):
ob.pov.object_as = "BOX"
return {'FINISHED'}
+
+def pov_cylinder_define(context, op, ob, radius, loc, loc_cap):
+ if op:
+ R = op.R
+ loc = bpy.context.scene.cursor_location
+ loc_cap[0] = loc[0]
+ loc_cap[1] = loc[1]
+ 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.
+ roteuler = rot.to_euler()
+ if not ob:
+ bpy.ops.object.add(type='MESH', location=loc)
+ ob = context.object
+ ob.name = ob.data.name = "PovCylinder"
+ ob.pov.cylinder_radius = radius
+ ob.pov.cylinder_location_cap = vec
+ ob.pov.object_as = "CYLINDER"
+ else:
+ ob.location = loc
+
+ 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_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)
+ bpy.ops.object.mode_set(mode="OBJECT")
+ bpy.ops.object.shade_smooth()
+
+
class POVRAY_OT_cylinder_add(bpy.types.Operator):
bl_idname = "pov.addcylinder"
bl_label = "Cylinder"
bl_description = "Add Cylinder"
bl_options = {'REGISTER', 'UNDO'}
+ # XXX Keep it in sync with __init__'s cylinder Primitive
+ 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))
+
+ imported_cyl_loc_cap = FloatVectorProperty(
+ name="Imported Pov cap location",
+ precision=6,
+ default=(0.0, 0.0, 2.0))
+
def execute(self,context):
+ props = self.properties
+ R = props.R
+ ob = context.object
layers = 20*[False]
layers[0] = True
- bpy.ops.mesh.primitive_cylinder_add(layers = layers)
+ if ob:
+ if ob.pov.imported_cyl_loc:
+ LOC = ob.pov.imported_cyl_loc
+ if ob.pov.imported_cyl_loc_cap:
+ LOC_CAP = ob.pov.imported_cyl_loc_cap
+ else:
+ if not props.imported_cyl_loc:
+ LOC_CAP = LOC = bpy.context.scene.cursor_location
+ LOC_CAP[2] += 2.0
+ else:
+ LOC = props.imported_cyl_loc
+ LOC_CAP = props.imported_cyl_loc_cap
+ self.report({'WARNING'}, "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)
+
+ return {'FINISHED'}
+
+
+class POVRAY_OT_cylinder_update(bpy.types.Operator):
+ bl_idname = "pov.cylinder_update"
+ bl_label = "Update"
+ bl_description = "Update Cylinder"
+ bl_options = {'REGISTER', 'UNDO'}
+ COMPAT_ENGINES = {'POVRAY_RENDER'}
+
+ @classmethod
+ def poll(cls, context):
+ engine = context.scene.render.engine
ob = context.object
- ob.name = ob.data.name = 'PovCylinder'
- bpy.ops.object.mode_set(mode="EDIT")
- self.report({'WARNING'}, "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 = "CYLINDER"
+ 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
+ radius = ob.pov.cylinder_radius
+ loc = ob.location
+ loc_cap = loc + ob.pov.cylinder_location_cap
+
+ pov_cylinder_define(context, None, ob, radius, loc, loc_cap)
return {'FINISHED'}
+
+
################################SPHERE##########################################
def pov_sphere_define(context, op, ob, loc):
if op:
R = op.R
-
+ loc = bpy.context.scene.cursor_location
else:
assert(ob)
R = ob.pov.sphere_radius
@@ -648,6 +735,7 @@ def pov_sphere_define(context, op, ob, loc):
bpy.ops.mesh.hide(unselected=False)
bpy.ops.object.mode_set(mode="OBJECT")
+ bpy.ops.object.shade_smooth()
#bpy.ops.transform.rotate(axis=obrot,constraint_orientation='GLOBAL')
if not ob:
@@ -659,6 +747,7 @@ def pov_sphere_define(context, op, ob, loc):
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):
bl_idname = "pov.addsphere"
bl_label = "Sphere"
@@ -677,14 +766,22 @@ class POVRAY_OT_sphere_add(bpy.types.Operator):
props = self.properties
R = props.R
ob = context.object
+
+
+
if ob:
if ob.pov.imported_loc:
LOC = ob.pov.imported_loc
else:
- LOC = bpy.context.scene.cursor_location
+ if not props.imported_loc:
+ LOC = bpy.context.scene.cursor_location
+
+ else:
+ LOC = props.imported_loc
+ self.report({'WARNING'}, "This native POV-Ray primitive "
+ "won't have any vertex to show in edit mode")
pov_sphere_define(context, self, None, LOC)
- self.report({'WARNING'}, "This native POV-Ray primitive "
- "won't have any vertex to show in edit mode")
+
return {'FINISHED'}
# def execute(self,context):
@@ -1355,140 +1452,376 @@ class POVRAY_OT_shape_polygon_to_circle_add(bpy.types.Operator):
return {'FINISHED'}
#############################IMPORT
-class ImportAvogadroPOV(bpy.types.Operator, ImportHelper):
- """Load Povray File as output by Avogadro"""
- bl_idname = "import_scene.avogadro"
- bl_label = "Import POV Avogadro"
+
+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'}
COMPAT_ENGINES = {'POVRAY_RENDER'}
- filename_ext = ".pov"
+ # -----------
+ # 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",
+ default="*.pov;*.inc",
options={'HIDDEN'},
)
-
+
+ import_at_cur = BoolProperty(name="Import at Cursor Location",
+ description = "Ignore Object Matrix",
+ default=False)
+
def execute(self, context):
- coords=[]
+ from mathutils import Matrix
+ verts = []
+ faces = []
+ materials = []
colors = []
matNames = []
- xall = yall = zall = []
- layers = 20*[False]
- layers[0] = True
- ob = None
- camloc = (0,0,0)
- filepov = bpy.path.abspath(self.filepath)
- for line in open(filepov):
- string = line.replace("<"," ")
- chars = [">","{","}",","]
- for symbol in chars:
- string = string.replace(symbol," ")
- split = string.split()
- if split and split[0] == "location":
- x = float(split[1])
- y = float(split[2])
- z = float(split[3])
- camloc = ((x,y,z))
- if split and len(split) == 7:
- try:
- x1 = float(split[0])
- coords.append(x1)
- except:
- pass
- if coords != []:
- x1 = float(split[0])
- y1 = float(split[1])
- z1 = float(split[2])
- x2 = float(split[3])
- y2 = float(split[4])
- z2 = float(split[5])
- xall.append(x1)
- yall.append(y1)
- zall.append(z1)
- xall.append(x2)
- yall.append(y2)
- zall.append(z2)
- radius = float(split[6])
- curveData = bpy.data.curves.new('myCurve', type='CURVE')
- curveData.dimensions = '3D'
- curveData.resolution_u = 2
- curveData.fill_mode = "FULL"
- curveData.bevel_depth = radius
- curveData.bevel_resolution = 5
- polyline = curveData.splines.new('POLY')
- polyline.points.add(1)
- polyline.points[0].co = (x1, y1, z1, 1)
- polyline.points[1].co = (x2, y2, z2, 1)
- ob = bpy.data.objects.new('myCurve', curveData)
- scn = bpy.context.scene
- scn.objects.link(ob)
- scn.objects.active = ob
- ob.select = True
- bpy.ops.object.convert(target='MESH',keep_original=False)
- #XXX TODO use a PovCylinder instead of mesh
- #but add end points and radius to addPovcylinder op first
- ob.select=False
- coords = []
- if split and len(split) == 4:
- try:
- x = float(split[0])
- coords.append(x)
- except:
- pass
- if coords != []:
- x = float(split[0])
- y = float(split[1])
- z = float(split[2])
- xall.append(x)
- yall.append(y)
- zall.append(z)
- radius = float(split[3])
+ lenverts = None
+ lenfaces = None
+ suffix = -1
+ name = 'Mesh2_%s'%suffix
+ name_search = False
+ verts_search = False
+ faces_search = False
+ plane_search = False
+ box_search = False
+ cylinder_search = False
+ sphere_search = False
+ cone_search = False
+ cache = []
+ matrixes = {}
+ writematrix = False
+ index = None
+ value = None
+ #filepov = bpy.path.abspath(self.filepath) #was used for single files
+
+ def mat_search(cache):
+ r,g,b,t = float(cache[-5]),float(cache[-4]),float(cache[-3]),float(cache[-2])
+ color = (r,g,b,t)
+ 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]])
+ for file in self.files:
+ 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(","," ")
+ lw = string.split()
+ lenwords = len(lw)
+ if lw:
+ if lw[0] == "object":
+ writematrix = True
+ if writematrix:
+ 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
+ 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 = S.split()
+ lenS= len(S)
+ for i,word in enumerate(S):
+ ##################Primitives Import##################
+ if word == 'cone':
+ cone_search = True
+ name_search = False
+ if cone_search:
+ cache.append(word)
+ if cache[-1] == '}':
+ try:
+ x0 = float(cache[2])
+ y0 = float(cache[3])
+ z0 = float(cache[4])
+ r0 = float(cache[5])
+ x1 = float(cache[6])
+ y1 = float(cache[7])
+ 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))
+ ob = context.object
+ ob.location = (x0,y0,z0)
+ #ob.scale = (r,r,r)
+ mat_search(cache)
+ except (ValueError):
+ pass
+ cache = []
+ cone_search = False
+ if word == 'plane':
+ plane_search = True
+ name_search = False
+ if plane_search:
+ cache.append(word)
+ if cache[-1] == '}':
+ try:
+ bpy.ops.pov.addplane()
+ ob = context.object
+ mat_search(cache)
+ except (ValueError):
+ pass
+ cache = []
+ plane_search = False
+ if word == 'box':
+ box_search = True
+ name_search = False
+ if box_search:
+ cache.append(word)
+ if cache[-1] == '}':
+ try:
+ x0 = float(cache[2])
+ y0 = float(cache[3])
+ z0 = float(cache[4])
+ 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)
+ bpy.ops.pov.addbox()
+ ob = context.object
+ ob.location = center
+ mat_search(cache)
+
+ except (ValueError):
+ pass
+ cache = []
+ box_search = False
+ if word == 'cylinder':
+ cylinder_search = True
+ name_search = False
+ if cylinder_search:
+ cache.append(word)
+ if cache[-1] == '}':
+ try:
+ x0 = float(cache[2])
+ y0 = float(cache[3])
+ z0 = float(cache[4])
+ 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)
+
+ r = float(cache[8])
+
+
+ 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)
+ ob = context.object
+ ob.location = (x0, y0, z0)
+ ob.rotation_euler = rot.to_euler()
+ ob.scale = (1,1,scaleZ)
+
+ #scale data rather than obj?
+ # bpy.ops.object.mode_set(mode='EDIT')
+ # bpy.ops.mesh.reveal()
+ # bpy.ops.mesh.select_all(action='SELECT')
+ # bpy.ops.transform.resize(value=(1,1,scaleZ), constraint_orientation='LOCAL')
+ # bpy.ops.mesh.hide(unselected=False)
+ # bpy.ops.object.mode_set(mode='OBJECT')
+
+ mat_search(cache)
+
+ except (ValueError):
+ pass
+ cache = []
+ cylinder_search = False
+ if word == 'sphere':
+ sphere_search = True
+ name_search = False
+ if sphere_search:
+ cache.append(word)
+ if cache[-1] == '}':
+ try:
+ x = float(cache[2])
+ y = float(cache[3])
+ z = float(cache[4])
+ r = float(cache[5])
+ bpy.ops.pov.addsphere(R=r, imported_loc=(x, y, z))
+ ob = context.object
+ ob.location = (x,y,z)
+ #ob.scale = (r,r,r)
+ mat_search(cache)
+ except (ValueError):
+ pass
+ cache = []
+ sphere_search = False
+ ##################End Primitives Import##################
+ if word == '#declare':
+ name_search = True
+ if name_search:
+ cache.append(word)
+ if word == 'mesh2':
+ name_search = False
+ if cache[-2] == '=':
+ name = cache[-3]
+ else:
+ suffix+=1
+ cache = []
+ if word in {'texture',';'}:
+ name_search = False
+ cache = []
+ if word == 'vertex_vectors':
+ verts_search = True
+ if verts_search:
+ cache.append(word)
+ if word == '}':
+ verts_search = False
+ 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])))
+ cache = []
+ if word == 'face_indices':
+ faces_search = True
+ if faces_search:
+ cache.append(word)
+ if word == '}':
+ faces_search = False
+ lenfaces = cache[2]
+ cache.pop()
+ cache.pop(0)
+ cache.pop(0)
+ cache.pop(0)
+ lf = int(lenfaces)
+ 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])))
+ if var == 4:
+ 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])))
+ 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_base = object_utils.object_data_add(context, mesh, operator=None)
+ ob = ob_base.object
+ cache = []
+ name_search = True
+ 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[0][0] = v[0]
+ matrix[1][0] = v[1]
+ matrix[2][0] = v[2]
+ matrix[0][1] = v[3]
+ matrix[1][1] = v[4]
+ matrix[2][1] = v[5]
+ matrix[0][2] = v[6]
+ matrix[1][2] = v[7]
+ matrix[2][2] = v[8]
+ matrix[0][3] = v[9]
+ matrix[1][3] = v[10]
+ matrix[2][3] = v[11]
+ 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)
-
- ob.pov.imported_loc=(x, y, z)
- bpy.ops.pov.addsphere(R=radius, imported_loc=(x, y, z))
- bpy.ops.object.shade_smooth()
- ob = bpy.context.object
- coords = []
- if split and len(split) == 6:
- if split[0] == "pigment":
- r,g,b,t = float(split[2]),float(split[3]),float(split[4]),float(split[5])
- color = (r,g,b,t)
- 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
- 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]])
- x0 = min(xall)
- x1 = max(xall)
- y0 = min(yall)
- y1 = max(yall)
- z0 = min(zall)
- z1 = max(zall)
- x = (x0+x1)/2
- y = (y0+y1)/2
- z = (z0+z1)/2
- bpy.ops.object.empty_add(layers=layers)
- ob = bpy.context.object
- ob.location = ((x,y,z))
- for obj in bpy.context.scene.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 = camloc
- for obj in bpy.context.scene.objects:
- if obj.type == "LAMP":
- obj.location = camloc
- obj.pov.light_type = "shadowless"
- break
- return {'FINISHED'}
+ # 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.scene.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)
+ return {'FINISHED'}
+
+
\ No newline at end of file
diff --git a/render_povray/render.py b/render_povray/render.py
index d773e96b01601419b393e8333eb37df93db5c5f8..d0fde8de1b6e4d94c15b645d490989867fb3ef65 100644
--- a/render_povray/render.py
+++ b/render_povray/render.py
@@ -2174,7 +2174,16 @@ def write_pov(filename, scene=None, info_callback=None):
continue #Don't render proxy mesh, skip to next object
if ob.pov.object_as == 'CYLINDER':
- tabWrite("#declare %s = cylinder { <0,0,1>,<0,0,-1>,1\n"%povdataname)
+ r = ob.pov.cylinder_radius
+ x2 = ob.pov.cylinder_location_cap[0]
+ y2 = ob.pov.cylinder_location_cap[1]
+ z2 = ob.pov.cylinder_location_cap[2]
+ tabWrite("#declare %s = cylinder { <0,0,0>,<%6f,%6f,%6f>,%6f\n"%(
+ povdataname,
+ x2,
+ y2,
+ z2,
+ r))
povMatName = "Default_texture"
if ob.active_material:
#povMatName = string_strip_hyphen(bpy.path.clean_name(ob.active_material.name))
@@ -2184,6 +2193,7 @@ def write_pov(filename, scene=None, info_callback=None):
except IndexError:
print(me)
#tabWrite("texture {%s}\n"%povMatName)
+ #cylinders written at origin, translated below
write_object_modifiers(scene,ob,file)
#tabWrite("rotate x*90\n")
tabWrite("}\n")
@@ -3154,7 +3164,7 @@ def write_pov(filename, scene=None, info_callback=None):
#string_strip_hyphen(patternNames[texture.name]) #maybe instead of the above
LocalPatternNames.append(currentPatName)
#use above list to prevent writing texture instances several times and assign in mats?
- if (texture.type!='NONE' and texture.pov.tex_pattern_type == 'emulator')or(texture.type =='NONE' and texture.pov.tex_pattern_type != 'emulator'):
+ if (texture.type not in {'NONE', 'IMAGE'} and texture.pov.tex_pattern_type == 'emulator')or(texture.type in {'NONE', 'IMAGE'} and texture.pov.tex_pattern_type != 'emulator'):
file.write("\n#declare PAT_%s = \n" % currentPatName)
file.write(shading.exportPattern(texture, string_strip_hyphen))
file.write("\n")
diff --git a/render_povray/shading.py b/render_povray/shading.py
index deb2ab866fe36f3976247ac5c44ee12905285cea..8a7cff75e3ec3fda5fec0ad33e2901b714a1613b 100644
--- a/render_povray/shading.py
+++ b/render_povray/shading.py
@@ -266,7 +266,7 @@ def exportPattern(texture, string_strip_hyphen):
return colRampStrg
#much work to be done here only defaults translated for now:
#pov noise_generator 3 means perlin noise
- if tex.type!='NONE' and pat.tex_pattern_type == 'emulator':
+ if tex.type not in {'NONE', 'IMAGE'} and pat.tex_pattern_type == 'emulator':
texStrg+="pigment {\n"
####################### EMULATE BLENDER VORONOI TEXTURE ####################
if tex.type == 'VORONOI':
@@ -769,7 +769,9 @@ def writeTextureInfluence(mater, materialNames, LocalMaterialNames, path_image,
unpacked_images.append(unpackedfilename)
t.texture.image.filepath_raw=unpackedfilename
t.texture.image.save()
- image_filename = unpackedfilename
+ image_filename = unpackedfilename.replace("\\","/")
+ # .replace("\\","/") to get only forward slashes as it's what POV prefers,
+ # even on windows
t.texture.image.filepath_raw=orig_image_filename
else:
image_filename = path_image(t.texture.image)
diff --git a/render_povray/ui.py b/render_povray/ui.py
index 106bf6ed8f168eeef881a8cfac5674eec7105a7f..f0c361d981605821ec50abeb482928efbc2b56fa 100644
--- a/render_povray/ui.py
+++ b/render_povray/ui.py
@@ -1042,7 +1042,41 @@ class OBJECT_PT_povray_obj_sphere(PovDataButtonsPanel, bpy.types.Panel):
#col.label(text="Parameters:")
col.prop(obj.pov, "sphere_radius", text="Radius of Sphere")
-
+
+class OBJECT_PT_povray_obj_cylinder(PovDataButtonsPanel, bpy.types.Panel):
+ bl_label = "POV-Ray Cylinder"
+ COMPAT_ENGINES = {'POVRAY_RENDER'}
+ #bl_options = {'HIDE_HEADER'}
+ @classmethod
+ def poll(cls, context):
+ engine = context.scene.render.engine
+ obj = context.object
+ return (obj and obj.pov.object_as == 'CYLINDER' and (engine in cls.COMPAT_ENGINES))
+ def draw(self, context):
+ layout = self.layout
+
+ obj = context.object
+
+ col = layout.column()
+
+ if obj.pov.object_as == 'CYLINDER':
+ if obj.pov.unlock_parameters == False:
+ col.prop(obj.pov, "unlock_parameters", text="Exported parameters below", icon='LOCKED')
+ col.label(text="Cylinder radius: " + str(obj.pov.cylinder_radius))
+ col.label(text="Cylinder cap location: " + str(obj.pov.cylinder_location_cap))
+
+ else:
+ col.prop(obj.pov, "unlock_parameters", text="Edit exported parameters", icon='UNLOCKED')
+ col.label(text="3D view proxy may get out of synch")
+ col.active = obj.pov.unlock_parameters
+
+
+ layout.operator("pov.cylinder_update", text="Update",icon="MESH_CYLINDER")
+
+ #col.label(text="Parameters:")
+ col.prop(obj.pov, "cylinder_radius")
+ col.prop(obj.pov, "cylinder_location_cap")
+
class OBJECT_PT_povray_obj_cone(PovDataButtonsPanel, bpy.types.Panel):
bl_label = "POV-Ray Cone"
COMPAT_ENGINES = {'POVRAY_RENDER'}
@@ -1330,7 +1364,7 @@ class ImportMenu(bpy.types.Menu):
pov = bpy.types.Object.pov #context.object.pov ?
layout = self.layout
layout.operator_context = 'INVOKE_REGION_WIN'
- layout.operator("import_scene.avogadro", text="Avogadro",icon="FORCE_LENNARDJONES")
+ layout.operator("import_scene.pov",icon="FORCE_LENNARDJONES")
def menu_func_add(self, context):
engine = context.scene.render.engine
@@ -1340,7 +1374,7 @@ def menu_func_add(self, context):
def menu_func_import(self, context):
engine = context.scene.render.engine
if engine == 'POVRAY_RENDER':
- self.layout.operator("import_scene.avogadro", text="POV-Ray Avogadro (.pov)",icon="FORCE_LENNARDJONES")
+ self.layout.operator("import_scene.pov",icon="FORCE_LENNARDJONES")
###############################################################################