Spelling fixes in comments and descriptions, patch by luzpaz.
Differential Revision: https://developer.blender.org/D3746
This commit is contained in:
parent
84b8171173
commit
d7d3233715
|
@ -201,7 +201,7 @@ def create_mesh_from_audio(self, scene, verts, faces):
|
|||
bpy.context.scene.objects.active = ob
|
||||
ob.select = True
|
||||
|
||||
# inital vertex colors
|
||||
# initial vertex colors
|
||||
if adv_obj.cubester_materials == "image" and adv_obj.cubester_color_image != "":
|
||||
picture = bpy.data.images[adv_obj.cubester_color_image]
|
||||
pixels = list(picture.pixels)
|
||||
|
@ -727,7 +727,7 @@ class CubeSterPanel(Panel):
|
|||
box.prop_search(adv_obj, "cubester_image", bpy.data, "images")
|
||||
box.prop(adv_obj, "cubester_load_image")
|
||||
|
||||
# find number of approriate images if sequence
|
||||
# find number of appropriate images if sequence
|
||||
if adv_obj.cubester_load_type == "multiple":
|
||||
box = layout.box()
|
||||
# display number of images found there
|
||||
|
@ -787,7 +787,7 @@ class CubeSterPanel(Panel):
|
|||
if adv_obj.cubester_materials == "image":
|
||||
box.prop(adv_obj, "cubester_load_type")
|
||||
|
||||
# find number of approriate images if sequence
|
||||
# find number of appropriate images if sequence
|
||||
if adv_obj.cubester_load_type == "multiple":
|
||||
# display number of images found there
|
||||
images = find_sequence_images(self, context)
|
||||
|
|
|
@ -48,7 +48,7 @@ def createLattice(context, obj, props):
|
|||
lat = bpy.data.lattices.new('EasyLattice')
|
||||
ob = bpy.data.objects.new('EasyLattice', lat)
|
||||
|
||||
# Take into consideration any selected vertices (default: all verticies)
|
||||
# Take into consideration any selected vertices (default: all vertices)
|
||||
selectedVertices = createVertexGroup(obj)
|
||||
|
||||
size, pos = findBBox(obj, selectedVertices)
|
||||
|
@ -172,7 +172,7 @@ def findBBox(obj, selvertsarray):
|
|||
def buildTrnSclMat(obj):
|
||||
# This function builds a local matrix that encodes translation
|
||||
# and scale and it leaves out the rotation matrix
|
||||
# The rotation is applied at obejct level if there is any
|
||||
# The rotation is applied at object level if there is any
|
||||
mat_trans = Matrix.Translation(obj.location)
|
||||
mat_scale = Matrix.Scale(obj.scale[0], 4, (1, 0, 0))
|
||||
mat_scale *= Matrix.Scale(obj.scale[1], 4, (0, 1, 0))
|
||||
|
@ -186,7 +186,7 @@ def buildTrnSclMat(obj):
|
|||
def buildTrnScl_WorldMat(obj):
|
||||
# This function builds a real world matrix that encodes translation
|
||||
# and scale and it leaves out the rotation matrix
|
||||
# The rotation is applied at obejct level if there is any
|
||||
# The rotation is applied at object level if there is any
|
||||
loc, rot, scl = obj.matrix_world.decompose()
|
||||
mat_trans = Matrix.Translation(loc)
|
||||
|
||||
|
@ -215,7 +215,7 @@ def buildRot_WorldMat(obj):
|
|||
def buildTrn_WorldMat(obj):
|
||||
# This function builds a real world matrix that encodes translation
|
||||
# and scale and it leaves out the rotation matrix
|
||||
# The rotation is applied at obejct level if there is any
|
||||
# The rotation is applied at object level if there is any
|
||||
loc, rot, scl = obj.matrix_world.decompose()
|
||||
mat_trans = Matrix.Translation(loc)
|
||||
|
||||
|
@ -225,7 +225,7 @@ def buildTrn_WorldMat(obj):
|
|||
def buildScl_WorldMat(obj):
|
||||
# This function builds a real world matrix that encodes translation
|
||||
# and scale and it leaves out the rotation matrix
|
||||
# The rotation is applied at obejct level if there is any
|
||||
# The rotation is applied at object level if there is any
|
||||
loc, rot, scl = obj.matrix_world.decompose()
|
||||
|
||||
mat_scale = Matrix.Scale(scl[0], 4, (1, 0, 0))
|
||||
|
|
|
@ -75,7 +75,7 @@ def Add_Chain():
|
|||
# Positions Torus primitive to center of scene
|
||||
bpy.context.active_object.location = 0.0, 0.0, 0.0
|
||||
|
||||
# Reseting Torus rotation in case of 'Align to view' option enabled
|
||||
# Resetting Torus rotation in case of 'Align to view' option enabled
|
||||
bpy.context.active_object.rotation_euler = 0.0, 0.0, 0.0
|
||||
|
||||
# Changes Torus name to chain adds variable tor
|
||||
|
|
|
@ -204,7 +204,7 @@ class ClothRope(Operator):
|
|||
bl_description = ("Create a new Scene with a Cloth modifier\n"
|
||||
"Rope Simulation with hooked Helper Objects")
|
||||
|
||||
ropelenght = IntProperty(
|
||||
ropelength = IntProperty(
|
||||
name="Rope Length",
|
||||
description="Length of the generated Rope",
|
||||
default=5
|
||||
|
@ -249,7 +249,7 @@ class ClothRope(Operator):
|
|||
scene = bpy.context.scene
|
||||
scene.name = "Test Rope"
|
||||
seleccionar_todo()
|
||||
longitud = self.ropelenght
|
||||
longitud = self.ropelength
|
||||
|
||||
# For the middle to have x segments between the first and
|
||||
# last point, must add 1 to the quantity:
|
||||
|
@ -333,10 +333,10 @@ class ClothRope(Operator):
|
|||
entrar_en_editmode() # enter edit mode
|
||||
bpy.ops.object.vertex_group_add() # Creating Master guide group
|
||||
select_all_in_edit_mode(ob)
|
||||
bpy.ops.object.vertex_group_assign() # and assing it
|
||||
bpy.ops.object.vertex_group_assign() # and assign it
|
||||
ob.vertex_groups[1].name = "Guide_rope"
|
||||
|
||||
# extrude the Curve so it has a minumum thickness for collide
|
||||
# extrude the Curve so it has a minimum thickness for collide
|
||||
bpy.ops.mesh.extrude_region_move(
|
||||
MESH_OT_extrude_region={"mirror": False},
|
||||
TRANSFORM_OT_translate={
|
||||
|
@ -485,7 +485,7 @@ class ClothRope(Operator):
|
|||
|
||||
col.label("Rope settings:")
|
||||
rowsub0 = col.row()
|
||||
rowsub0.prop(self, "ropelenght", text="Length")
|
||||
rowsub0.prop(self, "ropelength", text="Length")
|
||||
rowsub0.prop(self, "ropesegments", text="Segments")
|
||||
rowsub0.prop(self, "radiusrope", text="Radius")
|
||||
|
||||
|
@ -502,7 +502,7 @@ class BallRope(Operator):
|
|||
"Wrecking Ball on a rope")
|
||||
|
||||
# defaults rope ball
|
||||
ropelenght2 = IntProperty(
|
||||
ropelength2 = IntProperty(
|
||||
name="Rope Length",
|
||||
description="Length of the Wrecking Ball rope",
|
||||
default=10
|
||||
|
@ -564,7 +564,7 @@ class BallRope(Operator):
|
|||
def execute(self, context):
|
||||
world_steps = self.worldsteps
|
||||
solver_iterations = self.solveriterations
|
||||
longitud = self.ropelenght2
|
||||
longitud = self.ropelength2
|
||||
|
||||
# make a + 2, so the segments will be between the two end points...
|
||||
segmentos = self.ropesegments2 + 2
|
||||
|
@ -800,7 +800,7 @@ class BallRope(Operator):
|
|||
rowsub0.prop(self, "hidecubes", text="Hide Link Cubes")
|
||||
|
||||
rowsub1 = col.row(align=True)
|
||||
rowsub1.prop(self, "ropelenght2", text="Length")
|
||||
rowsub1.prop(self, "ropelength2", text="Length")
|
||||
rowsub1.prop(self, "ropesegments2", text="Segments")
|
||||
|
||||
rowsub2 = col.row(align=True)
|
||||
|
|
|
@ -264,10 +264,10 @@ class Context(object):
|
|||
|
||||
def setClipBuffer(self, xpourcent, ypourcent):
|
||||
xmin, xmax, ymin, ymax = self.extent
|
||||
witdh = xmax - xmin
|
||||
width = xmax - xmin
|
||||
height = ymax - ymin
|
||||
xmin = xmin - witdh * xpourcent / 100
|
||||
xmax = xmax + witdh * xpourcent / 100
|
||||
xmin = xmin - width * xpourcent / 100
|
||||
xmax = xmax + width * xpourcent / 100
|
||||
ymin = ymin - height * ypourcent / 100
|
||||
ymax = ymax + height * ypourcent / 100
|
||||
self.extent = xmin, xmax, ymin, ymax
|
||||
|
@ -761,7 +761,7 @@ class EdgeList(object):
|
|||
break
|
||||
i += 1
|
||||
|
||||
# Now search linear list of halfedges for the corect one
|
||||
# Now search linear list of halfedges for the correct one
|
||||
if (he is self.leftend) or (he is not self.rightend and he.isPointRightOf(pt)):
|
||||
he = he.right
|
||||
while he is not self.rightend and he.isPointRightOf(pt):
|
||||
|
|
|
@ -468,7 +468,7 @@ class AdvancedObjProperties1(PropertyGroup):
|
|||
)
|
||||
# oscurart_constellation
|
||||
constellation_limit = FloatProperty(
|
||||
name="Inital Threshold",
|
||||
name="Initial Threshold",
|
||||
description="Edges will be created only if the distance\n"
|
||||
"between vertices is smaller than this value\n"
|
||||
"This is a starting value on Operator Invoke",
|
||||
|
|
|
@ -157,7 +157,7 @@ class OBJECT_OT_TriangulateButton(Operator):
|
|||
print("Total :%s faces %s verts" % (len(faces), len(points_3D)))
|
||||
return {'FINISHED'}
|
||||
|
||||
# Get points coodinates
|
||||
# Get points coordinates
|
||||
r = obj.rotation_euler
|
||||
s = obj.scale
|
||||
mesh = obj.data
|
||||
|
@ -244,7 +244,7 @@ class OBJECT_OT_VoronoiButton(Operator):
|
|||
# move the check into the poll
|
||||
obj = context.active_object
|
||||
|
||||
# Get points coodinates
|
||||
# Get points coordinates
|
||||
r = obj.rotation_euler
|
||||
s = obj.scale
|
||||
mesh = obj.data
|
||||
|
|
|
@ -514,7 +514,7 @@ def writeStokeToSingleMesh(arr, jarr, orig, gs, mct, rpt=None):
|
|||
def visualizeArray(cg, oob, gs, vm, vs, vc, vv, rst):
|
||||
winmgr = bpy.context.scene.advanced_objects1
|
||||
# IN: (cellgrid, origin, gridscale,
|
||||
# mulimesh, single mesh, cubes, voxels, report sting)
|
||||
# mulimesh, single mesh, cubes, voxels, report string)
|
||||
origin = oob.location
|
||||
|
||||
# deal with vert multi-origins
|
||||
|
@ -613,7 +613,7 @@ def buildCPGraph_WORKINPROGRESS(arr, sti=2):
|
|||
def findChargePath(oc, fc, ngraph, restrict=[], partial=True):
|
||||
# oc -origin charge index, fc -final charge index
|
||||
# ngraph -node graph, restrict- index of sites cannot traverse
|
||||
# partial -return partial path if restriction encounterd
|
||||
# partial -return partial path if restriction encountered
|
||||
cList = splitList(ngraph, 0)
|
||||
pList = splitList(ngraph, 1)
|
||||
aRi = []
|
||||
|
@ -764,7 +764,7 @@ def classifyStroke(sarr, mct, hORDER=1):
|
|||
aTIPSi = findTips(sgarr)
|
||||
|
||||
# find horder channel roots
|
||||
# hcount = orders bewteen main and side/tips
|
||||
# hcount = orders between main and side/tips
|
||||
# !!!still buggy!!!
|
||||
hRESTRICT = list(aMAINi) # add to this after each time
|
||||
allHPATHSi = [] # all ho paths: [[h0], [h1]...]
|
||||
|
@ -794,7 +794,7 @@ def classifyStroke(sarr, mct, hORDER=1):
|
|||
hRESTRICT += hri
|
||||
curPATHSi = aHPATHSi
|
||||
|
||||
# side branches, final order of heirarchy
|
||||
# side branches, final order of hierarchy
|
||||
# from tips that are not in an existing path
|
||||
# back to any other point that is already on a path
|
||||
aDRAWNi = []
|
||||
|
@ -1159,13 +1159,13 @@ def FSLG():
|
|||
winmgr.ORIGIN = obORIGIN.location
|
||||
winmgr.GROUNDZ = int((obGROUND.location[2] - winmgr.ORIGIN[2]) / winmgr.GSCALE)
|
||||
|
||||
# 1) insert intial charge(s) point (uses verts if mesh)
|
||||
# 1) insert initial charge(s) point (uses verts if mesh)
|
||||
cgrid = [(0, 0, 0)]
|
||||
|
||||
if obORIGIN.type == 'MESH':
|
||||
debug_prints(
|
||||
func="FSLG",
|
||||
text="Origin object is mesh, 'voxelizing' intial charges from verts"
|
||||
text="Origin object is mesh, 'voxelizing' initial charges from verts"
|
||||
)
|
||||
cgrid = voxelByVertex(obORIGIN, winmgr.GSCALE)
|
||||
|
||||
|
|
|
@ -49,7 +49,7 @@ def move_coordinate(context, co, is_curve=False):
|
|||
multiplier = 1
|
||||
|
||||
# For curves, we base the multiplier on the circumference formula.
|
||||
# This helps make curve changes more noticable.
|
||||
# This helps make curve changes more noticeable.
|
||||
if is_curve:
|
||||
multiplier = 2 * pi
|
||||
random_mag = advanced_objects.mangle_random_magnitude
|
||||
|
|
|
@ -746,7 +746,7 @@ def setBezierHandles(obj, mode='AUTOMATIC'):
|
|||
bpy.ops.object.mode_set(mode='OBJECT', toggle=True)
|
||||
|
||||
|
||||
# get array of vertcoordinates acording to splinetype
|
||||
# get array of vertcoordinates according to splinetype
|
||||
def vertsToPoints(Verts, splineType):
|
||||
|
||||
# main vars
|
||||
|
|
|
@ -88,7 +88,7 @@ class CelticKnotOperator(Operator):
|
|||
)
|
||||
crossing_strength = FloatProperty(
|
||||
name="Crossing Strength",
|
||||
description="Aligned only: strenth of bezier control points",
|
||||
description="Aligned only: strength of bezier control points",
|
||||
soft_min=0,
|
||||
subtype="DISTANCE",
|
||||
unit="LENGTH"
|
||||
|
|
|
@ -817,7 +817,7 @@ class Simple(Operator):
|
|||
# general properties
|
||||
Types = [('Point', "Point", "Construct a Point"),
|
||||
('Line', "Line", "Construct a Line"),
|
||||
('Distance', "Distance", "Contruct a two point Distance"),
|
||||
('Distance', "Distance", "Construct a two point Distance"),
|
||||
('Angle', "Angle", "Construct an Angle"),
|
||||
('Circle', "Circle", "Construct a Circle"),
|
||||
('Ellipse', "Ellipse", "Construct an Ellipse"),
|
||||
|
@ -1526,7 +1526,7 @@ class SimpleVariables(PropertyGroup):
|
|||
# general properties
|
||||
Types = [('Point', "Point", "Construct a Point"),
|
||||
('Line', "Line", "Construct a Line"),
|
||||
('Distance', "Distance", "Contruct a two point Distance"),
|
||||
('Distance', "Distance", "Construct a two point Distance"),
|
||||
('Angle', "Angle", "Construct an Angle"),
|
||||
('Circle', "Circle", "Construct a Circle"),
|
||||
('Ellipse', "Ellipse", "Construct an Ellipse"),
|
||||
|
|
|
@ -43,7 +43,7 @@ def make_spiral(props, context):
|
|||
# archemedian and logarithmic can be plotted in cylindrical coordinates
|
||||
|
||||
# INPUT: turns->degree->max_phi, steps, direction
|
||||
# Initialise Polar Coordinate Enviroment
|
||||
# Initialise Polar Coordinate Environment
|
||||
props.degree = 360 * props.turns # If you want to make the slider for degree
|
||||
steps = props.steps * props.turns # props.steps[per turn] -> steps[for the whole spiral]
|
||||
props.z_scale = props.dif_z * props.turns
|
||||
|
|
|
@ -547,8 +547,8 @@ class torus_knot_plus(Operator, AddObjectHelper):
|
|||
items=SplineTypes,
|
||||
)
|
||||
bezierHandles = [
|
||||
('VECTOR', "Vector", "Bezier Hanles type - Vector"),
|
||||
('AUTOMATIC', "Auto", "Bezier Hanles type - Automatic"),
|
||||
('VECTOR', "Vector", "Bezier Handles type - Vector"),
|
||||
('AUTOMATIC', "Auto", "Bezier Handles type - Automatic"),
|
||||
]
|
||||
handleType = EnumProperty(
|
||||
name="Handle type",
|
||||
|
|
|
@ -81,7 +81,7 @@ class MakeSurfaceWedge(Operator, MakeSurfaceHelpers):
|
|||
|
||||
# add a surface Plane
|
||||
bpy.ops.object.add_surface_plane()
|
||||
# save some time, by getting instant acces to those values
|
||||
# save some time, by getting instant access to those values
|
||||
ao = context.active_object
|
||||
point = ao.data.splines[0].points
|
||||
|
||||
|
@ -95,7 +95,7 @@ class MakeSurfaceWedge(Operator, MakeSurfaceHelpers):
|
|||
bpy.ops.curve.select_all(action='DESELECT')
|
||||
|
||||
# select points 0 and 1, and extrudde them
|
||||
# declaring ao and point again seems necesary...
|
||||
# declaring ao and point again seems necessary...
|
||||
ao = context.active_object
|
||||
point = ao.data.splines[0].points
|
||||
point[0].select = True
|
||||
|
@ -154,7 +154,7 @@ class MakeSurfaceCone(Operator, MakeSurfaceHelpers):
|
|||
bpy.ops.object.mode_set(mode='EDIT')
|
||||
# deselect all
|
||||
bpy.ops.curve.select_all(action='DESELECT')
|
||||
# too shorten alot of lines
|
||||
# too shorten a lot of lines
|
||||
point = ao.data.splines[0].points
|
||||
# get middle points
|
||||
|
||||
|
@ -165,7 +165,7 @@ class MakeSurfaceCone(Operator, MakeSurfaceHelpers):
|
|||
# select non-middle points and delete them
|
||||
bpy.ops.curve.select_all(action='INVERT')
|
||||
bpy.ops.curve.delete(type='VERT')
|
||||
# declaring this again seems necesary...
|
||||
# declaring this again seems necessary...
|
||||
point = ao.data.splines[0].points
|
||||
# list of points to be in center, and 2 bu'' s higher
|
||||
|
||||
|
@ -200,7 +200,7 @@ class MakeSurfaceCone(Operator, MakeSurfaceHelpers):
|
|||
class MakeSurfaceStar(Operator, MakeSurfaceHelpers):
|
||||
bl_idname = "object.add_surface_star"
|
||||
bl_label = "Add Surface Star"
|
||||
bl_description = "Contruct a Surface Star"
|
||||
bl_description = "Construct a Surface Star"
|
||||
bl_options = {'REGISTER', 'UNDO'}
|
||||
|
||||
def execute(self, context):
|
||||
|
@ -282,7 +282,7 @@ class MakeSurfaceStar(Operator, MakeSurfaceHelpers):
|
|||
class MakeSurfacePlane(Operator, MakeSurfaceHelpers):
|
||||
bl_idname = "object.add_surface_plane"
|
||||
bl_label = "Add Surface Plane"
|
||||
bl_description = "Contruct a Surface Plane"
|
||||
bl_description = "Construct a Surface Plane"
|
||||
bl_options = {'REGISTER', 'UNDO'}
|
||||
|
||||
def execute(self, context):
|
||||
|
|
|
@ -67,7 +67,7 @@ def createIvyGeometry(IVY, growLeaves):
|
|||
# local_ivyBranchSize = IVY.ivyBranchSize # * radius * IVY.ivySize
|
||||
gaussWeight = (1.0, 2.0, 4.0, 7.0, 9.0, 10.0, 9.0, 7.0, 4.0, 2.0, 1.0)
|
||||
|
||||
# Create a new curve and intialise it
|
||||
# Create a new curve and initialise it
|
||||
curve = bpy.data.curves.new("IVY", type='CURVE')
|
||||
curve.dimensions = '3D'
|
||||
curve.bevel_depth = 1
|
||||
|
@ -277,7 +277,7 @@ class Ivy:
|
|||
self.maxAdhesionDistance = maxAdhesionDistance
|
||||
self.maxLength = 0.0
|
||||
|
||||
# Normalize all the weights only on intialisation
|
||||
# Normalize all the weights only on initialisation
|
||||
sums = self.primaryWeight + self.randomWeight + self.adhesionWeight
|
||||
self.primaryWeight /= sums
|
||||
self.randomWeight /= sums
|
||||
|
@ -432,7 +432,7 @@ def collision(ob, pos, new_pos):
|
|||
if ray_result[0]:
|
||||
# Check whether the collision is going into the object
|
||||
if tran_dir.dot(ray_result[2]) < 0.0:
|
||||
# Find projection of the piont onto the plane
|
||||
# Find projection of the point onto the plane
|
||||
p0 = tran_new_pos - (tran_new_pos -
|
||||
ray_result[1]).project(ray_result[2])
|
||||
# Reflect in the plane
|
||||
|
|
|
@ -108,7 +108,7 @@ branchmodes = [("original", "Original", "rotate around each branch"),
|
|||
|
||||
def getPresetpath():
|
||||
"""Support user defined scripts directory
|
||||
Find the first ocurrence of add_curve_sapling/presets in possible script paths
|
||||
Find the first occurrence of add_curve_sapling/presets in possible script paths
|
||||
and return it as preset path"""
|
||||
# presetpath = ""
|
||||
# for p in bpy.utils.script_paths():
|
||||
|
@ -526,7 +526,7 @@ class AddTree(Operator):
|
|||
)
|
||||
autoTaper = BoolProperty(
|
||||
name='Auto Taper',
|
||||
description='Calculate taper automaticly based on branch lengths',
|
||||
description='Calculate taper automatically based on branch lengths',
|
||||
default=True, update=update_tree
|
||||
)
|
||||
taper = FloatVectorProperty(
|
||||
|
@ -804,7 +804,7 @@ class AddTree(Operator):
|
|||
)
|
||||
gustF = FloatProperty(
|
||||
name='Wind Gust Fequency',
|
||||
description='The Fequency of directional movement',
|
||||
description='The Frequency of directional movement',
|
||||
default=0.075, update=update_tree
|
||||
)
|
||||
af1 = FloatProperty(
|
||||
|
|
|
@ -501,7 +501,7 @@ def growSpline(n, stem, numSplit, splitAng, splitAngV, splineList,
|
|||
# If this isn't the last point on a stem, then we need to add it
|
||||
# to the list of stems to continue growing
|
||||
# print(stem.seg != stem.segMax, stem.seg, stem.segMax)
|
||||
# if stem.seg != stem.segMax: # if probs not nessesary
|
||||
# if stem.seg != stem.segMax: # if probs not necessary
|
||||
nstem = stemSpline(
|
||||
newSpline, stem.curv, stem.curvV, stem.vertAtt, stem.seg + 1,
|
||||
stem.segMax, stemL, stem.children,
|
||||
|
@ -1334,7 +1334,7 @@ def perform_pruning(baseSize, baseSplits, childP, cu, currentMax, currentMin, cu
|
|||
numSplit = 0
|
||||
elif (k == 1) and (n == 0):
|
||||
numSplit = baseSplits
|
||||
# allways split at splitHeight
|
||||
# always split at splitHeight
|
||||
elif (n == 0) and (k == int((curveRes[n] - 1) * splitHeight) + 1) and (splitVal > 0):
|
||||
numSplit = 1
|
||||
else:
|
||||
|
@ -1430,7 +1430,7 @@ def perform_pruning(baseSize, baseSplits, childP, cu, currentMax, currentMin, cu
|
|||
return ratio, splineToBone
|
||||
|
||||
|
||||
# calculate taper automaticly
|
||||
# calculate taper automatically
|
||||
def findtaper(length, taper, shape, shapeS, levels, customShape):
|
||||
taperS = []
|
||||
for i, t in enumerate(length):
|
||||
|
@ -1684,7 +1684,7 @@ def addTree(props):
|
|||
kickstart_trunk(addstem, levels, leaves, branches, cu, curve, curveRes,
|
||||
curveV, attractUp, length, lengthV, ratio, ratioPower, resU,
|
||||
scale0, scaleV0, scaleVal, taper, minRadius, rootFlare)
|
||||
# If this isn't the trunk then we may have multiple stem to intialise
|
||||
# If this isn't the trunk then we may have multiple stem to initialise
|
||||
else:
|
||||
# For each of the points defined in the list of stem starting points we need to grow a stem.
|
||||
fabricate_stems(addsplinetobone, addstem, baseSize, branches, childP, cu, curve, curveBack,
|
||||
|
|
|
@ -69,7 +69,7 @@ def unpack_face_list(list_of_tuples):
|
|||
Remove Doubles takes a list on Verts and a list of Faces and
|
||||
removes the doubles, much like Blender does in edit mode.
|
||||
It doesn’t have the range function but it will round the corrdinates
|
||||
and remove verts that are very close togther. The function
|
||||
and remove verts that are very close together. The function
|
||||
is useful because you can perform a "Remove Doubles" with out
|
||||
having to enter Edit Mode. Having to enter edit mode has the
|
||||
disadvantage of not being able to interactively change the properties.
|
||||
|
@ -1482,7 +1482,7 @@ def add_Nylon_Head(OUTSIDE_RADIUS, Z_LOCATION, DIV_COUNT):
|
|||
INNER_HOLE = OUTSIDE_RADIUS - (OUTSIDE_RADIUS * (1.25 / 4.75))
|
||||
EDGE_THICKNESS = (OUTSIDE_RADIUS * (0.4 / 4.75))
|
||||
RAD1 = (OUTSIDE_RADIUS * (0.5 / 4.75))
|
||||
OVER_ALL_HEIGTH = (OUTSIDE_RADIUS * (2.0 / 4.75))
|
||||
OVER_ALL_HEIGHT = (OUTSIDE_RADIUS * (2.0 / 4.75))
|
||||
|
||||
FaceStart = len(verts)
|
||||
|
||||
|
@ -1491,13 +1491,13 @@ def add_Nylon_Head(OUTSIDE_RADIUS, Z_LOCATION, DIV_COUNT):
|
|||
Lowest_Z_Vert = 0
|
||||
|
||||
x = INNER_HOLE
|
||||
z = (Height_Offset - OVER_ALL_HEIGTH) + EDGE_THICKNESS
|
||||
z = (Height_Offset - OVER_ALL_HEIGHT) + EDGE_THICKNESS
|
||||
verts.append([x, 0.0, z])
|
||||
Lowest_Z_Vert = min(Lowest_Z_Vert, z)
|
||||
Row += 1
|
||||
|
||||
x = INNER_HOLE
|
||||
z = (Height_Offset - OVER_ALL_HEIGTH)
|
||||
z = (Height_Offset - OVER_ALL_HEIGHT)
|
||||
verts.append([x, 0.0, z])
|
||||
Lowest_Z_Vert = min(Lowest_Z_Vert, z)
|
||||
Row += 1
|
||||
|
@ -1505,7 +1505,7 @@ def add_Nylon_Head(OUTSIDE_RADIUS, Z_LOCATION, DIV_COUNT):
|
|||
for i in range(180, 80, -10):
|
||||
x = sin(radians(i)) * RAD1
|
||||
z = cos(radians(i)) * RAD1
|
||||
verts.append([(OUTSIDE_RADIUS - RAD1) + x, 0.0, ((Height_Offset - OVER_ALL_HEIGTH) + RAD1) + z])
|
||||
verts.append([(OUTSIDE_RADIUS - RAD1) + x, 0.0, ((Height_Offset - OVER_ALL_HEIGHT) + RAD1) + z])
|
||||
Lowest_Z_Vert = min(Lowest_Z_Vert, z)
|
||||
Row += 1
|
||||
|
||||
|
@ -1530,8 +1530,8 @@ def add_Nylon_Part(OUTSIDE_RADIUS, Z_LOCATION, DIV_COUNT):
|
|||
|
||||
INNER_HOLE = OUTSIDE_RADIUS - (OUTSIDE_RADIUS * (1.5 / 4.75))
|
||||
EDGE_THICKNESS = (OUTSIDE_RADIUS * (0.4 / 4.75))
|
||||
OVER_ALL_HEIGTH = (OUTSIDE_RADIUS * (2.0 / 4.75))
|
||||
PART_THICKNESS = OVER_ALL_HEIGTH - EDGE_THICKNESS
|
||||
OVER_ALL_HEIGHT = (OUTSIDE_RADIUS * (2.0 / 4.75))
|
||||
PART_THICKNESS = OVER_ALL_HEIGHT - EDGE_THICKNESS
|
||||
PART_INNER_HOLE = (OUTSIDE_RADIUS * (2.5 / 4.75))
|
||||
|
||||
FaceStart = len(verts)
|
||||
|
|
|
@ -11,7 +11,7 @@
|
|||
# note above.
|
||||
# if opening width == indent*2 the edge blocks fail (row of blocks cross opening).
|
||||
# if openings overlap fills inverse with blocks - see h/v slots.
|
||||
# Negative grout width creates a pair of phantom blocks, seperated by grout
|
||||
# Negative grout width creates a pair of phantom blocks, separated by grout
|
||||
# width, inside the edges.
|
||||
# if block width variance is 0, and edging is on, right edge blocks create a "vertical seam"
|
||||
|
||||
|
@ -401,7 +401,7 @@ def MakeAKeystone(xpos, width, zpos, ztop, zbtm, thick, bevel, vll=0, FaceExclud
|
|||
faces.append([5, 4, 0, 1])
|
||||
faces.append([6, 5, 1, 2])
|
||||
faces.append([7, 6, 2, 3])
|
||||
# Offset the vertex numbers by the number of verticies already in the list
|
||||
# Offset the vertex numbers by the number of vertices already in the list
|
||||
for i in range(len(faces)):
|
||||
for j in range(len(faces[i])):
|
||||
faces[i][j] += vll
|
||||
|
@ -415,7 +415,7 @@ def circ(offs=0., r=1.):
|
|||
__doc__ = """\
|
||||
offs is the distance perpendicular to the line to the center of the circle
|
||||
r is the radius of the circle
|
||||
circ returns the distance paralell to the line to the center of the circle at the intercept.
|
||||
circ returns the distance parallel to the line to the center of the circle at the intercept.
|
||||
"""
|
||||
offs = abs(offs)
|
||||
if offs > r:
|
||||
|
@ -769,7 +769,7 @@ class rowOb:
|
|||
self.h = float(rowheight)
|
||||
self.EdgeOffset = float(edgeoffset)
|
||||
|
||||
# THIS INITILIZATION IS IMPORTANT! OTHERWISE ALL OBJECTS WILL HAVE THE SAME LISTS!
|
||||
# THIS INITIALIZATION IS IMPORTANT! OTHERWISE ALL OBJECTS WILL HAVE THE SAME LISTS!
|
||||
self.BlocksEdge = []
|
||||
self.RowSegments = []
|
||||
self.BlocksNorm = []
|
||||
|
@ -904,7 +904,7 @@ def sketch():
|
|||
x['v'], x['t'], x['vl'], x['tl'], x['b']))
|
||||
else:
|
||||
boundlist.append(opening(x['x'], x['z'], x['w'], x['h'], x['v'], x['t'], x['vl'], x['tl'], x['b']))
|
||||
# check for overlaping edges?
|
||||
# check for overlapping edges?
|
||||
|
||||
return boundlist
|
||||
|
||||
|
@ -946,7 +946,7 @@ def wedgeBlocks(row, opening, leftPos, rightPos, edgeBinary, r1):
|
|||
# Wedges are on btm = blank, off, blank, off
|
||||
ThisBlockOffsets = [[0, 0, LeftVertOffset]] * 2 + [[0] * 3] * 2 + [[0, 0, RightVertOffset]] * 2
|
||||
|
||||
# Instert or append "blank" for top or bottom wedges.
|
||||
# Insert or append "blank" for top or bottom wedges.
|
||||
if edgeBinary == 1:
|
||||
ThisBlockOffsets = ThisBlockOffsets + [[0] * 3] * 2
|
||||
else:
|
||||
|
@ -1086,7 +1086,7 @@ def rowProcessing(row, Thesketch, WallBoundaries):
|
|||
LDiff = LBtm - LTop
|
||||
RDiff = RTop - RBtm
|
||||
|
||||
# which is furthur out on each side, top or bottom?
|
||||
# which is further out on each side, top or bottom?
|
||||
if LDiff > 0:
|
||||
LNerEdge = LBtm # the nearer edge left
|
||||
LEB = 1 # Left Edge Boolean, set to 1 if furthest edge is top, -1 if it is bottom
|
||||
|
@ -1180,7 +1180,7 @@ def rowProcessing(row, Thesketch, WallBoundaries):
|
|||
# this row is just two blocks! Left block, then right block
|
||||
# div is the x position of the dividing point between the two bricks
|
||||
div = InnerMid + (rndd() * settings['wv']) / r1
|
||||
# set the grout distance, since we need grout seperation between the blocks
|
||||
# set the grout distance, since we need grout separation between the blocks
|
||||
grt = (settings['g'] + rndc() * settings['gv']) / r1
|
||||
# set the x position and width for the left block
|
||||
x = (div + LNerEdge) / 2 - grt / 4
|
||||
|
@ -1330,7 +1330,7 @@ def archGeneration(hole, vlist, flist, sideSign):
|
|||
example, Upper arch:
|
||||
archGeneration(hole, vlist, flist, 1)
|
||||
hole is the opening object that the arch is for
|
||||
add the verticies to vlist
|
||||
add the vertices to vlist
|
||||
add the faces to flist
|
||||
sideSign is + or - 1, for the top or bottom arch. Other values may cause errors.
|
||||
"""
|
||||
|
@ -1410,7 +1410,7 @@ def archGeneration(hole, vlist, flist, sideSign):
|
|||
BtmHt = - (hole.btm() - MidZ) - Grout
|
||||
TopHt = nearCorner
|
||||
|
||||
# set the amout to bevel the keystone
|
||||
# set the amount to bevel the keystone
|
||||
keystoneBevel = (bevHt - v) * sideSign
|
||||
if Wdth >= settings['hm']:
|
||||
avlist, aflist = MakeAKeystone(x, Wdth, MidZ, TopHt, BtmHt, Dpth, keystoneBevel, len(vlist))
|
||||
|
@ -1572,7 +1572,7 @@ def build(Aplan):
|
|||
else:
|
||||
r1 = 1
|
||||
|
||||
Tollerance = settings['g'] / r1
|
||||
Tolerance = settings['g'] / r1
|
||||
idxThis = len(rows[rowidx].BlocksNorm[:]) - 1
|
||||
idxThat = len(rows[rowidx + 1].BlocksNorm[:]) - 1
|
||||
|
||||
|
@ -1588,7 +1588,7 @@ def build(Aplan):
|
|||
cx, cz, cw, ch, cd = blockThis[:5]
|
||||
ox, oz, ow, oh, od = blockThat[:5]
|
||||
|
||||
if (abs(cw - ow) < Tollerance) and (abs(cx - ox) < Tollerance):
|
||||
if (abs(cw - ow) < Tolerance) and (abs(cx - ox) < Tolerance):
|
||||
if cw > ow:
|
||||
BlockW = ow
|
||||
else:
|
||||
|
@ -1781,7 +1781,7 @@ def build(Aplan):
|
|||
def createWall(radial, curve, openings, mergeBlox, shelf, shelfSide,
|
||||
steps, stepDir, stepBare, stepSide):
|
||||
__doc__ = """\
|
||||
Call all the funcitons you need to make a wall, return the verts and faces.
|
||||
Call all the functions you need to make a wall, return the verts and faces.
|
||||
"""
|
||||
global radialized
|
||||
global slope
|
||||
|
|
|
@ -61,7 +61,7 @@ class add_mesh_wallb(Operator):
|
|||
bl_description = "Create a block (masonry) wall mesh"
|
||||
bl_options = {'REGISTER', 'UNDO'}
|
||||
|
||||
# UI items - API for properties - User accessable variables...
|
||||
# UI items - API for properties - User accessible variables...
|
||||
# not all options are via UI, and some operations just don't work yet
|
||||
|
||||
# only create object when True
|
||||
|
|
|
@ -186,7 +186,7 @@ def create_beam(sRef):
|
|||
def beamSlant(sRef, outV, inV):
|
||||
bTaper = 100 - sRef.edgeA
|
||||
|
||||
# calcuate variance & adjust vertex
|
||||
# calculate variance & adjust vertex
|
||||
deltaV = ((inV - outV) / 100)
|
||||
adVert = outV + (deltaV * bTaper)
|
||||
|
||||
|
|
|
@ -461,7 +461,7 @@ def add_spokes(teethNum, radius, De, base, width=1, conangle=0, rack=0,
|
|||
# crown ... Inward pointing extend of crown teeth
|
||||
#
|
||||
# @todo: Fix teethNum. Some numbers are not possible yet
|
||||
# @todo: Create start & end geoemtry (closing faces)
|
||||
# @todo: Create start & end geometry (closing faces)
|
||||
|
||||
def add_worm(teethNum, rowNum, radius, Ad, De, p_angle,
|
||||
width=1, skew=radians(11.25), crown=0.0):
|
||||
|
|
|
@ -27,9 +27,9 @@ def addBrilliant(context, s, table_w, crown_h, girdle_t, pavi_d, bezel_f,
|
|||
# table_w # table width default: 0.530
|
||||
# crown_h # crown height default: 0.162
|
||||
# girdle_t # girdle thickness default: 0.017
|
||||
# pavi_d # pavillion depth default: 0.431
|
||||
# pavi_d # pavilion depth default: 0.431
|
||||
# bezel_f # bezel factor default: 0.250
|
||||
# pavi_f # pavillion factor default: 0.400
|
||||
# pavi_f # pavilion factor default: 0.400
|
||||
# culet # culet size default: 0.000
|
||||
# girdle_real # type of girdle flat/real default: True
|
||||
# g_real_smooth # smooth or flat shading default: False
|
||||
|
@ -197,7 +197,7 @@ def addBrilliant(context, s, table_w, crown_h, girdle_t, pavi_d, bezel_f,
|
|||
else:
|
||||
va(culet / ca, pavi_d * (-2), 2 * ang, ang, int(s / 2))
|
||||
|
||||
# make pavillion facet face
|
||||
# make pavilion facet face
|
||||
l5 = len(Verts) # 4*s / 10*s //if !culet: 3.5*s+1 / 9.5*s+1
|
||||
for i in range(l5):
|
||||
if i > 0 and i < s - 1 and i % 2 == 0:
|
||||
|
@ -266,7 +266,7 @@ def addBrilliant(context, s, table_w, crown_h, girdle_t, pavi_d, bezel_f,
|
|||
for i, p in enumerate(dp):
|
||||
pls.extend(p.vertices) # list all verts of girdle
|
||||
|
||||
for i, e in enumerate(obj.data.edges): # select egdes to mark sharp
|
||||
for i, e in enumerate(obj.data.edges): # select edges to mark sharp
|
||||
if e.vertices[0] in pls and e.vertices[1] in pls and abs(
|
||||
ov[e.vertices[0]].co.x - ov[e.vertices[1]].co.x):
|
||||
obj.data.edges[i].select = True
|
||||
|
@ -301,7 +301,7 @@ def addBrilliant(context, s, table_w, crown_h, girdle_t, pavi_d, bezel_f,
|
|||
class MESH_OT_primitive_brilliant_add(Operator):
|
||||
bl_idname = "mesh.primitive_brilliant_add"
|
||||
bl_label = "Custom Brilliant"
|
||||
bl_description = "Contruct a custom brilliant mesh"
|
||||
bl_description = "Construct a custom brilliant mesh"
|
||||
bl_options = {'REGISTER', 'UNDO', 'PRESET'}
|
||||
|
||||
# set user options
|
||||
|
@ -324,7 +324,7 @@ class MESH_OT_primitive_brilliant_add(Operator):
|
|||
)
|
||||
crown_h = FloatProperty(
|
||||
name="Crown height",
|
||||
description="Heigth of crown",
|
||||
description="Height of crown",
|
||||
min=0.0,
|
||||
max=1.0,
|
||||
default=0.162,
|
||||
|
@ -350,7 +350,7 @@ class MESH_OT_primitive_brilliant_add(Operator):
|
|||
)
|
||||
pavi_d = FloatProperty(
|
||||
name="Pavilion depth",
|
||||
description="Height of pavillion",
|
||||
description="Height of pavilion",
|
||||
min=0.0,
|
||||
max=1.0,
|
||||
default=0.431,
|
||||
|
@ -366,7 +366,7 @@ class MESH_OT_primitive_brilliant_add(Operator):
|
|||
)
|
||||
pavi_f = FloatProperty(
|
||||
name="Lower facet factor",
|
||||
description="Determines the form of pavillion and lower girdle facets",
|
||||
description="Determines the form of pavilion and lower girdle facets",
|
||||
min=0.001,
|
||||
max=1.0,
|
||||
default=0.400,
|
||||
|
@ -382,7 +382,7 @@ class MESH_OT_primitive_brilliant_add(Operator):
|
|||
)
|
||||
keep_lga = BoolProperty(
|
||||
name="Retain lower angle",
|
||||
description="If culet > 0, retains angle of pavillion facets",
|
||||
description="If culet > 0, retains angle of pavilion facets",
|
||||
default=False
|
||||
)
|
||||
|
||||
|
|
|
@ -246,7 +246,7 @@ def createSolid(plato, vtrunc, etrunc, dual, snub):
|
|||
fvOutput[vData[x][2][j]][index - 1]])
|
||||
feOutput.append([fvOutput[x][j - 1], fvOutput[vData[x][2][j]][index],
|
||||
fvOutput[vData[x][2][j]][index - 1]])
|
||||
# special rules fro birectified mesh (v1 todo: done)
|
||||
# special rules for birectified mesh (v1 todo: done)
|
||||
elif vtrunc == 0.5:
|
||||
for j in range(len(i) - 1):
|
||||
if x < vData[x][2][j]: # use current vert, since other one has not passed yet
|
||||
|
@ -348,7 +348,7 @@ class Solids(bpy.types.Operator):
|
|||
)
|
||||
vTrunc = FloatProperty(
|
||||
name="Vertex Truncation",
|
||||
description="Ammount of vertex truncation",
|
||||
description="Amount of vertex truncation",
|
||||
min=0.0,
|
||||
soft_min=0.0,
|
||||
max=2.0,
|
||||
|
@ -359,7 +359,7 @@ class Solids(bpy.types.Operator):
|
|||
)
|
||||
eTrunc = FloatProperty(
|
||||
name="Edge Truncation",
|
||||
description="Ammount of edge truncation",
|
||||
description="Amount of edge truncation",
|
||||
min=0.0,
|
||||
soft_min=0.0,
|
||||
max=1.0,
|
||||
|
|
|
@ -199,8 +199,8 @@ def transpose(rowsbycols):
|
|||
def make_teapot(enumname, resolution):
|
||||
filenames = [None, teapot, teaspoon]
|
||||
try:
|
||||
indexs = int(enumname)
|
||||
filename = filenames[indexs]
|
||||
indexes = int(enumname)
|
||||
filename = filenames[indexes]
|
||||
except:
|
||||
print("Add Teapot Error: EnumProperty could not be set")
|
||||
filename = filenames[1]
|
||||
|
|
|
@ -68,9 +68,9 @@ class MakeTriangle(Operator):
|
|||
]
|
||||
triangleFaceList = [
|
||||
('DEFAULT', "Normal", "1 Tri(angle) face", 0),
|
||||
('TRIANGLES', "3 Tri faces", "4 Verticies & 3 Tri(angle) faces", 1),
|
||||
('QUADS', "3 Quad faces", "7 Verticies & 3 Quad faces", 2),
|
||||
('SAFEQUADS', "6 Quad faces", "12 Verticies & 6 Quad faces", 3)
|
||||
('TRIANGLES', "3 Tri faces", "4 Vertices & 3 Tri(angle) faces", 1),
|
||||
('QUADS', "3 Quad faces", "7 Vertices & 3 Quad faces", 2),
|
||||
('SAFEQUADS', "6 Quad faces", "12 Vertices & 6 Quad faces", 3)
|
||||
]
|
||||
|
||||
# add definitions for some manipulation buttons
|
||||
|
@ -255,7 +255,7 @@ class MakeTriangle(Operator):
|
|||
# a triangle consists of 3 points: A, B, C
|
||||
# a 'safer' subdividable triangle consists of 4 points: A, B, C, D
|
||||
# a subdivide friendly triangle consists of 7 points: A, B, C, D, AB, AC, BC
|
||||
# a truely subdivide friendly triangle consists of (3 x 4 = )12 points:
|
||||
# a truly subdivide friendly triangle consists of (3 x 4 = )12 points:
|
||||
# A, B, C, D, E, BC, AAB, AAC, BBA, BBC, BCC, CCA
|
||||
|
||||
BasicShapeCreated = False
|
||||
|
@ -263,7 +263,7 @@ class MakeTriangle(Operator):
|
|||
go = 0
|
||||
|
||||
#
|
||||
# call the functions for creating the triangles and test if successfull
|
||||
# call the functions for creating the triangles and test if successful
|
||||
#
|
||||
BasicShapeCreated = self.drawBasicTriangleShape()
|
||||
if (BasicShapeCreated):
|
||||
|
|
|
@ -1117,7 +1117,7 @@ class GenerateGeodesicDome(Operator):
|
|||
basegeodesic.makegeodesic()
|
||||
basegeodesic.connectivity()
|
||||
mesh = vefm_271.mesh()
|
||||
vefm_271.finalfill(basegeodesic, mesh) # always! for hexifiy etc. necessarry!!!
|
||||
vefm_271.finalfill(basegeodesic, mesh) # always! for hexifiy etc. necessary!!!
|
||||
vefm_271.vefm_add_object(mesh)
|
||||
last_generated_object = context.active_object
|
||||
last_generated_object.location = (0, 0, 0)
|
||||
|
@ -1319,7 +1319,7 @@ class GenerateGeodesicDome(Operator):
|
|||
message = "***OK***\nParameters saved in\n" + filename
|
||||
print(message)
|
||||
except:
|
||||
message = "***ERRROR***\n" + "Writing " + filename + "\nis not possible"
|
||||
message = "***ERROR***\n" + "Writing " + filename + "\nis not possible"
|
||||
# bpy.context.scene.instant_filenames = filenames
|
||||
|
||||
except:
|
||||
|
@ -1348,7 +1348,7 @@ class GenerateGeodesicDome(Operator):
|
|||
message = "***OK***\nparameters read from\n" + filename
|
||||
print(message)
|
||||
except:
|
||||
message = "***ERRROR***\n" + "Writing " + filename + "\nnot possible"
|
||||
message = "***ERROR***\n" + "Writing " + filename + "\nnot possible"
|
||||
# bpy.context.scene.instant_filenames = filenames
|
||||
except:
|
||||
message = "***ERROR***\n Contakt PKHG,\nsomething went wrong reading params happened"
|
||||
|
|
|
@ -72,7 +72,7 @@ class vertex:
|
|||
self.normal = average(target).centroid()
|
||||
self.normal.findlength()
|
||||
if self.length == 0:
|
||||
print("******ERROR*** lenght zero in findnormal, j = (0,1,0) replcaced")
|
||||
print("******ERROR*** length zero in findnormal, j = (0,1,0) replaced")
|
||||
self.normal = vertex((0, 1, 0))
|
||||
self.normal.normalize()
|
||||
|
||||
|
@ -706,7 +706,7 @@ class mesh:
|
|||
class facetype(mesh):
|
||||
def __init__(self, basegeodesic, parameters, width, height, relative):
|
||||
mesh.__init__(self)
|
||||
self.detatch = parameters[0]
|
||||
self.detach = parameters[0]
|
||||
self.endtype = parameters[1]
|
||||
self.coords = parameters[2]
|
||||
self.base = basegeodesic
|
||||
|
@ -750,7 +750,7 @@ class facetype(mesh):
|
|||
return length
|
||||
|
||||
def createfaces(self):
|
||||
if not self.detatch:
|
||||
if not self.detach:
|
||||
for point in self.base.verts:
|
||||
self.verts.append(point)
|
||||
if self.endtype == 4:
|
||||
|
@ -768,7 +768,7 @@ class facetype(mesh):
|
|||
grid = []
|
||||
candidate.dospokes()
|
||||
|
||||
if not self.detatch:
|
||||
if not self.detach:
|
||||
line = []
|
||||
for vert in candidate.vertices:
|
||||
line.append(vert)
|
||||
|
@ -1100,10 +1100,10 @@ class hub(mesh):
|
|||
|
||||
# ???PKHG TODO Nmesh used yet wrong!
|
||||
def finalfill(source, target):
|
||||
if source == target: # PKHG: otherewise >infinite< loop
|
||||
if source == target: # PKHG: otherwise >infinite< loop
|
||||
print("\n***WARNING*** vefm_271.finalfill L1104 source == target empty mesh used")
|
||||
target = mesh()
|
||||
# PKHG_??? maybe renumverting and checkkin faces wiht >=4 5 vertices?
|
||||
# PKHG_??? maybe renumverting and checking faces with >=4 5 vertices?
|
||||
count = 0
|
||||
|
||||
for point in source.verts:
|
||||
|
|
|
@ -461,7 +461,7 @@ def discombobulate(minHeight, maxHeight, minTaper, maxTaper, sf1, sf2, sf3, sf4,
|
|||
to_scale = bpy.context.active_object.scale
|
||||
to_rotate = bpy.context.active_object.rotation_euler
|
||||
|
||||
# First, we collect all the informations we will need from the previous mesh
|
||||
# First, we collect all the information we will need from the previous mesh
|
||||
obverts = bpy.context.active_object.data.vertices
|
||||
obpolygons = bpy.context.active_object.data.polygons
|
||||
verts = []
|
||||
|
|
|
@ -900,7 +900,7 @@ class AntLandscapePropertiesGroup(bpy.types.PropertyGroup):
|
|||
items = [
|
||||
("0", "None", "No strata", 0),
|
||||
("1", "Smooth", "Smooth transitions", 1),
|
||||
("2", "Sharp Sub", "Sharp substract transitions", 2),
|
||||
("2", "Sharp Sub", "Sharp subtract transitions", 2),
|
||||
("3", "Sharp Add", "Sharp add transitions", 3),
|
||||
("4", "Quantize", "Quantize", 4),
|
||||
("5", "Quantize Mix", "Quantize mixed", 5)]
|
||||
|
|
|
@ -538,7 +538,7 @@ class AntAddLandscape(bpy.types.Operator):
|
|||
items = [
|
||||
("0", "None", "No strata", 0),
|
||||
("1", "Smooth", "Smooth transitions", 1),
|
||||
("2", "Sharp Sub", "Sharp substract transitions", 2),
|
||||
("2", "Sharp Sub", "Sharp subtract transitions", 2),
|
||||
("3", "Sharp Add", "Sharp add transitions", 3),
|
||||
("4", "Quantize", "Quantize", 4),
|
||||
("5", "Quantize Mix", "Quantize mixed", 5)]
|
||||
|
|
|
@ -145,7 +145,7 @@ class Grid:
|
|||
@staticmethod
|
||||
def fromRaw(filename):
|
||||
"""initialize a grid from a Blender .raw file.
|
||||
currenly suports just rectangular grids of all triangles
|
||||
currently supports just rectangular grids of all triangles
|
||||
"""
|
||||
g = Grid.fromFile(filename)
|
||||
# we assume tris and an axis aligned grid
|
||||
|
@ -156,7 +156,7 @@ class Grid:
|
|||
|
||||
def _sort(self, expfact):
|
||||
# keep unique vertices only by creating a set and sort first on x then on y coordinate
|
||||
# using rather slow python sort but couldn;t wrap my head around np.lexsort
|
||||
# using rather slow python sort but couldn't wrap my head around np.lexsort
|
||||
verts = sorted(list({ tuple(t) for t in self.center[::] }))
|
||||
x = set(c[0] for c in verts)
|
||||
y = set(c[1] for c in verts)
|
||||
|
@ -461,7 +461,7 @@ class Grid:
|
|||
|
||||
def analyze(self):
|
||||
self.neighborgrid()
|
||||
# just looking at up and left to avoid needless doubel calculations
|
||||
# just looking at up and left to avoid needless double calculations
|
||||
slopes=np.concatenate((np.abs(self.left - self.center),np.abs(self.up - self.center)))
|
||||
return '\n'.join(["%-15s: %.3f"%t for t in [
|
||||
('height average', np.average(self.center)),
|
||||
|
@ -542,7 +542,7 @@ if __name__ == "__main__":
|
|||
parser.add_argument('-Gm', dest='gridmesa', type=float, default=0, help='Add mesa with given height')
|
||||
parser.add_argument('-Gr', dest='gridrandom', type=float, default=0, help='Add random values between 0 and given value')
|
||||
parser.add_argument('-m', dest='threads', type=int, default=1, help='number of threads to use')
|
||||
parser.add_argument('-u', action='store_true', dest='unittest', default=False, help='perfom unittests')
|
||||
parser.add_argument('-u', action='store_true', dest='unittest', default=False, help='perform unittests')
|
||||
parser.add_argument('-a', action='store_true', dest='analyze', default=False, help='show some statistics of input and output meshes')
|
||||
parser.add_argument('-d', action='store_true', dest='dump', default=False, help='show sediment and water meshes at end of run')
|
||||
parser.add_argument('-n', action='store_true', dest='usenumexpr', default=False, help='use numexpr optimizations')
|
||||
|
|
|
@ -536,7 +536,7 @@ class AntMeshDisplace(bpy.types.Operator):
|
|||
items = [
|
||||
("0", "None", "No strata", 0),
|
||||
("1", "Smooth", "Smooth transitions", 1),
|
||||
("2", "Sharp Sub", "Sharp substract transitions", 2),
|
||||
("2", "Sharp Sub", "Sharp subtract transitions", 2),
|
||||
("3", "Sharp Add", "Sharp add transitions", 3),
|
||||
("4", "Quantize", "Quantize", 4),
|
||||
("5", "Quantize Mix", "Quantize mixed", 5)]
|
||||
|
|
|
@ -1100,7 +1100,7 @@ def roller_side():
|
|||
# --------------------------------------------------------------------
|
||||
# Set curve cycle
|
||||
#
|
||||
# myObject: Curve obejct
|
||||
# myObject: Curve object
|
||||
# --------------------------------------------------------------------
|
||||
def set_curve_cycle(myobject):
|
||||
bpy.context.scene.objects.active = myobject
|
||||
|
|
|
@ -517,7 +517,7 @@ class ArchimeshMainPanel(Panel):
|
|||
class AchmRunHintDisplayButton(Operator):
|
||||
bl_idname = "archimesh.runopenglbutton"
|
||||
bl_label = "Display hint data manager"
|
||||
bl_description = "Display aditional information in the viewport"
|
||||
bl_description = "Display additional information in the viewport"
|
||||
bl_category = 'Archimesh'
|
||||
|
||||
_handle = None # keep function handler
|
||||
|
|
|
@ -1159,7 +1159,7 @@ def add_shell(selobject, objname, rp):
|
|||
# Project point using face normals
|
||||
#
|
||||
# m: Magnitud
|
||||
# pf: Comparision face +/-
|
||||
# pf: Comparison face +/-
|
||||
# ---------------------------------------------------------
|
||||
def project_point(idx, point, normals, m, pf):
|
||||
v1 = Vector(normals[idx])
|
||||
|
|
|
@ -1392,7 +1392,7 @@ def get_angle(p1, p2):
|
|||
# Point b: (x,z)
|
||||
# Point c: (x,z)
|
||||
# Return:
|
||||
# x, y: center poistion
|
||||
# x, y: center position
|
||||
# r: radio
|
||||
# ang: angle
|
||||
# ---------------------------------------------------------
|
||||
|
|
|
@ -674,7 +674,7 @@ class Arc(Circle):
|
|||
|
||||
def tangeant(self, t, length):
|
||||
"""
|
||||
Tangeant line so we are able to chain Circle and lines
|
||||
Tangent line so we are able to chain Circle and lines
|
||||
Beware, counterpart on Line does return an Arc !
|
||||
"""
|
||||
a = self.a0 + t * self.da
|
||||
|
@ -688,7 +688,7 @@ class Arc(Circle):
|
|||
|
||||
def tangeant_unit_vector(self, t):
|
||||
"""
|
||||
Return Tangeant vector of length 1
|
||||
Return Tangent vector of length 1
|
||||
"""
|
||||
a = self.a0 + t * self.da
|
||||
ca = cos(a)
|
||||
|
@ -700,7 +700,7 @@ class Arc(Circle):
|
|||
|
||||
def straight(self, length, t=1):
|
||||
"""
|
||||
Return a tangeant Line
|
||||
Return a tangent Line
|
||||
Counterpart on Line also return a Line
|
||||
"""
|
||||
return self.tangeant(t, length)
|
||||
|
@ -721,7 +721,7 @@ class Arc(Circle):
|
|||
|
||||
def rotate(self, a):
|
||||
"""
|
||||
Rotate center so we rotate ccw arround p0
|
||||
Rotate center so we rotate ccw around p0
|
||||
"""
|
||||
ca = cos(a)
|
||||
sa = sin(a)
|
||||
|
@ -941,7 +941,7 @@ class Line3d(Line):
|
|||
def sized_normal(self, t, size):
|
||||
"""
|
||||
3d Line perpendicular on plane defined by z_axis and of given size
|
||||
positionned at t in current line
|
||||
positioned at t in current line
|
||||
lie on the right side
|
||||
p1
|
||||
|--x
|
||||
|
|
|
@ -226,9 +226,9 @@ class ArchipackBoolManager():
|
|||
remove holes not found in childs
|
||||
|
||||
robust -> mixed:
|
||||
there is only one object taged with "archipack_robusthole"
|
||||
there is only one object tagged with "archipack_robusthole"
|
||||
interactive -> mixed:
|
||||
many modifisers on wall taged with "archipack_hole"
|
||||
many modifisers on wall tagged with "archipack_hole"
|
||||
keep objects
|
||||
"""
|
||||
existing = []
|
||||
|
|
|
@ -290,7 +290,7 @@ class CutAblePolygon():
|
|||
# sort by seg and param t of seg
|
||||
inter.sort()
|
||||
|
||||
# reorder so we realy start from s_start
|
||||
# reorder so we really start from s_start
|
||||
for i, it in enumerate(inter):
|
||||
if it[0] >= s_start:
|
||||
order = i
|
||||
|
@ -366,7 +366,7 @@ class CutAblePolygon():
|
|||
def slice(self, cutter):
|
||||
"""
|
||||
Simple 2d Boolean between boundary and roof part
|
||||
Dosen't handle slicing roof into multiple parts
|
||||
Doesn't handle slicing roof into multiple parts
|
||||
|
||||
4 cases:
|
||||
1 pitch has point in boundary -> start from this point
|
||||
|
|
|
@ -1808,7 +1808,7 @@ class ARCHIPACK_OT_door_draw(ArchpackDrawTool, Operator):
|
|||
('LEFTCLICK, RET, SPACE, ENTER', 'Create a door'),
|
||||
('BACKSPACE, CTRL+Z', 'undo last'),
|
||||
('C', 'Choose another door'),
|
||||
('SHIFT', 'Make independant copy'),
|
||||
('SHIFT', 'Make independent copy'),
|
||||
('RIGHTCLICK or ESC', 'exit')
|
||||
])
|
||||
self.feedback.enable()
|
||||
|
|
|
@ -157,7 +157,7 @@ class FenceGenerator():
|
|||
def param_t(self, angle_limit, post_spacing):
|
||||
"""
|
||||
setup corners and fences dz
|
||||
compute index of fences wich belong to each group of fences between corners
|
||||
compute index of fences which belong to each group of fences between corners
|
||||
compute t of each fence
|
||||
"""
|
||||
# segments are group of parts separated by limit angle
|
||||
|
|
|
@ -1571,7 +1571,7 @@ class archipack_floor_cutter_segment(ArchipackCutterPart, PropertyGroup):
|
|||
items=(
|
||||
('DEFAULT', 'Side', 'Side with rake', 0),
|
||||
('BOTTOM', 'Bottom', 'Bottom with gutter', 1),
|
||||
('LINK', 'Side link', 'Side witout decoration', 2),
|
||||
('LINK', 'Side link', 'Side without decoration', 2),
|
||||
('AXIS', 'Top', 'Top part with hip and beam', 3)
|
||||
# ('LINK_VALLEY', 'Side valley', 'Side with valley', 3),
|
||||
# ('LINK_HIP', 'Side hip', 'Side with hip', 4)
|
||||
|
|
|
@ -391,7 +391,7 @@ class GlLine(GlBaseLine):
|
|||
def sized_normal(self, t, size):
|
||||
"""
|
||||
GlLine perpendicular on plane defined by z_axis and of given size
|
||||
positionned at t in current line
|
||||
positioned at t in current line
|
||||
lie on the right side
|
||||
p1
|
||||
|--x
|
||||
|
|
|
@ -91,7 +91,7 @@ class Keymaps:
|
|||
|
||||
def dump_keys(self, context, filename="c:\\tmp\\keymap.txt"):
|
||||
"""
|
||||
Utility for developpers :
|
||||
Utility for developers :
|
||||
Dump all keymaps to a file
|
||||
filename : string a file path to dump keymaps
|
||||
"""
|
||||
|
|
|
@ -48,12 +48,12 @@ from .archipack_gl import (
|
|||
# as transform.translate in use to allow snap
|
||||
# does catch all events.
|
||||
# This however has a wanted side effect:
|
||||
# the manipulator take precedence over allready running
|
||||
# the manipulator take precedence over already running
|
||||
# ones, and prevent select mode to start.
|
||||
#
|
||||
# TODO:
|
||||
# Other manipulators should use same technique to take
|
||||
# precedence over allready running ones when active
|
||||
# precedence over already running ones when active
|
||||
#
|
||||
# NOTE:
|
||||
# Select mode does suffer from this stack effect:
|
||||
|
@ -178,7 +178,7 @@ def empty_stack():
|
|||
def add_manipulable(key, manipulable):
|
||||
"""
|
||||
add a ArchipackActiveManip into the stack
|
||||
if not allready present
|
||||
if not already present
|
||||
setup reference to manipulable
|
||||
return manipulators stack
|
||||
"""
|
||||
|
@ -263,7 +263,7 @@ class Manipulator():
|
|||
else:
|
||||
print("Manipulator.exit() handle not found %s" % (type(self).__name__))
|
||||
|
||||
# Mouse event handlers, MUST be overriden
|
||||
# Mouse event handlers, MUST be overridden
|
||||
def mouse_press(self, context, event):
|
||||
"""
|
||||
Manipulators must implement
|
||||
|
@ -288,7 +288,7 @@ class Manipulator():
|
|||
"""
|
||||
raise NotImplementedError
|
||||
|
||||
# Keyboard event handlers, MAY be overriden
|
||||
# Keyboard event handlers, MAY be overridden
|
||||
def keyboard_done(self, context, event, value):
|
||||
"""
|
||||
Manipulators may implement
|
||||
|
@ -332,8 +332,8 @@ class Manipulator():
|
|||
"""
|
||||
return False
|
||||
|
||||
# Internal, do not override unless you realy
|
||||
# realy realy deeply know what you are doing
|
||||
# Internal, do not override unless you really
|
||||
# really really deeply know what you are doing
|
||||
def keyboard_eval(self, context, event):
|
||||
"""
|
||||
evaluate keyboard entry while typing
|
||||
|
@ -1950,7 +1950,7 @@ manipulators_class_lookup = {}
|
|||
|
||||
def register_manipulator(type_key, manipulator_class):
|
||||
if type_key in manipulators_class_lookup.keys():
|
||||
raise RuntimeError("Manipulator of type {} allready exists, unable to override".format(type_key))
|
||||
raise RuntimeError("Manipulator of type {} already exists, unable to override".format(type_key))
|
||||
manipulators_class_lookup[type_key] = manipulator_class
|
||||
|
||||
|
||||
|
@ -1966,9 +1966,9 @@ class archipack_manipulator(PropertyGroup):
|
|||
type_key = StringProperty(default='SIZE')
|
||||
|
||||
# How 3d points are stored in manipulators ?
|
||||
# SIZE = 2 absolute positionned and a scaling vector
|
||||
# RADIUS = 1 absolute positionned (center) and 2 relatives (sides)
|
||||
# POLYGON = 2 absolute positionned and a relative vector (for rect polygons)
|
||||
# SIZE = 2 absolute positioned and a scaling vector
|
||||
# RADIUS = 1 absolute positioned (center) and 2 relatives (sides)
|
||||
# POLYGON = 2 absolute positioned and a relative vector (for rect polygons)
|
||||
|
||||
pts_mode = StringProperty(default='SIZE')
|
||||
prop1_name = StringProperty()
|
||||
|
@ -1984,7 +1984,7 @@ class archipack_manipulator(PropertyGroup):
|
|||
"""
|
||||
set 3d location of gl points (in object space)
|
||||
pts: array of 3 vectors 3d
|
||||
normal: optionnal vector 3d default to Z axis
|
||||
normal: optional vector 3d default to Z axis
|
||||
"""
|
||||
pts = [Vector(p) for p in pts]
|
||||
self.p0, self.p1, self.p2 = pts
|
||||
|
@ -2031,7 +2031,7 @@ class archipack_manipulator(PropertyGroup):
|
|||
if self.type_key not in manipulators_class_lookup.keys() or \
|
||||
not manipulators_class_lookup[self.type_key].poll(context):
|
||||
# RuntimeError is overkill but may be enabled for debug purposes
|
||||
# Silentely ignore allow skipping manipulators if / when deps as not meet
|
||||
# Silently ignore allow skipping manipulators if / when deps as not meet
|
||||
# manip stack will simply be filled with None objects
|
||||
# raise RuntimeError("Manipulator of type {} not found".format(self.type_key))
|
||||
return None
|
||||
|
@ -2255,9 +2255,9 @@ class Manipulable():
|
|||
def manipulable_modal(self, context, event):
|
||||
"""
|
||||
call in operator modal()
|
||||
should not be overriden
|
||||
should not be overridden
|
||||
as it provide all needed
|
||||
functionnality out of the box
|
||||
functionality out of the box
|
||||
"""
|
||||
# setup again when manipulators type change
|
||||
if self.manipulable_refresh:
|
||||
|
|
|
@ -273,7 +273,7 @@ class MaterialSetManager():
|
|||
material_sets[s_key] = []
|
||||
material_sets[s_key].append(mat_name.strip())
|
||||
except:
|
||||
print("Archipack: An error occured while loading {}".format(filename))
|
||||
print("Archipack: An error occurred while loading {}".format(filename))
|
||||
pass
|
||||
finally:
|
||||
f.close()
|
||||
|
@ -298,7 +298,7 @@ class MaterialSetManager():
|
|||
f = open(filename, 'w')
|
||||
f.writelines(lines)
|
||||
except:
|
||||
print("Archipack: An error occured while saving {}".format(filename))
|
||||
print("Archipack: An error occurred while saving {}".format(filename))
|
||||
pass
|
||||
finally:
|
||||
f.close()
|
||||
|
|
|
@ -57,7 +57,7 @@ class ArchipackObject():
|
|||
Filter object with this class in data
|
||||
return
|
||||
True when object contains this datablock
|
||||
False otherwhise
|
||||
False otherwise
|
||||
usage:
|
||||
class_name.filter(object) from outside world
|
||||
self.__class__.filter(object) from instance
|
||||
|
@ -171,7 +171,7 @@ class ArchipackCreateTool():
|
|||
d.auto_update = True
|
||||
|
||||
def add_material(self, o, material='DEFAULT', category=None):
|
||||
# skip if preset allready add material
|
||||
# skip if preset already add material
|
||||
if "archipack_material" in o:
|
||||
return
|
||||
try:
|
||||
|
|
|
@ -70,7 +70,7 @@ class archipack_reference_point(PropertyGroup):
|
|||
Filter object with this class in data
|
||||
return
|
||||
True when object contains this datablock
|
||||
False otherwhise
|
||||
False otherwise
|
||||
usage:
|
||||
class_name.filter(object) from outside world
|
||||
self.__class__.filter(object) from instance
|
||||
|
|
|
@ -82,7 +82,7 @@ class ARCHIPACK_OT_render_thumbs(Operator):
|
|||
Copy factory presets to writeable presets folder
|
||||
Two cases here:
|
||||
1 there is not presets thumbs found (official version)
|
||||
2 thumbs allready are there (unofficial)
|
||||
2 thumbs already are there (unofficial)
|
||||
"""
|
||||
file_list = []
|
||||
# load default presets
|
||||
|
@ -110,7 +110,7 @@ class ARCHIPACK_OT_render_thumbs(Operator):
|
|||
if f.endswith(".txt"):
|
||||
skipfiles.append(f)
|
||||
|
||||
# when thumbs allready are in factory folder but not found in user one
|
||||
# when thumbs already are in factory folder but not found in user one
|
||||
# simply copy them, and add preset to skip list
|
||||
thumb_filename = f[:-3] + ".png"
|
||||
if path.exists(source_path + path.sep + thumb_filename):
|
||||
|
|
|
@ -297,7 +297,7 @@ class RoofPolygon(CutAblePolygon):
|
|||
self.side = side
|
||||
# backward deps
|
||||
self.backward = False
|
||||
# pointers to neighboors along axis
|
||||
# pointers to neighbors along axis
|
||||
self.last = None
|
||||
self.next = None
|
||||
self.other_side = None
|
||||
|
@ -407,7 +407,7 @@ class RoofPolygon(CutAblePolygon):
|
|||
"""
|
||||
always in axis real direction
|
||||
"""
|
||||
# backward dependancy relative to axis
|
||||
# backward dependency relative to axis
|
||||
if last.backward:
|
||||
self.backward = self.side == last.side
|
||||
|
||||
|
@ -475,7 +475,7 @@ class RoofPolygon(CutAblePolygon):
|
|||
v1 = -self._axis.v
|
||||
|
||||
if last.side == self.side:
|
||||
# contigous, v0 node <- next
|
||||
# contiguous, v0 node <- next
|
||||
|
||||
# half angle between segments
|
||||
if self.side == 'LEFT':
|
||||
|
@ -1006,7 +1006,7 @@ class RoofGenerator(CutAbleGenerator):
|
|||
# on node basis along axis
|
||||
# bi-direction Radial around node
|
||||
# from left and right to center
|
||||
# contigous -> same
|
||||
# contiguous -> same
|
||||
# T: and (x % 2 == 1)
|
||||
# First one take precedence over others
|
||||
# others inherit from side
|
||||
|
@ -1018,7 +1018,7 @@ class RoofGenerator(CutAbleGenerator):
|
|||
# 2
|
||||
# r\ l
|
||||
#
|
||||
# X: rigth one r left one l (x % 2 == 0)
|
||||
# X: right one or left one l (x % 2 == 0)
|
||||
# inherits from side
|
||||
#
|
||||
# l 3 lb l = left
|
||||
|
@ -1051,7 +1051,7 @@ class RoofGenerator(CutAbleGenerator):
|
|||
l_bind = left
|
||||
r_bind = right
|
||||
|
||||
# simple case: 2 contigous segments
|
||||
# simple case: 2 contiguous segments
|
||||
if nb_segs == 2:
|
||||
s = node.last
|
||||
s.right.bind(r_bind, ccw=False)
|
||||
|
@ -1060,7 +1060,7 @@ class RoofGenerator(CutAbleGenerator):
|
|||
|
||||
# More than 2 segments, uneven distribution
|
||||
if nb_segs % 2 == 1:
|
||||
# find wich child does take precedence
|
||||
# find which child does take precedence
|
||||
# first one on rootline (arbitrary)
|
||||
center = (nb_segs - 1) / 2
|
||||
else:
|
||||
|
@ -1078,7 +1078,7 @@ class RoofGenerator(CutAbleGenerator):
|
|||
# skip axis
|
||||
if i > 0:
|
||||
if i < center:
|
||||
# right contigous with last
|
||||
# right contiguous with last
|
||||
s.right.bind(r_bind, ccw=False)
|
||||
|
||||
# next bind to left
|
||||
|
@ -1100,7 +1100,7 @@ class RoofGenerator(CutAbleGenerator):
|
|||
for i, s in enumerate(reversed(node.segs)):
|
||||
# skip axis
|
||||
if i < nb_segs - center - 1:
|
||||
# left contigous with last
|
||||
# left contiguous with last
|
||||
s.left.bind(l_bind, ccw=True)
|
||||
# next bind to right
|
||||
l_bind = s.right
|
||||
|
@ -1257,12 +1257,12 @@ class RoofGenerator(CutAbleGenerator):
|
|||
if s1.seg.constraint_type == 'SLOPE':
|
||||
|
||||
# 3 cases:
|
||||
# s0 is root contigous -> sides are same
|
||||
# s2 is root contigous -> sides are same
|
||||
# s0 is root contiguous -> sides are same
|
||||
# s2 is root contiguous -> sides are same
|
||||
# back to back -> sides are not same
|
||||
|
||||
if s0.reversed:
|
||||
# contigous right / right
|
||||
# contiguous right / right
|
||||
# 2 cases
|
||||
# right is backward
|
||||
# right is forward
|
||||
|
@ -1284,7 +1284,7 @@ class RoofGenerator(CutAbleGenerator):
|
|||
else:
|
||||
main.rotate_next_slope(-a0)
|
||||
elif s2.reversed:
|
||||
# contigous left / left
|
||||
# contiguous left / left
|
||||
# 2 cases
|
||||
# left is backward
|
||||
# left is forward
|
||||
|
@ -1455,7 +1455,7 @@ class RoofGenerator(CutAbleGenerator):
|
|||
for pan in pans:
|
||||
self.pans.extend([pan.left, pan.right])
|
||||
|
||||
# merge contigous with 0 angle diff
|
||||
# merge contiguous with 0 angle diff
|
||||
to_remove = []
|
||||
for i, pan in enumerate(self.pans):
|
||||
if pan.backward:
|
||||
|
@ -2054,9 +2054,9 @@ class RoofGenerator(CutAbleGenerator):
|
|||
p2 = s0.p1
|
||||
p3 = s1.p1
|
||||
|
||||
# find last neighboor depending on type
|
||||
# find last neighbor depending on type
|
||||
if s2.type == 'AXIS' or 'LINK' in s2.type:
|
||||
# apply only on boundarys
|
||||
# apply only on boundaries
|
||||
if not s.is_hole:
|
||||
# use last axis
|
||||
if pan.side == 'LEFT':
|
||||
|
@ -2079,7 +2079,7 @@ class RoofGenerator(CutAbleGenerator):
|
|||
s2 = s2.offset(offset)
|
||||
s4 = s2.offset(offset + width)
|
||||
|
||||
# find next neighboor depending on type
|
||||
# find next neighbor depending on type
|
||||
if s3.type == 'AXIS' or 'LINK' in s3.type:
|
||||
if not s.is_hole:
|
||||
# use last axis
|
||||
|
@ -2245,9 +2245,9 @@ class RoofGenerator(CutAbleGenerator):
|
|||
tri_0, tri_1 = tri_1, tri_0
|
||||
|
||||
# tiangular use bottom segment direction
|
||||
# find last neighboor depending on type
|
||||
# find last neighbor depending on type
|
||||
if s1.type == 'AXIS' or 'LINK' in s1.type:
|
||||
# apply only on boundarys
|
||||
# apply only on boundaries
|
||||
if not s.is_hole:
|
||||
# use last axis
|
||||
if pan.side == 'LEFT':
|
||||
|
@ -2266,7 +2266,7 @@ class RoofGenerator(CutAbleGenerator):
|
|||
else:
|
||||
s1 = s1.offset(d.fascia_width)
|
||||
|
||||
# find next neighboor depending on type
|
||||
# find next neighbor depending on type
|
||||
if s2.type == 'AXIS' or 'LINK' in s2.type:
|
||||
if not s.is_hole:
|
||||
# use last axis
|
||||
|
@ -2378,9 +2378,9 @@ class RoofGenerator(CutAbleGenerator):
|
|||
f = len(verts)
|
||||
|
||||
# tiangular use segment direction
|
||||
# find last neighboor depending on type
|
||||
# find last neighbor depending on type
|
||||
if s1.type == 'AXIS' or 'LINK' in s1.type:
|
||||
# apply only on boundarys
|
||||
# apply only on boundaries
|
||||
if not s.is_hole:
|
||||
# use last axis
|
||||
if pan.side == 'LEFT':
|
||||
|
@ -2399,7 +2399,7 @@ class RoofGenerator(CutAbleGenerator):
|
|||
else:
|
||||
s1 = s1.offset(d.gutter_dist + d.gutter_width)
|
||||
|
||||
# find next neighboor depending on type
|
||||
# find next neighbor depending on type
|
||||
if s2.type == 'AXIS' or 'LINK' in s2.type:
|
||||
if not s.is_hole:
|
||||
# use last axis
|
||||
|
@ -4732,7 +4732,7 @@ class archipack_roof_cutter_segment(ArchipackCutterPart, PropertyGroup):
|
|||
items=(
|
||||
('SIDE', 'Side', 'Side with bargeboard', 0),
|
||||
('BOTTOM', 'Bottom', 'Bottom with gutter', 1),
|
||||
('LINK', 'Side link', 'Side witout decoration', 2),
|
||||
('LINK', 'Side link', 'Side without decoration', 2),
|
||||
('AXIS', 'Top', 'Top part with hip and beam', 3)
|
||||
# ('LINK_VALLEY', 'Side valley', 'Side with valley', 3),
|
||||
# ('LINK_HIP', 'Side hip', 'Side with hip', 4)
|
||||
|
@ -5269,10 +5269,10 @@ class ArchipackThrottleHandler():
|
|||
self.start_timer(context)
|
||||
return True
|
||||
|
||||
# allready a timer running
|
||||
# already a timer running
|
||||
self.stop_timer(context)
|
||||
|
||||
# prevent race conditions when allready in update mode
|
||||
# prevent race conditions when already in update mode
|
||||
if self.is_updating:
|
||||
return False
|
||||
|
||||
|
|
|
@ -841,12 +841,12 @@ class archipack_slab(ArchipackObject, Manipulable, PropertyGroup):
|
|||
if (idx + 1 == next_idx) or (next_idx == 0 and i + 1 == self.n_parts):
|
||||
# shared: should move last point
|
||||
# and apply to next segments
|
||||
# this is overriden for common segs
|
||||
# this is overridden for common segs
|
||||
# but translate non common ones
|
||||
dp = seg.p1 - w.segs[idx].p1
|
||||
w.translate(idx, dp)
|
||||
|
||||
# shared: transfert type too
|
||||
# shared: transfer type too
|
||||
if "C_" in part.type:
|
||||
d.parts[idx].type = 'C_WALL'
|
||||
w.segs[idx] = CurvedSlab(seg.c, seg.r, seg.a0, seg.da)
|
||||
|
@ -1250,7 +1250,7 @@ class archipack_slab_cutter_segment(ArchipackCutterPart, PropertyGroup):
|
|||
items=(
|
||||
('DEFAULT', 'Side', 'Side with rake', 0),
|
||||
('BOTTOM', 'Bottom', 'Bottom with gutter', 1),
|
||||
('LINK', 'Side link', 'Side witout decoration', 2),
|
||||
('LINK', 'Side link', 'Side without decoration', 2),
|
||||
('AXIS', 'Top', 'Top part with hip and beam', 3)
|
||||
# ('LINK_VALLEY', 'Side valley', 'Side with valley', 3),
|
||||
# ('LINK_HIP', 'Side hip', 'Side with hip', 4)
|
||||
|
|
|
@ -468,7 +468,7 @@ class CurvedStair(Stair, Arc):
|
|||
self.l_shape = left_shape
|
||||
self.r_shape = right_shape
|
||||
self.edges_multiples = round(abs(da), 6) > double_limit
|
||||
# left arc, tangeant at start and end
|
||||
# left arc, tangent at start and end
|
||||
self.l_arc, self.l_t0, self.l_t1, self.l_tc = self.set_offset(-left_offset, left_shape)
|
||||
self.r_arc, self.r_t0, self.r_t1, self.r_tc = self.set_offset(right_offset, right_shape)
|
||||
|
||||
|
|
|
@ -432,7 +432,7 @@ def update_t_part(self, context):
|
|||
# 1 No parents at all
|
||||
# 2 o has parent
|
||||
# 3 w has parent
|
||||
# 4 o and w share same parent allready
|
||||
# 4 o and w share same parent already
|
||||
# 5 o and w dosent share parent
|
||||
link_to_parent = False
|
||||
|
||||
|
|
|
@ -1317,7 +1317,7 @@ class archipack_window(ArchipackObject, Manipulable, PropertyGroup):
|
|||
props.angle_y = self.angle_y
|
||||
props.enable_glass = self.enable_glass
|
||||
props.update(context)
|
||||
# location y + frame width. frame depends on choosen profile (fixed or not)
|
||||
# location y + frame width. frame depends on chosen profile (fixed or not)
|
||||
# update linked childs location too
|
||||
child.location = Vector((origin[panel].x, origin[panel].y + location_y + self.frame_y,
|
||||
self.altitude + offset.y))
|
||||
|
@ -1997,7 +1997,7 @@ class ARCHIPACK_OT_window_draw(ArchpackDrawTool, Operator):
|
|||
('LEFTCLICK, RET, SPACE, ENTER', 'Create a window'),
|
||||
('BACKSPACE, CTRL+Z', 'undo last'),
|
||||
('C', 'Choose another window'),
|
||||
('SHIFT', 'Make independant copy'),
|
||||
('SHIFT', 'Make independent copy'),
|
||||
('RIGHTCLICK or ESC', 'exit')
|
||||
])
|
||||
self.feedback.enable()
|
||||
|
|
|
@ -479,7 +479,7 @@ class Panel():
|
|||
|
||||
def choose_a_shape_in_tri(self, center, origin, size, basis, pivot):
|
||||
"""
|
||||
Choose wich shape inside either a tri or a pentagon
|
||||
Choose which shape inside either a tri or a pentagon
|
||||
"""
|
||||
cx = (0.5 * basis + center.x) - origin.x
|
||||
cy = center.y - origin.y
|
||||
|
|
|
@ -286,7 +286,7 @@ def create_aim_widget(self, name):
|
|||
|
||||
|
||||
# =========================================================================
|
||||
# Define the fuction to make the camera active
|
||||
# Define the function to make the camera active
|
||||
# =========================================================================
|
||||
def sceneCamera():
|
||||
ob = bpy.context.active_object
|
||||
|
@ -535,7 +535,7 @@ def build_dolly_rig(context):
|
|||
cam_data_name = bpy.context.object.data.name
|
||||
bpy.data.cameras[cam_data_name].draw_size = 1.0
|
||||
cam.rotation_euler[0] = 1.5708 # rotate the camera 90 degrees in x
|
||||
cam.location = (0.0, -2.0, 0.0) # move the camera to the correct postion
|
||||
cam.location = (0.0, -2.0, 0.0) # move the camera to the correct position
|
||||
cam.parent = rig
|
||||
cam.parent_type = "BONE"
|
||||
cam.parent_bone = "CTRL"
|
||||
|
@ -720,7 +720,7 @@ def build_crane_rig(context):
|
|||
cam_data_name = bpy.context.object.data.name
|
||||
bpy.data.cameras[cam_data_name].draw_size = 1.0
|
||||
cam.rotation_euler[0] = 1.5708 # rotate the camera 90 degrees in x
|
||||
cam.location = (0.0, -2.0, 0.0) # move the camera to the correct postion
|
||||
cam.location = (0.0, -2.0, 0.0) # move the camera to the correct position
|
||||
cam.parent = rig
|
||||
cam.parent_type = "BONE"
|
||||
cam.parent_bone = "CTRL"
|
||||
|
|
|
@ -34,7 +34,7 @@ bl_info = {
|
|||
that tries to be representative of its type. These lists are :
|
||||
|
||||
* Items (for an iterable object)
|
||||
* Item Values (for an iterable object wich only supports index)
|
||||
* Item Values (for an iterable object which only supports index)
|
||||
* Modules
|
||||
* Types
|
||||
* Properties
|
||||
|
@ -47,7 +47,7 @@ that tries to be representative of its type. These lists are :
|
|||
filter section. It is also possible to explore other modules. Go the the root and select
|
||||
it in the list of available modules. It will be imported dynamically.
|
||||
|
||||
In the text section, some informations are displayed. The type of the object,
|
||||
In the text section, some information are displayed. The type of the object,
|
||||
what it returns, and its docstring. We could hope that these docstrings will be as
|
||||
descriptive as possible. This text data block named api_doc_ can be toggled on and off
|
||||
with the Escape key. (but a bug prevent the keymap to register correctly at start)
|
||||
|
@ -85,7 +85,7 @@ def init_tree_level():
|
|||
|
||||
init_tree_level()
|
||||
|
||||
api_doc_ = '' # the documentation formated for the API Navigator
|
||||
api_doc_ = '' # the documentation formatted for the API Navigator
|
||||
module_type = None # the type of current_module
|
||||
return_report = '' # what current_module returns
|
||||
filter_mem = {} # remember last filters entered for each path
|
||||
|
@ -561,10 +561,10 @@ class OBJECT_PT_api_navigator(ApiNavigator, Panel):
|
|||
show_panel_elements = bpy.context.window_manager.api_nav_props.panel_toggle[t] if \
|
||||
0 <= t < 10 else True
|
||||
|
||||
lenght = tree_level[t].__len__()
|
||||
too_long = lenght > reduce_to
|
||||
length = tree_level[t].__len__()
|
||||
too_long = length > reduce_to
|
||||
|
||||
if lenght:
|
||||
if length:
|
||||
col = layout.column()
|
||||
box = col.box()
|
||||
|
||||
|
@ -582,7 +582,7 @@ class OBJECT_PT_api_navigator(ApiNavigator, Panel):
|
|||
i = 0
|
||||
objects, count, filtered = 0, 0, 0
|
||||
|
||||
while count < reduce_to and i < lenght:
|
||||
while count < reduce_to and i < length:
|
||||
obj = tree_level[t][i]
|
||||
|
||||
if filters and filters not in obj:
|
||||
|
|
|
@ -169,7 +169,7 @@ def write_armature(
|
|||
"rest_arm_imat",
|
||||
# Rest_local_mat inverted.
|
||||
"rest_local_imat",
|
||||
# Last used euler to preserve euler compability in between keyframes.
|
||||
# Last used euler to preserve euler compatibility in between keyframes.
|
||||
"prev_euler",
|
||||
# Is the bone disconnected to the parent bone?
|
||||
"skip_position",
|
||||
|
|
|
@ -117,7 +117,7 @@ def read_bvh(context, file_path, rotate_mode='XYZ', global_scale=1.0):
|
|||
# Open the file for importing
|
||||
file = open(file_path, 'rU')
|
||||
|
||||
# Seperate into a list of lists, each line a list of words.
|
||||
# Separate into a list of lists, each line a list of words.
|
||||
file_lines = file.readlines()
|
||||
# Non standard carrage returns?
|
||||
if len(file_lines) == 1:
|
||||
|
|
|
@ -37,10 +37,10 @@ def read_chan(context, filepath, z_up, rot_ord, sensor_width, sensor_height):
|
|||
# read the file
|
||||
filehandle = open(filepath, 'r')
|
||||
|
||||
# iterate throug the files lines
|
||||
# iterate through the files lines
|
||||
for line in filehandle:
|
||||
# reset the target objects matrix
|
||||
# (the one from whitch one we'll extract the final transforms)
|
||||
# (the one from which one we'll extract the final transforms)
|
||||
m_trans_mat = Matrix()
|
||||
|
||||
# strip the line
|
||||
|
|
|
@ -106,7 +106,7 @@ def _relpath_remap(
|
|||
def pack(
|
||||
# store the blendfile relative to this directory, can be:
|
||||
# os.path.dirname(blendfile_src)
|
||||
# but in some cases we wan't to use a path higher up.
|
||||
# but in some cases we want to use a path higher up.
|
||||
# base_dir_src,
|
||||
blendfile_src, blendfile_dst,
|
||||
|
||||
|
|
|
@ -317,7 +317,7 @@ class bam_session:
|
|||
|
||||
sys.stdout.write(" operating on: %r\n" % blendfile_abs)
|
||||
sys.stdout.flush()
|
||||
# we don't want to read, just edit whats there.
|
||||
# we don't want to read, just edit what's there.
|
||||
with open(blendfile_abs, 'rb+') as fh_blend:
|
||||
for ofs, data in binary_edits:
|
||||
# sys.stdout.write("\n%r\n" % data)
|
||||
|
|
|
@ -32,7 +32,7 @@ class BTerrain:
|
|||
Functions for creating Blender meshes from DTM objects
|
||||
|
||||
This class contains functions that convert DTM objects to Blender meshes.
|
||||
Its main responsiblity is to triangulate a mesh from the elevation data in
|
||||
Its main responsibility is to triangulate a mesh from the elevation data in
|
||||
the DTM. Additionally, it attaches some metadata to the object and creates
|
||||
a UV map for it so that companion ortho-images drape properly.
|
||||
|
||||
|
@ -95,7 +95,7 @@ class BTerrain:
|
|||
@staticmethod
|
||||
def reload(obj, dtm):
|
||||
"""
|
||||
Replaces an exisiting object's terrain mesh
|
||||
Replaces an existing object's terrain mesh
|
||||
|
||||
This replaces an object's mesh with a new mesh, transferring old
|
||||
materials over to the new mesh. This is useful for reloading DTMs
|
||||
|
|
|
@ -50,7 +50,7 @@ class ImportHiRISETerrain(bpy.types.Operator, ImportHelper):
|
|||
#
|
||||
# Displaying this value as a percentage (0, 100] is an intuitive way
|
||||
# for users to grasp what this value does. The DTM importer, however,
|
||||
# wants to recieve a value between (0, 1]. This is obviously a
|
||||
# wants to receive a value between (0, 1]. This is obviously a
|
||||
# straightforward conversion:
|
||||
#
|
||||
# f(x) = x / 100
|
||||
|
|
|
@ -45,7 +45,7 @@ class TerrainPanel(Panel):
|
|||
#
|
||||
# Displaying this value as a percentage (0, 100] is an intuitive way
|
||||
# for users to grasp what this value does. The DTM importer, however,
|
||||
# wants to recieve a value between (0, 1]. This is obviously a
|
||||
# wants to receive a value between (0, 1]. This is obviously a
|
||||
# straightforward conversion:
|
||||
#
|
||||
# f(x) = x / 100
|
||||
|
|
|
@ -1331,7 +1331,7 @@ class SVGGeometryRECT(SVGGeometry):
|
|||
SVG rectangle
|
||||
"""
|
||||
|
||||
__slots__ = ('_rect', # coordinate and domensions of rectangle
|
||||
__slots__ = ('_rect', # coordinate and dimensions of rectangle
|
||||
'_radius', # Rounded corner radiuses
|
||||
'_styles') # Styles, used for displaying
|
||||
|
||||
|
|
|
@ -94,12 +94,12 @@ def get_active_cam_for_each_frame(scene, start, end):
|
|||
return(active_cam_frames)
|
||||
|
||||
|
||||
# create managable list of selected objects
|
||||
# create manageable list of selected objects
|
||||
def get_selected(context):
|
||||
cameras = [] # list of selected cameras
|
||||
solids = [] # list of all selected meshes that can be exported as AE's solids
|
||||
lights = [] # list of all selected lamps that can be exported as AE's lights
|
||||
nulls = [] # list of all selected objects exept cameras (will be used to create nulls in AE)
|
||||
nulls = [] # list of all selected objects except cameras (will be used to create nulls in AE)
|
||||
obs = context.selected_objects
|
||||
|
||||
for ob in obs:
|
||||
|
|
|
@ -94,7 +94,7 @@ try:
|
|||
except:
|
||||
copy = None
|
||||
|
||||
####1) Private (only for developpers)
|
||||
####1) Private (only for developers)
|
||||
_HEADER_POINTS=['insbase','extmin','extmax']
|
||||
|
||||
#---helper functions-----------------------------------
|
||||
|
|
|
@ -57,7 +57,7 @@ class BasePrimitiveDXFExporter(object):
|
|||
# get its normal-vector in localCS
|
||||
vec_normal = f.no.copy()
|
||||
#print 'deb: vec_normal=', vec_normal #------------------
|
||||
# must be transfered to camera/view-CS
|
||||
# must be transferred to camera/view-CS
|
||||
vec_normal *= mx_n
|
||||
#vec_normal *= mb.rotationPart()
|
||||
#print 'deb:2vec_normal=', vec_normal #------------------
|
||||
|
@ -191,5 +191,5 @@ class BasePrimitiveDXFExporter(object):
|
|||
# # ECS_origin is Global_Origin in EntityCoordSystem
|
||||
# ECS_origin = OCS_origin * Zrotmatrix
|
||||
# #print 'deb: ECS_origin=', ECS_origin #---------
|
||||
# #TODO: it doesnt work yet for negative scaled curve-objects!
|
||||
# #TODO: it doesn't work yet for negative scaled curve-objects!
|
||||
# return ZRotation,Zrotmatrix,OCS_origin,ECS_origin
|
||||
|
|
|
@ -245,7 +245,7 @@ class Unfolder:
|
|||
|
||||
def save(self, properties):
|
||||
"""Export the document"""
|
||||
# Note about scale: input is direcly in blender length
|
||||
# Note about scale: input is directly in blender length
|
||||
# Mesh.scale_islands multiplies everything by a user-defined ratio
|
||||
# exporters (SVG or PDF) multiply everything by 1000 (output in millimeters)
|
||||
Exporter = SVG if properties.file_format == 'SVG' else PDF
|
||||
|
@ -472,7 +472,7 @@ class Mesh:
|
|||
def generate_stickers(self, default_width, do_create_numbers=True):
|
||||
"""Add sticker faces where they are needed."""
|
||||
def uvedge_priority(uvedge):
|
||||
"""Retuns whether it is a good idea to stick something on this edge's face"""
|
||||
"""Returns whether it is a good idea to stick something on this edge's face"""
|
||||
# TODO: it should take into account overlaps with faces and with other stickers
|
||||
return uvedge.uvface.face.area / sum((vb.co - va.co).length for (va, vb) in pairs(uvedge.uvface.vertices))
|
||||
|
||||
|
|
|
@ -169,7 +169,7 @@ from struct import pack
|
|||
# U = x / sqrt(x^2 + y^2 + z^2)
|
||||
# V = y / sqrt(x^2 + y^2 + z^2)
|
||||
#
|
||||
# Triangles specifed counter clockwise for front face
|
||||
# Triangles specified counter clockwise for front face
|
||||
#
|
||||
# defines for sizeofs
|
||||
SIZE_FQUAT = 16
|
||||
|
@ -804,7 +804,7 @@ def is_1d_face(face, mesh):
|
|||
|
||||
# ===========================================================================
|
||||
# Smoothing group
|
||||
# (renamed to seperate it from VVertex.SmoothGroup)
|
||||
# (renamed to separate it from VVertex.SmoothGroup)
|
||||
# ===========================================================================
|
||||
class SmoothingGroup:
|
||||
|
||||
|
@ -1540,7 +1540,7 @@ def parse_animation(armature, udk_bones, actions_to_export, psa):
|
|||
restoreAction = armature.animation_data.action # Q: is animation_data always valid?
|
||||
# we already do this in export_proxy, but we'll do it here too for now
|
||||
restoreFrame = context.scene.frame_current
|
||||
raw_frame_index = 0 # used to set FirstRawFrame, seperating actions in the raw keyframe array
|
||||
raw_frame_index = 0 # used to set FirstRawFrame, separating actions in the raw keyframe array
|
||||
|
||||
# action loop...
|
||||
for action in actions_to_export:
|
||||
|
@ -2716,7 +2716,7 @@ class OBJECT_OT_ActionSetAnimUpdate(Operator):
|
|||
# print("remove :",actionlist.name)
|
||||
removeactions.append(actionlist.name)
|
||||
# print("Not in the action data list:",len(removeactions))
|
||||
# remove list or chnages in the name the template list
|
||||
# remove list or changes in the name the template list
|
||||
for actname in removeactions:
|
||||
actioncount = 0
|
||||
for actionlist in my_sett:
|
||||
|
|
|
@ -40,7 +40,7 @@ class CalendarDate:
|
|||
Z = floor(self.jdate)
|
||||
|
||||
if Z < 2299161:
|
||||
A = Z # julian calender
|
||||
A = Z # julian calendar
|
||||
else:
|
||||
g = floor((Z - 1867216.25) / 36524.25) # gregorian calendar
|
||||
A = Z + 1. + g - floor(g / 4.)
|
||||
|
|
|
@ -290,7 +290,7 @@ class Do:
|
|||
note: en.start_angle + en.end_angle: angles measured from the angle base (angbase) in the direction of
|
||||
angdir (1 = clockwise, 0 = counterclockwise)
|
||||
"""
|
||||
treshold = 0.005
|
||||
threshold = 0.005
|
||||
|
||||
if aunits is None:
|
||||
aunits = self.dwg.header.get('$AUNITS', 0)
|
||||
|
@ -337,22 +337,22 @@ class Do:
|
|||
# start
|
||||
spline = list()
|
||||
spline.append(vc + start)
|
||||
if abs(angle) - pi / 2 > treshold: # if angle is more than pi/2 incl. treshold
|
||||
if abs(angle) - pi / 2 > threshold: # if angle is more than pi/2 incl. threshold
|
||||
spline.append(vc + start + start * kappa * rot)
|
||||
else:
|
||||
spline.append(vc + start + start * kappa * angle / (pi / 2) * rot)
|
||||
|
||||
# fill if angle is larger than 90 degrees
|
||||
a = pi / 2
|
||||
if abs(angle) - treshold > a:
|
||||
if abs(angle) - threshold > a:
|
||||
fill = start
|
||||
|
||||
while abs(angle) - a > treshold:
|
||||
while abs(angle) - a > threshold:
|
||||
fillnext = fill * rot
|
||||
spline.append(vc + fillnext + fill * kappa)
|
||||
spline.append(vc + fillnext)
|
||||
# if this was the last fill control point
|
||||
if abs(angle) - a - pi / 2 < treshold:
|
||||
if abs(angle) - a - pi / 2 < threshold:
|
||||
end_angle = (abs(angle) - a) * abs(angle) / angle
|
||||
spline.append(vc + fillnext + fillnext * kappa * end_angle / (pi / 2) * rot)
|
||||
else:
|
||||
|
@ -578,7 +578,7 @@ class Do:
|
|||
|
||||
def polymesh(self, en, bm):
|
||||
"""
|
||||
en: POLYMESH entitiy
|
||||
en: POLYMESH entity
|
||||
bm: Blender bmesh instance
|
||||
"""
|
||||
mc = en.mcount if not en.is_mclosed else en.mcount + 1
|
||||
|
@ -905,7 +905,7 @@ class Do:
|
|||
for obj in inserts:
|
||||
obj.parent = o
|
||||
|
||||
# put a copy of the retreived objects into the known_blocks dict, so that the attributes being added to
|
||||
# put a copy of the retrieved objects into the known_blocks dict, so that the attributes being added to
|
||||
# the object from this point onwards (from INSERT attributes) are not being copied to new/other INSERTs
|
||||
self.known_blocks[name] = [[o.copy() for o in objects], inserts]
|
||||
|
||||
|
|
|
@ -72,7 +72,7 @@ def by_dxftype(entities):
|
|||
def by_attributes(entities):
|
||||
"""
|
||||
entities: list of DXF entities
|
||||
attributes: thickness and width occuring in curve types; subdivision_levels occuring in MESH dxf types
|
||||
attributes: thickness and width occurring in curve types; subdivision_levels occurring in MESH dxf types
|
||||
"""
|
||||
def attributes(entity):
|
||||
width = [(0, 0)]
|
||||
|
|
|
@ -88,7 +88,7 @@ def main(report, File, Path, LayerViewers, MixerViewers, LayerOffset,
|
|||
|
||||
"""The "nice" method to check if layer has alpha channel
|
||||
sadly GIMP sometimes decides not to export an alpha channel
|
||||
if it's pure white so we are not completly sure here yet"""
|
||||
if it's pure white so we are not completely sure here yet"""
|
||||
if Line.startswith("b'L"): HasAlpha = True
|
||||
else: HasAlpha = False
|
||||
|
||||
|
@ -107,7 +107,7 @@ def main(report, File, Path, LayerViewers, MixerViewers, LayerOffset,
|
|||
if HasAlpha:
|
||||
if not os.path.isfile(PathSaveRaw+imageFileAlpha): HasAlpha = False
|
||||
|
||||
# Get Widht and Height from images
|
||||
# Get Width and Height from images
|
||||
data = open(PathSaveRaw+imageFile, "rb").read()
|
||||
|
||||
hexList = []
|
||||
|
|
|
@ -327,7 +327,7 @@ def clean_node_tree(node_tree):
|
|||
|
||||
|
||||
def get_shadeless_node(dest_node_tree):
|
||||
"""Return a "shadless" cycles node, creating a node group if nonexistant"""
|
||||
"""Return a "shadless" cycles node, creating a node group if nonexistent"""
|
||||
try:
|
||||
node_tree = bpy.data.node_groups['IAP_SHADELESS']
|
||||
|
||||
|
@ -458,7 +458,7 @@ def register_watched_object(obj):
|
|||
def find_plane_corner(object_name, x, y, axis, camera=None, *args, **kwargs):
|
||||
"""Find the location in camera space of a plane's corner"""
|
||||
if args or kwargs:
|
||||
# I've added args / kwargs as a compatability measure with future versions
|
||||
# I've added args / kwargs as a compatibility measure with future versions
|
||||
warnings.warn("Unknown Parameters Passed to \"Images as Planes\". Maybe you need to upgrade?")
|
||||
|
||||
plane = bpy.data.objects[object_name]
|
||||
|
@ -606,7 +606,7 @@ def setup_compositing(context, plane, img_spec):
|
|||
# Operator
|
||||
|
||||
class IMPORT_IMAGE_OT_to_plane(Operator, AddObjectHelper):
|
||||
"""Create mesh plane(s) from image files with the appropiate aspect ratio"""
|
||||
"""Create mesh plane(s) from image files with the appropriate aspect ratio"""
|
||||
|
||||
bl_idname = "import_image.to_plane"
|
||||
bl_label = "Import Images as Planes"
|
||||
|
@ -1165,7 +1165,7 @@ class IMPORT_IMAGE_OT_to_plane(Operator, AddObjectHelper):
|
|||
# Axis-aligned
|
||||
axis = self.axis_id_to_vector[self.align_axis]
|
||||
|
||||
# rotate accodingly for x/y axiis
|
||||
# rotate accordingly for x/y axiis
|
||||
if not axis.z:
|
||||
plane.rotation_euler.x = pi / 2
|
||||
|
||||
|
|
|
@ -497,7 +497,7 @@ def read_colmap(col_bytes, object_layers):
|
|||
|
||||
|
||||
def read_color_vmad(col_bytes, object_layers, last_pols_count):
|
||||
"""Read the Discontinous (per-polygon) RGB values."""
|
||||
"""Read the Discontinuous (per-polygon) RGB values."""
|
||||
chunk_len= len(col_bytes)
|
||||
dia,= struct.unpack(">H", col_bytes[0:2])
|
||||
offset= 2
|
||||
|
@ -570,7 +570,7 @@ def read_uvmap(uv_bytes, object_layers):
|
|||
|
||||
|
||||
def read_uv_vmad(uv_bytes, object_layers, last_pols_count):
|
||||
"""Read the Discontinous (per-polygon) uv values."""
|
||||
"""Read the Discontinuous (per-polygon) uv values."""
|
||||
chunk_len= len(uv_bytes)
|
||||
offset= 2
|
||||
name, name_len= read_lwostring(uv_bytes[offset:])
|
||||
|
|
|
@ -89,10 +89,10 @@ class md5_bone:
|
|||
self.scale = [0.0] * 3
|
||||
self.head = [0.0] * 3
|
||||
self.tail = [0.0] * 3
|
||||
self.bindmat = [None] * 3 # is this how you initilize a 2d-array
|
||||
self.bindmat = [None] * 3 # is this how you initialize a 2d-array
|
||||
for i in range(3):
|
||||
self.bindmat[i] = [0.0] * 3
|
||||
self.origmat = [None] * 3 #is this how you initilize a 2d-array
|
||||
self.origmat = [None] * 3 #is this how you initialize a 2d-array
|
||||
for i in range(3):
|
||||
self.origmat[i] = [0.0] * 3
|
||||
self.parent = ""
|
||||
|
@ -628,7 +628,7 @@ def pskimport(infile,importmesh,importbone,bDebugLogPSK,importmultiuvtextures):
|
|||
print("INIT UV TEXTURE...")
|
||||
_matcount = 0
|
||||
#for mattexcount in materials:
|
||||
#print("MATERAIL ID:", _matcount)
|
||||
#print("MATERIAL ID:", _matcount)
|
||||
_textcount = 0
|
||||
for uv in me_ob.tessface_uv_textures: # uv texture
|
||||
print("UV TEXTURE ID:",_textcount)
|
||||
|
|
|
@ -144,7 +144,7 @@ class ImportPDB(Operator, ImportHelper):
|
|||
description="The sticks are round (sectors are not visible)")
|
||||
use_sticks_bonds = BoolProperty(
|
||||
name="Bonds", default=False,
|
||||
description="Show double and tripple bonds")
|
||||
description="Show double and triple bonds")
|
||||
sticks_dist = FloatProperty(
|
||||
name="", default = 1.1, min=1.0, max=3.0,
|
||||
description="Distance between sticks measured in stick diameter")
|
||||
|
|
|
@ -364,10 +364,10 @@ def read_pdb_file_sticks(filepath_pdb, use_sticks_bonds, all_atoms):
|
|||
split_list = line.split(' ')
|
||||
|
||||
# Go to the first entry
|
||||
if "CONECT" not in split_list[0]:
|
||||
if "CONNECT" not in split_list[0]:
|
||||
for line in filepath_pdb_p:
|
||||
split_list = line.split(' ')
|
||||
if "CONECT" in split_list[0]:
|
||||
if "CONNECT" in split_list[0]:
|
||||
break
|
||||
|
||||
Number_of_sticks = 0
|
||||
|
@ -379,8 +379,8 @@ def read_pdb_file_sticks(filepath_pdb, use_sticks_bonds, all_atoms):
|
|||
# ... which is broken here (EOF) ...
|
||||
if line == "":
|
||||
break
|
||||
# ... or here, when no 'CONECT' appears anymore.
|
||||
if "CONECT" not in line:
|
||||
# ... or here, when no 'CONNECT' appears anymore.
|
||||
if "CONNECT" not in line:
|
||||
break
|
||||
|
||||
# The strings of the atom numbers do have a clear position in the file
|
||||
|
@ -388,13 +388,13 @@ def read_pdb_file_sticks(filepath_pdb, use_sticks_bonds, all_atoms):
|
|||
# this. One could also use the split function but then one gets into
|
||||
# trouble if there are lots of atoms: For instance, it may happen that
|
||||
# one has
|
||||
# CONECT 11111 22244444
|
||||
# CONNECT 11111 22244444
|
||||
#
|
||||
# In Fact it means that atom No. 11111 has a connection with atom
|
||||
# No. 222 but also with atom No. 44444. The split function would give
|
||||
# me only two numbers (11111 and 22244444), which is wrong.
|
||||
|
||||
# Cut spaces from the right and 'CONECT' at the beginning
|
||||
# Cut spaces from the right and 'CONNECT' at the beginning
|
||||
line = line.rstrip()
|
||||
line = line[6:]
|
||||
# Amount of loops
|
||||
|
@ -474,7 +474,7 @@ def read_pdb_file_sticks(filepath_pdb, use_sticks_bonds, all_atoms):
|
|||
return all_sticks
|
||||
|
||||
|
||||
# Function, which produces a cylinder. All is somewhat easy to undertsand.
|
||||
# Function, which produces a cylinder. All is somewhat easy to understand.
|
||||
def build_stick(radius, length, sectors):
|
||||
|
||||
dphi = 2.0 * pi/(float(sectors)-1)
|
||||
|
@ -1237,7 +1237,7 @@ def import_pdb(Ball_type,
|
|||
|
||||
# It may happen that the structure in a PDB file already has an offset
|
||||
# If chosen, the structure is first put into the center of the scene
|
||||
# (the offset is substracted).
|
||||
# (the offset is subtracted).
|
||||
|
||||
if put_to_center == True:
|
||||
sum_vec = Vector((0.0,0.0,0.0))
|
||||
|
@ -1245,7 +1245,7 @@ def import_pdb(Ball_type,
|
|||
sum_vec = sum([atom.location for atom in all_atoms], sum_vec)
|
||||
# Then the average is taken
|
||||
sum_vec = sum_vec / Number_of_total_atoms
|
||||
# After, for each atom the center of gravity is substracted
|
||||
# After, for each atom the center of gravity is subtracted
|
||||
for atom in all_atoms:
|
||||
atom.location -= sum_vec
|
||||
|
||||
|
|
|
@ -24,7 +24,7 @@ bl_info = {
|
|||
"version": (1, 0, 0),
|
||||
"blender": (2, 74, 0),
|
||||
"location": "File > Import-Export",
|
||||
"description": "Import-Export PLY mesh data withs UV's and vertex colors",
|
||||
"description": "Import-Export PLY mesh data with UV's and vertex colors",
|
||||
"warning": "",
|
||||
"wiki_url": "http://wiki.blender.org/index.php/Extensions:2.6/Py/"
|
||||
"Scripts/Import-Export/Stanford_PLY",
|
||||
|
|
|
@ -264,7 +264,7 @@ def read_stl(filepath):
|
|||
|
||||
for nor, pt in gen(data):
|
||||
# Add the triangle and the point.
|
||||
# If the point is allready in the list of points, the
|
||||
# If the point is already in the list of points, the
|
||||
# index returned by pts.add() will be the one from the
|
||||
# first equal point inserted.
|
||||
tris.append([pts.add(p) for p in pt])
|
||||
|
|
|
@ -269,7 +269,7 @@ class ExportSketchfab(Operator):
|
|||
filename = r["filename"]
|
||||
|
||||
except Exception as e:
|
||||
self.report({'WARNING'}, "Error occured while preparing your file: %s" % str(e))
|
||||
self.report({'WARNING'}, "Error occurred while preparing your file: %s" % str(e))
|
||||
return {'FINISHED'}
|
||||
|
||||
sf_state.uploading = True
|
||||
|
@ -417,7 +417,7 @@ class SketchfabEmailToken(Operator):
|
|||
return {'FINISHED'}
|
||||
|
||||
if r.status_code != requests.codes.ok:
|
||||
self.report({'ERROR'}, "An error occured. Check the format of your email")
|
||||
self.report({'ERROR'}, "An error occurred. Check the format of your email")
|
||||
else:
|
||||
self.report({'INFO'}, "Your email was sent at your email address")
|
||||
|
||||
|
|
|
@ -101,7 +101,7 @@ SCL_TRACK_TAG = 0xB022
|
|||
import struct
|
||||
|
||||
# So 3ds max can open files, limit names to 12 in length
|
||||
# this is verry annoying for filenames!
|
||||
# this is very annoying for filenames!
|
||||
name_unique = [] # stores str, ascii only
|
||||
name_mapping = {} # stores {orig: byte} mapping
|
||||
|
||||
|
|
|
@ -2962,7 +2962,7 @@ def save_single(operator, scene, filepath="",
|
|||
if embed_textures and path_mode != 'COPY':
|
||||
embed_textures = False
|
||||
|
||||
# Calcuate bone correction matrix
|
||||
# Calculate bone correction matrix
|
||||
bone_correction_matrix = None # Default is None = no change
|
||||
bone_correction_matrix_inv = None
|
||||
if (primary_bone_axis, secondary_bone_axis) != ('Y', 'X'):
|
||||
|
|
|
@ -650,7 +650,7 @@ def elem_props_template_finalize(template, elem):
|
|||
Finalize one element's template/props.
|
||||
Issue is, some templates might be "needed" by different types (e.g. NodeAttribute is for lights, cameras, etc.),
|
||||
but values for only *one* subtype can be written as template. So we have to be sure we write those for the other
|
||||
subtypes in each and every elements, if they are not overriden by that element.
|
||||
subtypes in each and every elements, if they are not overridden by that element.
|
||||
Yes, hairy, FBX that is to say. When they could easily support several subtypes per template... :(
|
||||
"""
|
||||
for name, (value, ptype_name, animatable, written) in template.items():
|
||||
|
|
|
@ -3167,7 +3167,7 @@ def load(operator, context, filepath="",
|
|||
else:
|
||||
for material in mesh.materials:
|
||||
if material in material_decals:
|
||||
# recieve but dont cast shadows
|
||||
# receive but dont cast shadows
|
||||
material.use_raytrace = False
|
||||
_(); del _
|
||||
|
||||
|
|
|
@ -254,7 +254,7 @@ class Ms3dExporter():
|
|||
ms3d_group._comment_object.comment = \
|
||||
blender_ms3d_group.comment
|
||||
ms3d_group._comment_object.index = len(ms3d_model._groups)
|
||||
ms3d_group.material_index = None # to mark as not setted
|
||||
ms3d_group.material_index = None # to mark as not set
|
||||
ms3d_model._groups.append(ms3d_group)
|
||||
blender_to_ms3d_groups[blender_ms3d_group.id] = ms3d_group
|
||||
|
||||
|
|
|
@ -1133,7 +1133,7 @@ class Ms3dMaterialHelper:
|
|||
|
||||
@staticmethod
|
||||
def copy_from_blender(cls, blender_context, ms3d_material, blender_material):
|
||||
# copy, bacause of auto update, it would distord original values
|
||||
# copy, because of auto update, it would distord original values
|
||||
blender_material_diffuse_color = blender_material.diffuse_color.copy()
|
||||
blender_material_diffuse_intensity = blender_material.diffuse_intensity
|
||||
blender_material_specular_color = blender_material.specular_color.copy()
|
||||
|
|
|
@ -118,7 +118,7 @@ def write_mtl(scene, filepath, path_mode, copy_set, mtl_dict):
|
|||
elif mat.use_transparency and mat.transparency_method == 'RAYTRACE':
|
||||
fw('illum 9\n') # 'Glass' transparency and no Ray trace reflection... fuzzy matching, but...
|
||||
else:
|
||||
fw('illum 2\n') # light normaly
|
||||
fw('illum 2\n') # light normally
|
||||
|
||||
else:
|
||||
# Write a dummy material here?
|
||||
|
@ -127,7 +127,7 @@ def write_mtl(scene, filepath, path_mode, copy_set, mtl_dict):
|
|||
fw('Kd 0.8 0.8 0.8\n')
|
||||
fw('Ks 0.8 0.8 0.8\n')
|
||||
fw('d 1\n') # No alpha
|
||||
fw('illum 2\n') # light normaly
|
||||
fw('illum 2\n') # light normally
|
||||
|
||||
# Write images!
|
||||
if face_img: # We have an image on the face!
|
||||
|
@ -309,7 +309,7 @@ def write_file(filepath, objects, scene,
|
|||
def findVertexGroupName(face, vWeightMap):
|
||||
"""
|
||||
Searches the vertexDict to see what groups is assigned to a given face.
|
||||
We use a frequency system in order to sort out the name because a given vetex can
|
||||
We use a frequency system in order to sort out the name because a given vertex can
|
||||
belong to two or more groups at the same time. To find the right name for the face
|
||||
we list all the possible vertex group names with their frequency and then sort by
|
||||
frequency in descend order. The top element is the one shared by the highest number
|
||||
|
|
|
@ -45,7 +45,7 @@ from progress_report import ProgressReport, ProgressReportSubstep
|
|||
def line_value(line_split):
|
||||
"""
|
||||
Returns 1 string representing the value for this line
|
||||
None will be returned if theres only 1 word
|
||||
None will be returned if there's only 1 word
|
||||
"""
|
||||
length = len(line_split)
|
||||
if length == 1:
|
||||
|
@ -616,7 +616,7 @@ def create_mesh(new_objects,
|
|||
smooth_group_users = {context_smooth_group: {} for context_smooth_group in unique_smooth_groups.keys()}
|
||||
context_smooth_group_old = -1
|
||||
|
||||
fgon_edges = set() # Used for storing fgon keys when we need to tesselate/untesselate them (ngons with hole).
|
||||
fgon_edges = set() # Used for storing fgon keys when we need to tessellate/untessellate them (ngons with hole).
|
||||
edges = []
|
||||
tot_loops = 0
|
||||
|
||||
|
@ -710,7 +710,7 @@ def create_mesh(new_objects,
|
|||
if unique_smooth_groups:
|
||||
for edge_dict in smooth_group_users.values():
|
||||
for key, users in edge_dict.items():
|
||||
if users == 1: # This edge is on the boundry of a group
|
||||
if users == 1: # This edge is on the boundary of a group
|
||||
sharp_edges.add(key)
|
||||
|
||||
# map the material names to an index
|
||||
|
@ -1256,7 +1256,7 @@ def load(context,
|
|||
context_nurbs = {}
|
||||
context_parm = b''
|
||||
|
||||
''' # How to use usemap? depricated?
|
||||
''' # How to use usemap? deprecated?
|
||||
elif line_start == b'usema': # usemap or usemat
|
||||
context_image= line_value(line_split)
|
||||
'''
|
||||
|
|
|
@ -328,7 +328,7 @@ class ExportObject: # Base class, do not use
|
|||
for Child in Util.SortByNameField(self.Children):
|
||||
Child.Write()
|
||||
|
||||
# Simple decorator implemenation for ExportObject. Used by empty objects
|
||||
# Simple decorator implementation for ExportObject. Used by empty objects
|
||||
class EmptyExportObject(ExportObject):
|
||||
def __init__(self, Config, Exporter, BlenderObject):
|
||||
ExportObject.__init__(self, Config, Exporter, BlenderObject)
|
||||
|
|
|
@ -54,7 +54,7 @@ def imageConvertCompat(path):
|
|||
|
||||
# notes
|
||||
# transform are relative
|
||||
# order dosnt matter for loc/size/rot
|
||||
# order doesn't matter for loc/size/rot
|
||||
# right handed rotation
|
||||
# angles are in radians
|
||||
# rotation first defines axis then amount in radians
|
||||
|
@ -105,7 +105,7 @@ def vrmlFormat(data):
|
|||
"""
|
||||
Keep this as a valid vrml file, but format in a way we can predict.
|
||||
"""
|
||||
# Strip all commends - # not in strings - warning multiline strings are ignored.
|
||||
# Strip all comments - # not in strings - warning multiline strings are ignored.
|
||||
def strip_comment(l):
|
||||
#l = ' '.join(l.split())
|
||||
l = l.strip()
|
||||
|
@ -138,7 +138,7 @@ def vrmlFormat(data):
|
|||
|
||||
data = '\n'.join([strip_comment(l) for l in data.split('\n')]) # remove all whitespace
|
||||
|
||||
EXTRACT_STRINGS = True # only needed when strings or filesnames containe ,[]{} chars :/
|
||||
EXTRACT_STRINGS = True # only needed when strings or filename contains ,[]{} chars :/
|
||||
|
||||
if EXTRACT_STRINGS:
|
||||
|
||||
|
@ -573,7 +573,7 @@ class vrmlNode(object):
|
|||
# Only add this in a very special case
|
||||
# where the parent of this object is not the real parent
|
||||
# - In this case we have added the proto as a child to a node instancing it.
|
||||
# This is a bit arbitary, but its how Proto's are done with this importer.
|
||||
# This is a bit arbitrary, but its how Proto's are done with this importer.
|
||||
if child.getProtoName() is None and child.getExternprotoName() is None:
|
||||
child.getSerialized(results, ancestry)
|
||||
else:
|
||||
|
@ -621,7 +621,7 @@ class vrmlNode(object):
|
|||
|
||||
# proto settings are stored in "self.proto_node"
|
||||
if node.proto_node:
|
||||
# Get the default value from the proto, this can be overwridden by the proto instace
|
||||
# Get the default value from the proto, this can be overwritten by the proto instance
|
||||
# 'field SFColor legColor .8 .4 .7'
|
||||
if AS_CHILD:
|
||||
for child in node.proto_node.children:
|
||||
|
@ -808,12 +808,12 @@ class vrmlNode(object):
|
|||
|
||||
child_array = self_real.getFieldName(field, ancestry, True, SPLIT_COMMAS=True)
|
||||
|
||||
#if type(child_array)==list: # happens occasionaly
|
||||
#if type(child_array)==list: # happens occasionally
|
||||
# array_data = child_array
|
||||
|
||||
if child_array is None:
|
||||
# For x3d, should work ok with vrml too
|
||||
# for x3d arrays are fields, vrml they are nodes, annoying but not tooo bad.
|
||||
# for x3d arrays are fields, vrml they are nodes, annoying but not too bad.
|
||||
data_split = self.getFieldName(field, ancestry, SPLIT_COMMAS=True)
|
||||
if not data_split:
|
||||
return []
|
||||
|
@ -1668,7 +1668,7 @@ def importMesh_ReadVertices(bpymesh, geom, ancestry):
|
|||
# of vertices matches the source file.
|
||||
# Relies upon texture coordinates in the X3D node; if a coordinate generation
|
||||
# algorithm for a geometry is in the spec (e. g. for ElevationGrid), it needs
|
||||
# to be implemeted by the geometry handler.
|
||||
# to be implemented by the geometry handler.
|
||||
#
|
||||
# Texture transform is applied in ProcessObject.
|
||||
def importMesh_ApplyTextureToTessfaces(bpymesh, geom, ancestry, bpyima):
|
||||
|
@ -2258,7 +2258,7 @@ def importMesh_Extrusion(geom, ancestry, bpyima):
|
|||
(s + 1) * nc + c), ccw) for s in range(ns - 1) for c in range(ncf)]
|
||||
|
||||
if spine_closed:
|
||||
# The faces between the last and the first spine poins
|
||||
# The faces between the last and the first spine points
|
||||
b = (ns - 1) * nc
|
||||
faces += [flip((
|
||||
b + c,
|
||||
|
@ -2388,7 +2388,7 @@ def importMesh_IndexedLineSet(geom, ancestry, _):
|
|||
lines.append(line)
|
||||
|
||||
# vcolor = geom.getChildByName('color')
|
||||
# blender dosnt have per vertex color
|
||||
# blender doesn't have per vertex color
|
||||
|
||||
bpycurve = bpy.data.curves.new('IndexedCurve', 'CURVE')
|
||||
bpycurve.dimensions = '3D'
|
||||
|
@ -2414,7 +2414,7 @@ def importMesh_PointSet(geom, ancestry, _):
|
|||
points = []
|
||||
|
||||
# vcolor = geom.getChildByName('color')
|
||||
# blender dosnt have per vertex color
|
||||
# blender doesn't have per vertex color
|
||||
|
||||
bpymesh = bpy.data.meshes.new("PointSet")
|
||||
bpymesh.vertices.add(len(points))
|
||||
|
@ -2679,7 +2679,7 @@ def appearance_CreateMaterial(vrmlname, mat, ancestry, is_vcol):
|
|||
ancestry)
|
||||
bpymat.diffuse_color = diff_color
|
||||
|
||||
# NOTE - blender dosnt support emmisive color
|
||||
# NOTE - blender doesn't support emmisive color
|
||||
# Store in mirror color and approximate with emit.
|
||||
emit = mat.getFieldAsFloatTuple('emissiveColor', [0.0, 0.0, 0.0], ancestry)
|
||||
bpymat.mirror_color = emit
|
||||
|
@ -2893,7 +2893,7 @@ def importShape_LoadAppearance(vrmlname, appr, ancestry, node, is_vcol):
|
|||
It's probably an abuse of Blender of some level.
|
||||
|
||||
So here's the caching structure:
|
||||
For USE on apprearance, we store the material object
|
||||
For USE on appearance, we store the material object
|
||||
in the appearance node.
|
||||
|
||||
For USE on texture, we store the image object in the tex node.
|
||||
|
@ -3376,7 +3376,7 @@ def translateTimeSensor(node, action, ancestry):
|
|||
loop = node.getFieldAsBool('loop', False, ancestry)
|
||||
|
||||
time_cu.append((1 + startTime, 0.0))
|
||||
time_cu.append((1 + stopTime, 1.0 / 10.0)) # anoying, the UI uses /10
|
||||
time_cu.append((1 + stopTime, 1.0 / 10.0)) # annoying, the UI uses /10
|
||||
|
||||
if loop:
|
||||
time_cu.extend = Blender.IpoCurve.ExtendTypes.CYCLIC # or - EXTRAP, CYCLIC_EXTRAP, CONST,
|
||||
|
|
|
@ -209,7 +209,7 @@ def load_edl(scene, filename, reel_files, reel_offsets, global_offset):
|
|||
other.frame_offset_end += (other.frame_final_end - new_end)
|
||||
other.update()
|
||||
|
||||
# Apply disolve
|
||||
# Apply dissolve
|
||||
if edit.transition_type == parse_edl.TRANSITION_DISSOLVE:
|
||||
apply_dissolve_fcurve(final_strip, edit.transition_duration)
|
||||
|
||||
|
|
|
@ -257,7 +257,7 @@ BLACK_ID = {
|
|||
|
||||
|
||||
"""
|
||||
Most sytems:
|
||||
Most systems:
|
||||
Non-dropframe: 1:00:00:00 - colon in last position
|
||||
Dropframe: 1:00:00;00 - semicolon in last position
|
||||
PAL/SECAM: 1:00:00:00 - colon in last position
|
||||
|
|
|
@ -26,7 +26,7 @@
|
|||
# behavior
|
||||
#
|
||||
# vertex animation to ShapeKeys with ipo and gives the frame a value of 1.0
|
||||
# A modifier to read mdd files would be Ideal but thats for another day :)
|
||||
# A modifier to read mdd files would be Ideal but that's for another day :)
|
||||
#
|
||||
# Please send any fixes,updates,bugs to Slow67_at_Gmail.com
|
||||
# Bill Niewuendorp
|
||||
|
|
|
@ -39,7 +39,7 @@ Usage:
|
|||
A simple interface can be accessed in the tool shelf panel
|
||||
in 3D View ([T] Key).
|
||||
|
||||
A base mesh has to be provided, which will normaly be a
|
||||
A base mesh has to be provided, which will normally be a
|
||||
subdivided plane. The script will then create a camera rig
|
||||
and a light rig with adjustable properties. A sample camera
|
||||
and a spotlight will be created on each vertex of the
|
||||
|
@ -85,7 +85,7 @@ v0.0.1 - Initial version.
|
|||
TODO:
|
||||
* Restore view after primary camera is changed.
|
||||
* Apply object matrix to normals.
|
||||
* Allign to normals, somehow,....
|
||||
* Align to normals, somehow,....
|
||||
* StringProperties with PATH tag, for proper ui.
|
||||
"""
|
||||
|
||||
|
|
|
@ -43,8 +43,8 @@ Example: D:\Blender\2.72\scripts\addon\
|
|||
|
||||
Updates:
|
||||
v 0.5.61
|
||||
- Libraries arent read on each draw call, only on startup or when added. This fixes potential crashes and is less stressful, but when a library is deleted blender should be restarted.
|
||||
-Moved the addon from "System" category to "Materials"
|
||||
- Libraries aren't read on each draw call, only on startup or when added. This fixes potential crashes and is less stressful, but when a library is deleted blender should be restarted.
|
||||
- Moved the addon from "System" category to "Materials"
|
||||
|
||||
v 0.5.6
|
||||
- Create new libraries.
|
||||
|
|
Some files were not shown because too many files have changed in this diff Show More
Loading…
Reference in New Issue