add_curve_ivygen.py

   1 # ##### BEGIN GPL LICENSE BLOCK #####
   2 #
   3 #  This program is free software; you can redistribute it and/or
   4 #  modify it under the terms of the GNU General Public License
   5 #  as published by the Free Software Foundation; either version 2
   6 #  of the License, or (at your option) any later version.
   7 #
   8 #  This program is distributed in the hope that it will be useful,
   9 #  but WITHOUT ANY WARRANTY; without even the implied warranty of
  10 #  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11 #  GNU General Public License for more details.
  12 #
  13 #  You should have received a copy of the GNU General Public License
  14 #  along with this program; if not, write to the Free Software Foundation,
  15 #  Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  16 #
  17 # ##### END GPL LICENSE BLOCK #####
  18
  19 # <pep8-80 compliant>
  20
  21 bl_info = {
  22     "name": "IvyGen",
  23     "author": "testscreenings, PKHG, TrumanBlending",
  24     "version": (0, 1, 4),
  25     "blender": (2, 59, 0),
  26     "location": "View3D > Tool Shelf > Create > Ivy Generator",
  27     "description": "Adds generated ivy to a mesh object starting "
  28                    "at the 3D cursor",
  29     "warning": "",
  30     "wiki_url": "https://wiki.blender.org/index.php/Extensions:2.6/Py/"
  31                 "Scripts/Curve/Ivy_Gen",
  32     "category": "Add Curve",
  33 }
  34
  35
  36 import bpy
  37 from bpy.types import (
  38         Operator,
  39         Panel,
  40         PropertyGroup,
  41         )
  42 from bpy.props import (
  43         BoolProperty,
  44         FloatProperty,
  45         IntProperty,
  46         PointerProperty,
  47         )
  48 from mathutils import (
  49         Vector,
  50         Matrix,
  51         )
  52 from collections import deque
  53 from math import (
  54         pow, cos,
  55         pi, atan2,
  56         )
  57 from random import (
  58         random as rand_val,
  59         seed as rand_seed,
  60         )
  61 import time
  62
  63
  64 def createIvyGeometry(IVY, growLeaves):
  65     """Create the curve geometry for IVY"""
  66     # Compute the local size and the gauss weight filter
  67     # local_ivyBranchSize = IVY.ivyBranchSize  # * radius * IVY.ivySize
  68     gaussWeight = (1.0, 2.0, 4.0, 7.0, 9.0, 10.0, 9.0, 7.0, 4.0, 2.0, 1.0)
  69
  70     # Create a new curve and intialise it
  71     curve = bpy.data.curves.new("IVY", type='CURVE')
  72     curve.dimensions = '3D'
  73     curve.bevel_depth = 1
  74     curve.fill_mode = 'FULL'
  75     curve.resolution_u = 4
  76
  77     if growLeaves:
  78         # Create the ivy leaves
  79         # Order location of the vertices
  80         signList = ((-1.0, +1.0),
  81                     (+1.0, +1.0),
  82                     (+1.0, -1.0),
  83                     (-1.0, -1.0),
  84                     )
  85
  86         # Get the local size
  87         # local_ivyLeafSize = IVY.ivyLeafSize  # * radius * IVY.ivySize
  88
  89         # Initialise the vertex and face lists
  90         vertList = deque()
  91
  92         # Store the methods for faster calling
  93         addV = vertList.extend
  94         rotMat = Matrix.Rotation
  95
  96     # Loop over all roots to generate its nodes
  97     for root in IVY.ivyRoots:
  98         # Only grow if more than one node
  99         numNodes = len(root.ivyNodes)
 100         if numNodes > 1:
 101             # Calculate the local radius
 102             local_ivyBranchRadius = 1.0 / (root.parents + 1) + 1.0
 103             prevIvyLength = 1.0 / root.ivyNodes[-1].length
 104             splineVerts = [ax for n in root.ivyNodes for ax in n.pos.to_4d()]
 105
 106             radiusConstant = local_ivyBranchRadius * IVY.ivyBranchSize
 107             splineRadii = [radiusConstant * (1.3 - n.length * prevIvyLength)
 108                            for n in root.ivyNodes]
 109
 110             # Add the poly curve and set coords and radii
 111             newSpline = curve.splines.new(type='POLY')
 112             newSpline.points.add(len(splineVerts) // 4 - 1)
 113             newSpline.points.foreach_set('co', splineVerts)
 114             newSpline.points.foreach_set('radius', splineRadii)
 115
 116             # Loop over all nodes in the root
 117             for i, n in enumerate(root.ivyNodes):
 118                 for k in range(len(gaussWeight)):
 119                     idx = max(0, min(i + k - 5, numNodes - 1))
 120                     n.smoothAdhesionVector += (gaussWeight[k] *
 121                                                root.ivyNodes[idx].adhesionVector)
 122                 n.smoothAdhesionVector /= 56.0
 123                 n.adhesionLength = n.smoothAdhesionVector.length
 124                 n.smoothAdhesionVector.normalize()
 125
 126                 if growLeaves and (i < numNodes - 1):
 127                     node = root.ivyNodes[i]
 128                     nodeNext = root.ivyNodes[i + 1]
 129
 130                     # Find the weight and normalize the smooth adhesion vector
 131                     weight = pow(node.length * prevIvyLength, 0.7)
 132
 133                     # Calculate the ground ivy and the new weight
 134                     groundIvy = max(0.0, -node.smoothAdhesionVector.z)
 135                     weight += groundIvy * pow(1 - node.length *
 136                                                               prevIvyLength, 2)
 137
 138                     # Find the alignment weight
 139                     alignmentWeight = node.adhesionLength
 140
 141                     # Calculate the needed angles
 142                     phi = atan2(node.smoothAdhesionVector.y,
 143                                 node.smoothAdhesionVector.x) - pi / 2.0
 144
 145                     theta = (0.5 *
 146                         node.smoothAdhesionVector.angle(Vector((0, 0, -1)), 0))
 147
 148                     # Find the size weight
 149                     sizeWeight = 1.5 - (cos(2 * pi * weight) * 0.5 + 0.5)
 150
 151                     # Randomise the angles
 152                     phi += (rand_val() - 0.5) * (1.3 - alignmentWeight)
 153                     theta += (rand_val() - 0.5) * (1.1 - alignmentWeight)
 154
 155                     # Calculate the leaf size an append the face to the list
 156                     leafSize = IVY.ivyLeafSize * sizeWeight
 157
 158                     for j in range(10):
 159                         # Generate the probability
 160                         probability = rand_val()
 161
 162                         # If we need to grow a leaf, do so
 163                         if (probability * weight) > IVY.leafProbability:
 164
 165                             # Generate the random vector
 166                             randomVector = Vector((rand_val() - 0.5,
 167                                                    rand_val() - 0.5,
 168                                                    rand_val() - 0.5,
 169                                                    ))
 170
 171                             # Find the leaf center
 172                             center = (node.pos.lerp(nodeNext.pos, j / 10.0) +
 173                                                IVY.ivyLeafSize * randomVector)
 174
 175                             # For each of the verts, rotate/scale and append
 176                             basisVecX = Vector((1, 0, 0))
 177                             basisVecY = Vector((0, 1, 0))
 178
 179                             horiRot = rotMat(theta, 3, 'X')
 180                             vertRot = rotMat(phi, 3, 'Z')
 181
 182                             basisVecX.rotate(horiRot)
 183                             basisVecY.rotate(horiRot)
 184
 185                             basisVecX.rotate(vertRot)
 186                             basisVecY.rotate(vertRot)
 187
 188                             basisVecX *= leafSize
 189                             basisVecY *= leafSize
 190
 191                             addV([k1 * basisVecX + k2 * basisVecY + center for
 192                                                            k1, k2 in signList])
 193
 194     # Add the object and link to scene
 195     newCurve = bpy.data.objects.new("IVY_Curve", curve)
 196     bpy.context.scene.objects.link(newCurve)
 197
 198     if growLeaves:
 199         faceList = [[4 * i + l for l in range(4)] for i in
 200                     range(len(vertList) // 4)]
 201
 202         # Generate the new leaf mesh and link
 203         me = bpy.data.meshes.new('IvyLeaf')
 204         me.from_pydata(vertList, [], faceList)
 205         me.update(calc_edges=True)
 206         ob = bpy.data.objects.new('IvyLeaf', me)
 207         bpy.context.scene.objects.link(ob)
 208
 209         me.uv_textures.new("Leaves")
 210
 211         # Set the uv texture coords
 212         # TODO, this is non-functional, default uvs are ok?
 213         '''
 214         for d in tex.data:
 215             uv1, uv2, uv3, uv4 = signList
 216         '''
 217
 218         ob.parent = newCurve
 219
 220
 221 class IvyNode:
 222     """ The basic class used for each point on the ivy which is grown."""
 223     __slots__ = ('pos', 'primaryDir', 'adhesionVector', 'adhesionLength',
 224                  'smoothAdhesionVector', 'length', 'floatingLength', 'climb')
 225
 226     def __init__(self):
 227         self.pos = Vector((0, 0, 0))
 228         self.primaryDir = Vector((0, 0, 1))
 229         self.adhesionVector = Vector((0, 0, 0))
 230         self.smoothAdhesionVector = Vector((0, 0, 0))
 231         self.length = 0.0001
 232         self.floatingLength = 0.0
 233         self.climb = True
 234
 235
 236 class IvyRoot:
 237     """ The class used to hold all ivy nodes growing from this root point."""
 238     __slots__ = ('ivyNodes', 'alive', 'parents')
 239
 240     def __init__(self):
 241         self.ivyNodes = deque()
 242         self.alive = True
 243         self.parents = 0
 244
 245
 246 class Ivy:
 247     """ The class holding all parameters and ivy roots."""
 248     __slots__ = ('ivyRoots', 'primaryWeight', 'randomWeight',
 249                  'gravityWeight', 'adhesionWeight', 'branchingProbability',
 250                  'leafProbability', 'ivySize', 'ivyLeafSize', 'ivyBranchSize',
 251                  'maxFloatLength', 'maxAdhesionDistance', 'maxLength')
 252
 253     def __init__(self,
 254                  primaryWeight=0.5,
 255                  randomWeight=0.2,
 256                  gravityWeight=1.0,
 257                  adhesionWeight=0.1,
 258                  branchingProbability=0.05,
 259                  leafProbability=0.35,
 260                  ivySize=0.02,
 261                  ivyLeafSize=0.02,
 262                  ivyBranchSize=0.001,
 263                  maxFloatLength=0.5,
 264                  maxAdhesionDistance=1.0):
 265
 266         self.ivyRoots = deque()
 267         self.primaryWeight = primaryWeight
 268         self.randomWeight = randomWeight
 269         self.gravityWeight = gravityWeight
 270         self.adhesionWeight = adhesionWeight
 271         self.branchingProbability = 1 - branchingProbability
 272         self.leafProbability = 1 - leafProbability
 273         self.ivySize = ivySize
 274         self.ivyLeafSize = ivyLeafSize
 275         self.ivyBranchSize = ivyBranchSize
 276         self.maxFloatLength = maxFloatLength
 277         self.maxAdhesionDistance = maxAdhesionDistance
 278         self.maxLength = 0.0
 279
 280         # Normalize all the weights only on intialisation
 281         sums = self.primaryWeight + self.randomWeight + self.adhesionWeight
 282         self.primaryWeight /= sums
 283         self.randomWeight /= sums
 284         self.adhesionWeight /= sums
 285
 286     def seed(self, seedPos):
 287         # Seed the Ivy by making a new root and first node
 288         tmpRoot = IvyRoot()
 289         tmpIvy = IvyNode()
 290         tmpIvy.pos = seedPos
 291
 292         tmpRoot.ivyNodes.append(tmpIvy)
 293         self.ivyRoots.append(tmpRoot)
 294
 295     def grow(self, ob):
 296         # Determine the local sizes
 297         # local_ivySize = self.ivySize  # * radius
 298         # local_maxFloatLength = self.maxFloatLength  # * radius
 299         # local_maxAdhesionDistance = self.maxAdhesionDistance  # * radius
 300
 301         for root in self.ivyRoots:
 302             # Make sure the root is alive, if not, skip
 303             if not root.alive:
 304                 continue
 305
 306             # Get the last node in the current root
 307             prevIvy = root.ivyNodes[-1]
 308
 309             # If the node is floating for too long, kill the root
 310             if prevIvy.floatingLength > self.maxFloatLength:
 311                 root.alive = False
 312
 313             # Set the primary direction from the last node
 314             primaryVector = prevIvy.primaryDir
 315
 316             # Make the random vector and normalize
 317             randomVector = Vector((rand_val() - 0.5, rand_val() - 0.5,
 318                                    rand_val() - 0.5)) + Vector((0, 0, 0.2))
 319             randomVector.normalize()
 320
 321             # Calculate the adhesion vector
 322             adhesionVector = adhesion(prevIvy.pos, ob,
 323                                                       self.maxAdhesionDistance)
 324
 325             # Calculate the growing vector
 326             growVector = self.ivySize * (primaryVector * self.primaryWeight +
 327                                           randomVector * self.randomWeight +
 328                                           adhesionVector * self.adhesionWeight)
 329
 330             # Find the gravity vector
 331             gravityVector = (self.ivySize * self.gravityWeight *
 332                                                             Vector((0, 0, -1)))
 333             gravityVector *= pow(prevIvy.floatingLength / self.maxFloatLength,
 334                                  0.7)
 335
 336             # Determine the new position vector
 337             newPos = prevIvy.pos + growVector + gravityVector
 338
 339             # Check for collisions with the object
 340             climbing = collision(ob, prevIvy.pos, newPos)
 341
 342             # Update the growing vector for any collisions
 343             growVector = newPos - prevIvy.pos - gravityVector
 344             growVector.normalize()
 345
 346             # Create a new IvyNode and set its properties
 347             tmpNode = IvyNode()
 348             tmpNode.climb = climbing
 349             tmpNode.pos = newPos
 350             tmpNode.primaryDir = prevIvy.primaryDir.lerp(growVector, 0.5)
 351             tmpNode.primaryDir.normalize()
 352             tmpNode.adhesionVector = adhesionVector
 353             tmpNode.length = prevIvy.length + (newPos - prevIvy.pos).length
 354
 355             if tmpNode.length > self.maxLength:
 356                 self.maxLength = tmpNode.length
 357
 358             # If the node isn't climbing, update it's floating length
 359             # Otherwise set it to 0
 360             if not climbing:
 361                 tmpNode.floatingLength = prevIvy.floatingLength + (newPos -
 362                                                             prevIvy.pos).length
 363             else:
 364                 tmpNode.floatingLength = 0.0
 365
 366             root.ivyNodes.append(tmpNode)
 367
 368         # Loop through all roots to check if a new root is generated
 369         for root in self.ivyRoots:
 370             # Check the root is alive and isn't at high level of recursion
 371             if (root.parents > 3) or (not root.alive):
 372                 continue
 373
 374             # Check to make sure there's more than 1 node
 375             if len(root.ivyNodes) > 1:
 376                 # Loop through all nodes in root to check if new root is grown
 377                 for node in root.ivyNodes:
 378                     # Set the last node of the root and find the weighting
 379                     prevIvy = root.ivyNodes[-1]
 380                     weight = 1.0 - (cos(2.0 * pi * node.length /
 381                                         prevIvy.length) * 0.5 + 0.5)
 382
 383                     probability = rand_val()
 384
 385                     # Check if a new root is grown and if so, set its values
 386                     if (probability * weight > self.branchingProbability):
 387                         tmpNode = IvyNode()
 388                         tmpNode.pos = node.pos
 389                         tmpNode.floatingLength = node.floatingLength
 390
 391                         tmpRoot = IvyRoot()
 392                         tmpRoot.parents = root.parents + 1
 393
 394                         tmpRoot.ivyNodes.append(tmpNode)
 395                         self.ivyRoots.append(tmpRoot)
 396                         return
 397
 398
 399 def adhesion(loc, ob, max_l):
 400     # Get transfor vector and transformed loc
 401     tran_mat = ob.matrix_world.inverted()
 402     tran_loc = tran_mat * loc
 403
 404     # Compute the adhesion vector by finding the nearest point
 405     nearest_result = ob.closest_point_on_mesh(tran_loc, max_l)
 406     adhesion_vector = Vector((0.0, 0.0, 0.0))
 407     if nearest_result[0]:
 408         # Compute the distance to the nearest point
 409         adhesion_vector = ob.matrix_world * nearest_result[1] - loc
 410         distance = adhesion_vector.length
 411         # If it's less than the maximum allowed and not 0, continue
 412         if distance:
 413             # Compute the direction vector between the closest point and loc
 414             adhesion_vector.normalize()
 415             adhesion_vector *= 1.0 - distance / max_l
 416             # adhesion_vector *= getFaceWeight(ob.data, nearest_result[3])
 417     return adhesion_vector
 418
 419
 420 def collision(ob, pos, new_pos):
 421     # Check for collision with the object
 422     climbing = False
 423
 424     # Transform vecs
 425     tran_mat = ob.matrix_world.inverted()
 426     tran_pos = tran_mat * pos
 427     tran_new_pos = tran_mat * new_pos
 428     tran_dir = tran_new_pos - tran_pos
 429
 430     ray_result = ob.ray_cast(tran_pos, tran_dir, tran_dir.length)
 431     # If there's a collision we need to check it
 432     if ray_result[0]:
 433         # Check whether the collision is going into the object
 434         if tran_dir.dot(ray_result[2]) < 0.0:
 435             # Find projection of the piont onto the plane
 436             p0 = tran_new_pos - (tran_new_pos -
 437                                           ray_result[1]).project(ray_result[2])
 438             # Reflect in the plane
 439             tran_new_pos += 2 * (p0 - tran_new_pos)
 440             new_pos *= 0
 441             new_pos += ob.matrix_world * tran_new_pos
 442             climbing = True
 443     return climbing
 444
 445
 446 def check_mesh_faces(ob):
 447     me = ob.data
 448     if len(me.polygons) > 0:
 449         return True
 450
 451     return False
 452
 453
 454 class IvyGen(Operator):
 455     bl_idname = "curve.ivy_gen"
 456     bl_label = "IvyGen"
 457     bl_description = "Generate Ivy on an Mesh Object"
 458     bl_options = {'REGISTER', 'UNDO'}
 459
 460     updateIvy = BoolProperty(
 461             name="Update Ivy",
 462             description="Update the Ivy location based on the cursor and Panel settings",
 463             default=False
 464             )
 465     defaultIvy = BoolProperty(
 466             name="Default Ivy",
 467             options={"HIDDEN", "SKIP_SAVE"},
 468             default=False
 469             )
 470
 471     @classmethod
 472     def poll(self, context):
 473         # Check if there's an object and whether it's a mesh
 474         ob = context.active_object
 475         return ((ob is not None) and
 476                 (ob.type == 'MESH') and
 477                 (context.mode == 'OBJECT'))
 478
 479     def invoke(self, context, event):
 480         self.updateIvy = True
 481         return self.execute(context)
 482
 483     def execute(self, context):
 484         # scene = context.scene
 485         ivyProps = context.window_manager.ivy_gen_props
 486
 487         if not self.updateIvy:
 488             return {'PASS_THROUGH'}
 489
 490         # assign the variables, check if it is default
 491         # Note: update the values if window_manager props defaults are changed
 492         randomSeed = ivyProps.randomSeed if not self.defaultIvy else 0
 493         maxTime = ivyProps.maxTime if not self.defaultIvy else 0
 494         maxIvyLength = ivyProps.maxIvyLength if not self.defaultIvy else 1.0
 495         ivySize = ivyProps.ivySize if not self.defaultIvy else 0.02
 496         maxFloatLength = ivyProps.maxFloatLength if not self.defaultIvy else 0.5
 497         maxAdhesionDistance = ivyProps.maxAdhesionDistance if not self.defaultIvy else 1.0
 498         primaryWeight = ivyProps.primaryWeight if not self.defaultIvy else 0.5
 499         randomWeight = ivyProps.randomWeight if not self.defaultIvy else 0.2
 500         gravityWeight = ivyProps.gravityWeight if not self.defaultIvy else 1.0
 501         adhesionWeight = ivyProps.adhesionWeight if not self.defaultIvy else 0.1
 502         branchingProbability = ivyProps.branchingProbability if not self.defaultIvy else 0.05
 503         leafProbability = ivyProps.leafProbability if not self.defaultIvy else 0.35
 504         ivyBranchSize = ivyProps.ivyBranchSize if not self.defaultIvy else 0.001
 505         ivyLeafSize = ivyProps.ivyLeafSize if not self.defaultIvy else 0.02
 506         growLeaves = ivyProps.growLeaves if not self.defaultIvy else True
 507
 508         bpy.ops.object.mode_set(mode='EDIT', toggle=False)
 509         bpy.ops.object.mode_set(mode='OBJECT', toggle=False)
 510
 511         # Get the selected object
 512         ob = context.active_object
 513
 514         # Check if the mesh has at least one polygon since some functions
 515         # are expecting them in the object's data (see T51753)
 516         check_face = check_mesh_faces(ob)
 517         if check_face is False:
 518             self.report({'WARNING'},
 519                         "Mesh Object doesn't have at least one Face. "
 520                         "Operation Cancelled")
 521             return {"CANCELLED"}
 522
 523         # Compute bounding sphere radius
 524         # radius = computeBoundingSphere(ob)  # Not needed anymore
 525
 526         # Get the seeding point
 527         seedPoint = context.scene.cursor_location
 528
 529         # Fix the random seed
 530         rand_seed(randomSeed)
 531
 532         # Make the new ivy
 533         IVY = Ivy(
 534             primaryWeight=primaryWeight,
 535             randomWeight=randomWeight,
 536             gravityWeight=gravityWeight,
 537             adhesionWeight=adhesionWeight,
 538             branchingProbability=branchingProbability,
 539             leafProbability=leafProbability,
 540             ivySize=ivySize,
 541             ivyLeafSize=ivyLeafSize,
 542             ivyBranchSize=ivyBranchSize,
 543             maxFloatLength=maxFloatLength,
 544             maxAdhesionDistance=maxAdhesionDistance
 545             )
 546         # Generate first root and node
 547         IVY.seed(seedPoint)
 548
 549         checkTime = False
 550         maxLength = maxIvyLength  # * radius
 551
 552         # If we need to check time set the flag
 553         if maxTime != 0.0:
 554             checkTime = True
 555
 556         t = time.time()
 557         startPercent = 0.0
 558         checkAliveIter = [True, ]
 559
 560         # Grow until 200 roots is reached or backup counter exceeds limit
 561         while (any(checkAliveIter) and
 562                (IVY.maxLength < maxLength) and
 563                (not checkTime or (time.time() - t < maxTime))):
 564             # Grow the ivy for this iteration
 565             IVY.grow(ob)
 566
 567             # Print the proportion of ivy growth to console
 568             if (IVY.maxLength / maxLength * 100) > 10 * startPercent // 10:
 569                 print('%0.2f%% of Ivy nodes have grown' %
 570                                          (IVY.maxLength / maxLength * 100))
 571                 startPercent += 10
 572                 if IVY.maxLength / maxLength > 1:
 573                     print("Halting Growth")
 574
 575             # Make an iterator to check if all are alive
 576             checkAliveIter = (r.alive for r in IVY.ivyRoots)
 577
 578         # Create the curve and leaf geometry
 579         createIvyGeometry(IVY, growLeaves)
 580         print("Geometry Generation Complete")
 581
 582         print("Ivy generated in %0.2f s" % (time.time() - t))
 583
 584         self.updateIvy = False
 585         self.defaultIvy = False
 586
 587         return {'FINISHED'}
 588
 589     def draw(self, context):
 590         layout = self.layout
 591
 592         layout.prop(self, "updateIvy", icon="FILE_REFRESH")
 593
 594
 595 class CURVE_PT_IvyGenPanel(Panel):
 596     bl_label = "Ivy Generator"
 597     bl_idname = "CURVE_PT_IvyGenPanel"
 598     bl_space_type = "VIEW_3D"
 599     bl_region_type = "TOOLS"
 600     bl_category = "Create"
 601     bl_context = 'objectmode'
 602     bl_options = {"DEFAULT_CLOSED"}
 603
 604     def draw(self, context):
 605         layout = self.layout
 606         wm = context.window_manager
 607         col = layout.column(align=True)
 608
 609         prop_new = col.operator("curve.ivy_gen", text="Add New Ivy", icon="OUTLINER_OB_CURVE")
 610         prop_new.defaultIvy = False
 611         prop_new.updateIvy = True
 612
 613         prop_def = col.operator("curve.ivy_gen", text="Add New Default Ivy", icon="CURVE_DATA")
 614         prop_def.defaultIvy = True
 615         prop_def.updateIvy = True
 616
 617         col = layout.column(align=True)
 618         col.label("Generation Settings:")
 619         col.prop(wm.ivy_gen_props, "randomSeed")
 620         col.prop(wm.ivy_gen_props, "maxTime")
 621
 622         col = layout.column(align=True)
 623         col.label("Size Settings:")
 624         col.prop(wm.ivy_gen_props, "maxIvyLength")
 625         col.prop(wm.ivy_gen_props, "ivySize")
 626         col.prop(wm.ivy_gen_props, "maxFloatLength")
 627         col.prop(wm.ivy_gen_props, "maxAdhesionDistance")
 628
 629         col = layout.column(align=True)
 630         col.label("Weight Settings:")
 631         col.prop(wm.ivy_gen_props, "primaryWeight")
 632         col.prop(wm.ivy_gen_props, "randomWeight")
 633         col.prop(wm.ivy_gen_props, "gravityWeight")
 634         col.prop(wm.ivy_gen_props, "adhesionWeight")
 635
 636         col = layout.column(align=True)
 637         col.label("Branch Settings:")
 638         col.prop(wm.ivy_gen_props, "branchingProbability")
 639         col.prop(wm.ivy_gen_props, "ivyBranchSize")
 640
 641         col = layout.column(align=True)
 642         col.prop(wm.ivy_gen_props, "growLeaves")
 643
 644         if wm.ivy_gen_props.growLeaves:
 645             col = layout.column(align=True)
 646             col.label("Leaf Settings:")
 647             col.prop(wm.ivy_gen_props, "ivyLeafSize")
 648             col.prop(wm.ivy_gen_props, "leafProbability")
 649
 650
 651 class IvyGenProperties(PropertyGroup):
 652     maxIvyLength = FloatProperty(
 653             name="Max Ivy Length",
 654             description="Maximum ivy length in Blender Units",
 655             default=1.0,
 656             min=0.0,
 657             soft_max=3.0,
 658             subtype='DISTANCE',
 659             unit='LENGTH'
 660             )
 661     primaryWeight = FloatProperty(
 662             name="Primary Weight",
 663             description="Weighting given to the current direction",
 664             default=0.5,
 665             min=0.0,
 666             soft_max=1.0
 667             )
 668     randomWeight = FloatProperty(
 669             name="Random Weight",
 670             description="Weighting given to the random direction",
 671             default=0.2,
 672             min=0.0,
 673             soft_max=1.0
 674             )
 675     gravityWeight = FloatProperty(
 676             name="Gravity Weight",
 677             description="Weighting given to the gravity direction",
 678             default=1.0,
 679             min=0.0,
 680             soft_max=1.0
 681             )
 682     adhesionWeight = FloatProperty(
 683             name="Adhesion Weight",
 684             description="Weighting given to the adhesion direction",
 685             default=0.1,
 686             min=0.0,
 687             soft_max=1.0
 688             )
 689     branchingProbability = FloatProperty(
 690             name="Branching Probability",
 691             description="Probability of a new branch forming",
 692             default=0.05,
 693             min=0.0,
 694             soft_max=1.0
 695             )
 696     leafProbability = FloatProperty(
 697             name="Leaf Probability",
 698             description="Probability of a leaf forming",
 699             default=0.35,
 700             min=0.0,
 701             soft_max=1.0
 702             )
 703     ivySize = FloatProperty(
 704             name="Ivy Size",
 705             description="The length of an ivy segment in Blender"
 706                         " Units",
 707             default=0.02,
 708             min=0.0,
 709             soft_max=1.0,
 710             precision=3
 711             )
 712     ivyLeafSize = FloatProperty(
 713             name="Ivy Leaf Size",
 714             description="The size of the ivy leaves",
 715             default=0.02,
 716             min=0.0,
 717             soft_max=0.5,
 718             precision=3
 719             )
 720     ivyBranchSize = FloatProperty(
 721             name="Ivy Branch Size",
 722             description="The size of the ivy branches",
 723             default=0.001,
 724             min=0.0,
 725             soft_max=0.1,
 726             precision=4
 727             )
 728     maxFloatLength = FloatProperty(
 729             name="Max Float Length",
 730             description="The maximum distance that a branch "
 731                         "can live while floating",
 732             default=0.5,
 733             min=0.0,
 734             soft_max=1.0
 735             )
 736     maxAdhesionDistance = FloatProperty(
 737             name="Max Adhesion Length",
 738             description="The maximum distance that a branch "
 739                         "will feel the effects of adhesion",
 740             default=1.0,
 741             min=0.0,
 742             soft_max=2.0,
 743             precision=2
 744             )
 745     randomSeed = IntProperty(
 746             name="Random Seed",
 747             description="The seed governing random generation",
 748             default=0,
 749             min=0
 750             )
 751     maxTime = FloatProperty(
 752             name="Maximum Time",
 753             description="The maximum time to run the generation for "
 754                         "in seconds generation (0.0 = Disabled)",
 755             default=0.0,
 756             min=0.0,
 757             soft_max=10
 758             )
 759     growLeaves = BoolProperty(
 760             name="Grow Leaves",
 761             description="Grow leaves or not",
 762             default=True
 763             )
 764
 765
 766 classes = (
 767     IvyGen,
 768     IvyGenProperties,
 769     CURVE_PT_IvyGenPanel
 770 )
 771
 772
 773 def register():
 774     for cls in classes:
 775         bpy.utils.register_class(cls)
 776
 777     bpy.types.WindowManager.ivy_gen_props = PointerProperty(
 778             type=IvyGenProperties
 779             )
 780
 781
 782 def unregister():
 783     del bpy.types.WindowManager.ivy_gen_props
 784
 785     for cls in reversed(classes):
 786         bpy.utils.unregister_class(cls)
 787
 788
 789 if __name__ == "__main__":
 790     register()