No cvs freeze msg yet, so thought I could go with a last minute new script:

Scripts:
- license info for camera changer (thanks Tom for pointing), made it GPL since it's stricter and so can be "downgraded" w/o problems, but emailed the author to confirm and if necessary will fix before release.

- adding Discombobulator by Evan J. Rosky (in Mesh menu):
http://evan.nerdsofparadise.com/programs/discombobulator/index.html

This is a fun script to play with, giving quite interesting results.  It's good for that "high-tech" look in buildings, spaceships and walls.  Thanks Evan for contributing it.  GUI should have further updates in the future, like an added "horizontal" layout.  (Note: ignore mention in its online docs of a problem with edit mode, the script was fixed.)

1 files changed, 1229 insertions, 0 deletions

diff --git a/release/scripts/discombobulator.py b/release/scripts/discombobulator.py
new file mode 100644
index 00000000000..1128c51c731
--- /dev/null
+++ b/release/scripts/discombobulator.py
@@ -0,0 +1,1229 @@
+#!BPY
+
+"""
+Name: 'Discombobulator'
+Blender: 236
+Group: 'Mesh'
+Tip: 'Adds random geometry to a mesh'
+"""
+
+__author__ = "Evan J. Rosky (syrux)"
+__url__ = ("Script's homepage, http://evan.nerdsofparadise.com/programs/discombobulator/index.html")
+__version__ = "236"
+__bpydoc__ = """\
+Discombobulator adds random geometry to a mesh.
+
+As an example, this script can easily give a "high-tech"
+look to walls and spaceships.
+
+Definitions:<br>
+  - Protrusions: extrusions of each original face on the mesh.
+You may have from 1 to 4 protrusions on each face.<br>
+  - Taper: The tips of each protrusion will be a percentage
+smaller than the base.<br>
+  - Doodads: small extruded blocks/shapes that are randomly placed
+about the top of a protrusion or face.
+
+
+Usage:<br>
+  Input your settings, make sure the mesh you would like to modify
+is selected (active) and then click on "Discombobulate".
+
+Notes:<br>
+  - Modifications can be restricted to selected faces
+by setting "Only selected faces" for protrusions and/or
+doodads.<br>
+  - It's possible to restrict mesh generation to add only
+protrusions or only doodads instead of both.<br>
+  - You may also choose to have Discombobulator select the
+tops of created protrusions by clicking the corresponding
+number of protrusion buttons under "Select Tops". You may 
+also do the same for doodads by choosing "Select Doodads" and
+"Only Select Tops". You may choose to select the whole doodads 
+by leaving "Only Select Tops" off.<br>
+  - By selecting "Deselect Selected" you can have
+discombobulator deselect everything but the selections it
+makes.<br>
+  - The "Face %" option will set the percentage of faces that
+will be modified either for the doodads or the protrusions.<br>
+  - "Copy Before Modifying" will create a new object with the
+modifications where leaving it off will overwrite the original
+mesh.<br>
+
+You can find more information at the Link above.
+"""
+
+
+# $Id$
+#
+# --------------------------------------------------------------------------
+# Discombobulator v5.3.5.406893.potato
+# by Evan J. Rosky, 2005
+# This plugin is protected by the GPL: Gnu Public Licence
+# GPL - http://www.gnu.org/copyleft/gpl.html
+# --------------------------------------------------------------------------
+# ***** BEGIN GPL LICENSE BLOCK *****
+#
+# Copyright (C) 2005: Evan J. Rosky
+#
+# This program is free software; you can redistribute it and/or
+# modify it under the terms of the GNU General Public License
+# as published by the Free Software Foundation; either version 2
+# of the License, or (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.	See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software Foundation,
+# Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+#
+# ***** END GPL LICENCE BLOCK *****
+# --------------------------------------------------------------------------
+
+#Hit Alt-P to run
+
+import Blender
+from Blender import NMesh,Object,Material,Window
+from Blender.NMesh import Vert,Face
+from Blender.Mathutils import *
+
+import defaultdoodads
+import BPyMathutils
+from BPyMathutils import genrand
+a = BPyMathutils.sgenrand(int(round(Rand(1000,99999),0)))
+
+#Create random numbers
+def randnum(low,high):
+	num = genrand()
+	num = num*(high-low)
+	num = num+low
+	return num
+
+
+origmesh = NMesh.GetRaw()
+newmesh = NMesh.GetRaw()
+origobj = Object.Get()
+newobj = Object.Get()
+
+#Global Vars
+makenewobj = 1
+errortext = "Remember to select an object."
+editmode = 0
+
+#Protrusion Vars
+makeprots = 1
+faceschangedpercent = 1.0
+minimumheight = 0.2
+maximumheight = 0.4
+subface1 = 1
+subface2 = 1
+subface3 = 1
+subface4 = 1
+subfaceArray = [1,2,3,4]
+minsubfaces = 1
+minimumtaperpercent = 0.15
+maximumtaperpercent = 0.35
+useselectedfaces = 0
+selectface1 = 1
+selectface2 = 1
+selectface3 = 1
+selectface4 = 1
+deselface = 1
+#vertselected = 0
+
+#Doodad Vars
+makedoodads = 1
+doodadfacepercent = 1.0
+selectdoodad = 0
+onlyonprotrusions = 0
+doodonselectedfaces = 0
+selectdoodadtoponly = 0
+doodad1 = 1
+doodad2 = 1
+doodad3 = 1
+doodad4 = 1
+doodad5 = 1
+doodad6 = 1
+doodadminperface = 2
+doodadmaxperface = 6
+doodadminsize = 0.15
+doodadmaxsize = 0.45
+doodadminheight = 0.0
+doodadmaxheight = 0.1
+doodadArray = [1,2,3,4,5,6]
+
+SEL = NMesh.FaceFlags['SELECT']
+
+def isselectedface(theface):
+	for vertic in theface.v:
+		if vertic.sel == 0:
+			return 0
+	return 1
+
+def makeSubfaceArray():
+	global subfaceArray
+	global subface1
+	global subface2
+	global subface3
+	global subface4
+	
+	subfaceArray = []
+	if subface1 > 0:
+		subfaceArray.append(1)
+	if subface2 > 0:
+		subfaceArray.append(2)
+	if subface3 > 0:
+		subfaceArray.append(3)
+	if subface4 > 0:
+		subfaceArray.append(4)
+
+def makeDoodadArray():
+	global doodadArray
+	global doodad1
+	global doodad2
+	global doodad3
+	global doodad4
+	global doodad5
+	global doodad6
+	
+	doodadArray = []
+	if doodad1 > 0:
+		doodadArray.append(1)
+	if doodad2 > 0:
+		doodadArray.append(2)
+	if doodad3 > 0:
+		doodadArray.append(3)
+	if doodad4 > 0:
+		doodadArray.append(4)
+	if doodad5 > 0:
+		doodadArray.append(5)
+	if doodad6 > 0:
+		doodadArray.append(6)
+
+def copyObjStuff(startObj,endObj):
+	endObj.setDeltaLocation(startObj.getDeltaLocation())
+	endObj.setDrawMode(startObj.getDrawMode())
+	endObj.setDrawType(startObj.getDrawType())
+	endObj.setEuler(startObj.getEuler())
+	if(startObj.getIpo() != None):
+		endObj.setIpo(startObj.getIpo())
+	endObj.setLocation(startObj.getLocation())
+	endObj.setMaterials(startObj.getMaterials())
+	endObj.setMatrix(startObj.getMatrix())
+	endObj.setSize(startObj.getSize())
+	endObj.setTimeOffset(startObj.getTimeOffset())
+	
+
+def extrude(mid,nor,protrusion,v1,v2,v3,v4,tosel=1,flipnor=0):
+	taper = 1 - randnum(minimumtaperpercent,maximumtaperpercent)
+	
+	vert = newmesh.verts[v1]
+	point = (vert.co - mid)*taper + mid + protrusion*Vector(nor)
+	ver = Vert(point[0],point[1],point[2])
+	ver.sel = tosel
+	newmesh.verts.append(ver)
+	vert = newmesh.verts[v2]
+	point = (vert.co - mid)*taper + mid + protrusion*Vector(nor)
+	ver = Vert(point[0],point[1],point[2])
+	ver.sel = tosel
+	newmesh.verts.append(ver)
+	vert = newmesh.verts[v3]
+	point = (vert.co - mid)*taper + mid + protrusion*Vector(nor)
+	ver = Vert(point[0],point[1],point[2])
+	ver.sel = tosel
+	newmesh.verts.append(ver)
+	vert = newmesh.verts[v4]
+	point = (vert.co - mid)*taper + mid + protrusion*Vector(nor)
+	ver = Vert(point[0],point[1],point[2])
+	ver.sel = tosel
+	newmesh.verts.append(ver)
+	
+	faceindex = len(newmesh.verts) - 4
+	
+	#face 1
+	face = Face()
+	face.v.append(newmesh.verts[v1])
+	face.v.append(newmesh.verts[v2])
+	face.v.append(newmesh.verts[faceindex+1])
+	face.v.append(newmesh.verts[faceindex])
+	if flipnor != 0:
+		face.v.reverse()
+	newmesh.faces.append(face)
+	
+	#face 2
+	face = Face()
+	face.v.append(newmesh.verts[v2])
+	face.v.append(newmesh.verts[v3])
+	face.v.append(newmesh.verts[faceindex+2])
+	face.v.append(newmesh.verts[faceindex+1])
+	if flipnor != 0:
+		face.v.reverse()
+	newmesh.faces.append(face)
+	
+	#face 3
+	face = Face()
+	face.v.append(newmesh.verts[v3])
+	face.v.append(newmesh.verts[v4])
+	face.v.append(newmesh.verts[faceindex+3])
+	face.v.append(newmesh.verts[faceindex+2])
+	if flipnor != 0:
+		face.v.reverse()
+	newmesh.faces.append(face)
+	
+	#face 4
+	face = Face()
+	face.v.append(newmesh.verts[v4])
+	face.v.append(newmesh.verts[v1])
+	face.v.append(newmesh.verts[faceindex])
+	face.v.append(newmesh.verts[faceindex+3])
+	if flipnor != 0:
+		face.v.reverse()
+	newmesh.faces.append(face)
+		
+	face = Face()
+	face.v = newmesh.verts[-4:]
+	if flipnor != 0:
+		face.v.reverse()
+	if tosel == 1:
+		face.sel = 1
+	newmesh.faces.append(face)
+	return face
+
+def discombobulate(p0,p1,p2,p3,p4,p5,p6,p7,p8,p9,p10,p11,p12,p13,p14,p15,g0,d0,d1,d2,d3,d4,d5,d6,d7,d8,d9,d10,d11,d12,d13,d14,d15,d16,d17):
+	
+	#Global
+	global origmesh
+	global newmesh
+	global makenewobj
+	global origobj
+	global newobj
+	global messagetext
+	global errortext
+	global editmode
+	
+	#Protrusions
+	global makeprots
+	global minimumtaperpercent
+	global maximumtaperpercent
+	global faceschangedpercent
+	global minimumheight
+	global maximumheight
+	global subface1
+	global subface2
+	global subface3
+	global subface4
+	global useselectedfaces
+	global selectface1
+	global selectface2
+	global selectface3
+	global selectface4
+	global deselface
+	#global vertselected
+	global subfaceArray
+	
+	#Doodads
+	global makedoodads
+	global doodadfacepercent
+	global selectdoodad
+	global onlyonprotrusions
+	global doodad1
+	global doodad2
+	global doodad3
+	global doodad4
+	global doodad5
+	global doodad6
+	global doodadminperface
+	global doodadmaxperface
+	global doodadminsize
+	global doodadmaxsize
+	global doodadminheight
+	global doodadmaxheight
+	global doodadArray
+	global doodonselectedfaces
+	global selectdoodadtoponly
+	
+	#Global
+	try:
+		origobj = Object.GetSelected()[0]
+	except:
+		glRasterPos2d(10,50)
+		errortext = "YOU MUST SELECT AN OBJECT!"
+		messagetext = ErrorText(errortext)
+		Blender.Redraw()
+		return
+
+	#Leave Editmode
+	editmode = Window.EditMode()
+	if editmode: Window.EditMode(0)
+
+	newobj = Object.Get()
+	origmesh = origobj.getData()
+	newmesh = NMesh.GetRaw()
+	newmesh.verts = []
+	makenewobj = g0
+	
+	#Protrusions
+	makeprots = p0
+	faceschangedpercent = p1
+	minimumheight = p2
+	maximumheight = p3
+	subface1 = p4
+	subface2 = p5
+	subface3 = p6
+	subface4 = p7
+	minimumtaperpercent = p8
+	maximumtaperpercent = p9
+	useselectedfaces = p10
+	selectface1 = p11
+	selectface2 = p12
+	selectface3 = p13
+	selectface4 = p14
+	deselface = p15
+	makeSubfaceArray()
+	if len(subfaceArray) == 0:
+		makeprots = 0
+	
+	
+	#Doodads
+	makedoodads = d0
+	doodadfacepercent = d1
+	selectdoodad = d2
+	onlyonprotrusions = d3
+	doodad1 = d4
+	doodad2 = d5
+	doodad3 = d6
+	doodad4 = d7
+	doodad5 = d8
+	doodad6 = d9
+	doodadminperface = d10
+	doodadmaxperface = d11
+	doodadminsize = d12
+	doodadmaxsize = d13
+	doodadminheight = d14
+	doodadmaxheight = d15
+	doodonselectedfaces = d16
+	selectdoodadtoponly = d17
+	makeDoodadArray()
+	if len(doodadArray) == 0:
+		makedoodads = 0
+	defaultdoodads.topsonly(selectdoodadtoponly)
+	
+	if minimumheight > maximumheight:
+		glColor3f(1.0,0.0,0.0)
+		glRasterPos2d(10,50)
+		errortext = "MIN HEIGHT MUST BE LESS THAN OR EQUAL TO MAX HEIGHT!"
+		messagetext = ErrorText(errortext)
+		Blender.Redraw()
+		return
+	elif minimumtaperpercent > maximumtaperpercent:
+		glColor3f(1.0,0.0,0.0)
+		glRasterPos2d(10,50)
+		errortext = "MIN TAPER MUST BE LESS THAN OR EQUAL TO MAX TAPER!"
+		messagetext = ErrorText(errortext)
+		Blender.Redraw()
+		return
+	elif doodadminperface > doodadmaxperface:
+		glColor3f(1.0,0.0,0.0)
+		glRasterPos2d(10,50)
+		errortext = "MIN NUMBER OF DOODADS MUST BE LESS THAN OR EQUAL TO MAX!"
+		messagetext = ErrorText(errortext)
+		Blender.Redraw()
+		return
+	elif doodadminsize > doodadmaxsize:
+		glColor3f(1.0,0.0,0.0)
+		glRasterPos2d(10,50)
+		errortext = "MIN DOODAD SIZE MUST BE LESS THAN OR EQUAL TO MAX!"
+		messagetext = ErrorText(errortext)
+		Blender.Redraw()
+		return
+	elif doodadminheight > doodadmaxheight:
+		glColor3f(1.0,0.0,0.0)
+		glRasterPos2d(10,50)
+		errortext = "MIN DOODAD HEIGHT MUST BE LESS THAN OR EQUAL TO MAX!"
+		messagetext = ErrorText(errortext)
+		Blender.Redraw()
+		return
+	
+	newmesh.verts.extend(origmesh.verts)
+	
+	for currface in origmesh.faces:
+		
+		#Check if it is a triangle
+		if len(currface.v)<4:
+			face = Face()
+			face.v.extend([newmesh.verts[currface.v[0].index],newmesh.verts[currface.v[1].index],newmesh.verts[currface.v[2].index]])
+			newmesh.faces.append(face)
+			continue
+		
+		#Check whether or not to make protrusions
+		if makeprots == 0:
+			face = Face()
+			face.v.extend([newmesh.verts[currface.v[0].index],newmesh.verts[currface.v[1].index],newmesh.verts[currface.v[2].index],newmesh.verts[currface.v[3].index]])
+			newmesh.faces.append(face)
+			if makedoodads == 1 and onlyonprotrusions == 0:
+				if doodonselectedfaces == 1:
+					if currface.sel:
+						tempmesh = NMesh.GetRaw()
+						tempmesh = defaultdoodads.createDoodad(doodadArray,face, doodadminsize, doodadmaxsize, doodadminheight,doodadmaxheight, selectdoodad, doodadminperface, doodadmaxperface, doodadfacepercent)
+						newmesh.verts.extend(tempmesh.verts)
+						newmesh.faces.extend(tempmesh.faces)
+				else:
+					tempmesh = NMesh.GetRaw()
+					tempmesh = defaultdoodads.createDoodad(doodadArray,face, doodadminsize, doodadmaxsize, doodadminheight,doodadmaxheight, selectdoodad, doodadminperface, doodadmaxperface, doodadfacepercent)
+					newmesh.verts.extend(tempmesh.verts)
+					newmesh.faces.extend(tempmesh.faces)
+			continue
+		
+		#Check if only changing selected faces
+		if useselectedfaces == 1:
+			#check if currface is selected
+			if currface.sel:
+				a = 1
+			else:
+				face = Face()
+				face.v.extend([newmesh.verts[currface.v[0].index],newmesh.verts[currface.v[1].index],newmesh.verts[currface.v[2].index],newmesh.verts[currface.v[3].index]])
+				newmesh.faces.append(face)
+				if makedoodads == 1 and onlyonprotrusions == 0:
+					if doodonselectedfaces != 1:
+						tempmesh = NMesh.GetRaw()
+						tempmesh = defaultdoodads.createDoodad(doodadArray,face, doodadminsize, doodadmaxsize, doodadminheight,doodadmaxheight, selectdoodad, doodadminperface, doodadmaxperface, doodadfacepercent)
+						newmesh.verts.extend(tempmesh.verts)
+						newmesh.faces.extend(tempmesh.faces)
+				continue
+		#Check if face should be modified by random chance
+		if randnum(0,1)>faceschangedpercent: 
+			face = Face()
+			face.v.extend([newmesh.verts[currface.v[0].index],newmesh.verts[currface.v[1].index],newmesh.verts[currface.v[2].index],newmesh.verts[currface.v[3].index]])
+			newmesh.faces.append(face)
+			if makedoodads == 1 and onlyonprotrusions == 0:
+				if doodonselectedfaces == 1:
+					if currface.sel:
+						tempmesh = NMesh.GetRaw()
+						tempmesh = defaultdoodads.createDoodad(doodadArray,face, doodadminsize, doodadmaxsize, doodadminheight,doodadmaxheight, selectdoodad, doodadminperface, doodadmaxperface, doodadfacepercent)
+						newmesh.verts.extend(tempmesh.verts)
+						newmesh.faces.extend(tempmesh.faces)
+				else:
+					tempmesh = NMesh.GetRaw()
+					tempmesh = defaultdoodads.createDoodad(doodadArray,face, doodadminsize, doodadmaxsize, doodadminheight,doodadmaxheight, selectdoodad, doodadminperface, doodadmaxperface, doodadfacepercent)
+					newmesh.verts.extend(tempmesh.verts)
+					newmesh.faces.extend(tempmesh.faces)
+			continue
+		
+		center = Vector([0,0,0])
+		for pt in currface.v:
+			center = center + pt.co
+		center = center/len(currface.v)
+		
+		#Determine amount of subfaces
+		subfaces = round(randnum(1,len(subfaceArray)),0)
+		subfaces = subfaceArray[(int(subfaces) - 1)]
+		
+		if subfaces == 1:
+			prot = randnum(minimumheight,maximumheight)
+			tempface = extrude(center,currface.no,prot,currface.v[0].index,currface.v[1].index,currface.v[2].index,currface.v[3].index,selectface1)
+			if makedoodads == 1:
+				if doodonselectedfaces == 1:
+					if currface.sel:
+						tempmesh = NMesh.GetRaw()
+						tempmesh = defaultdoodads.createDoodad(doodadArray, tempface, doodadminsize, doodadmaxsize, doodadminheight,doodadmaxheight, selectdoodad, doodadminperface, doodadmaxperface, doodadfacepercent)
+						newmesh.verts.extend(tempmesh.verts)
+						newmesh.faces.extend(tempmesh.faces)
+				else:
+					tempmesh = NMesh.GetRaw()
+					tempmesh = defaultdoodads.createDoodad(doodadArray, tempface, doodadminsize, doodadmaxsize, doodadminheight,doodadmaxheight, selectdoodad, doodadminperface, doodadmaxperface, doodadfacepercent)
+					newmesh.verts.extend(tempmesh.verts)
+					newmesh.faces.extend(tempmesh.faces)
+		
+		elif subfaces == 2:
+			orientation = int(round(randnum(0,1)))
+			p1 = currface.v[orientation]
+			p2 = currface.v[orientation + 1]
+			p3 = (p2.co - p1.co)/2 + p1.co
+			ve1 = Vert(p3[0],p3[1],p3[2])
+			ve1.sel = 0
+			p1 = currface.v[2 + orientation]
+			if orientation < 0.5:
+				p2 = currface.v[3]
+			else:
+				p2 = currface.v[0]
+			p3 = (p2.co - p1.co)/2 + p1.co
+			ve2 = Vert(p3[0],p3[1],p3[2])
+			ve2.sel = 0
+			if orientation < 0.5:
+				verti = currface.v[3]
+				p3 = verti.index
+				v1 = p3
+				verti = currface.v[0]
+				p0 = verti.index
+				v2 = p0
+			else:
+				verti = currface.v[0]
+				p0 = verti.index
+				v1 = p0
+				verti = currface.v[1]
+				p1 = verti.index
+				v2 = p1
+			newmesh.verts.append(ve1)
+			newmesh.verts.append(ve2)
+			index = len(newmesh.verts) - 2
+			v4 = index + 1
+			v3 = index
+			center = Vector([0, 0, 0])
+			for pt in [newmesh.verts[v1],newmesh.verts[v2],newmesh.verts[v3],newmesh.verts[v4]]:
+				center = center + pt.co
+			center = center/4
+			prot = randnum(minimumheight,maximumheight)
+			tempface = extrude(center,currface.no,prot,v1,v2,v3,v4,selectface2)
+			if makedoodads == 1:
+				if doodonselectedfaces == 1:
+					if currface.sel:
+						tempmesh = NMesh.GetRaw()
+						tempmesh = defaultdoodads.createDoodad(doodadArray, tempface, doodadminsize, doodadmaxsize, doodadminheight,doodadmaxheight, selectdoodad, doodadminperface, doodadmaxperface, doodadfacepercent)
+						newmesh.verts.extend(tempmesh.verts)
+						newmesh.faces.extend(tempmesh.faces)
+				else:
+					tempmesh = NMesh.GetRaw()
+					tempmesh = defaultdoodads.createDoodad(doodadArray, tempface, doodadminsize, doodadmaxsize, doodadminheight,doodadmaxheight, selectdoodad, doodadminperface, doodadmaxperface, doodadfacepercent)
+					newmesh.verts.extend(tempmesh.verts)
+					newmesh.faces.extend(tempmesh.faces)
+			if orientation < 0.5:
+				verti = currface.v[1]
+				p1 = verti.index
+				v1 = p1
+				verti = currface.v[2]
+				p2 = verti.index
+				v2 = p2
+			else:
+				verti = currface.v[2]
+				p2 = verti.index
+				v1 = p2
+				verti = currface.v[3]
+				p3 = verti.index
+				v2 = p3
+			center = Vector([0]*3)
+			for pt in [newmesh.verts[v1],newmesh.verts[v2],newmesh.verts[v3],newmesh.verts[v4]]:
+				center = center + pt.co
+			center = center/4
+			prot = randnum(minimumheight,maximumheight)
+			tempface = extrude(center,currface.no,prot,v1,v2,v4,v3,selectface2)
+			if makedoodads == 1:
+				if doodonselectedfaces == 1:
+					if currface.sel:
+						tempmesh = NMesh.GetRaw()
+						tempmesh = defaultdoodads.createDoodad(doodadArray, tempface, doodadminsize, doodadmaxsize, doodadminheight,doodadmaxheight, selectdoodad, doodadminperface, doodadmaxperface, doodadfacepercent)
+						newmesh.verts.extend(tempmesh.verts)
+						newmesh.faces.extend(tempmesh.faces)
+				else:
+					tempmesh = NMesh.GetRaw()
+					tempmesh = defaultdoodads.createDoodad(doodadArray, tempface, doodadminsize, doodadmaxsize, doodadminheight,doodadmaxheight, selectdoodad, doodadminperface, doodadmaxperface, doodadfacepercent)
+					newmesh.verts.extend(tempmesh.verts)
+					newmesh.faces.extend(tempmesh.faces)
+			if orientation < 0.5:
+				face = Face()
+				face.v.extend([newmesh.verts[p0],newmesh.verts[p1],newmesh.verts[v3]])
+				newmesh.faces.append(face)
+				face = Face()
+				face.v.extend([newmesh.verts[p2],newmesh.verts[p3],newmesh.verts[v4]])
+				newmesh.faces.append(face)
+			else:
+				face = Face()
+				face.v.extend([newmesh.verts[p1],newmesh.verts[p2],newmesh.verts[v3]])
+				newmesh.faces.append(face)
+				face = Face()
+				face.v.extend([newmesh.verts[p3],newmesh.verts[p0],newmesh.verts[v4]])
+				newmesh.faces.append(face)
+			
+		elif subfaces == 3:
+			layer2inds = []
+			layer2verts = []
+			orientation = int(round(randnum(0,1)))
+			rotation = int(round(randnum(0,1)))
+			p1 = currface.v[orientation]
+			p2 = currface.v[orientation + 1]
+			p3 = (p2.co - p1.co)/2 + p1.co
+			ve1 = Vert(p3[0],p3[1],p3[2])
+			ve1.sel = 0
+			p1 = currface.v[2 + orientation]
+			if orientation < 0.5:
+				p2 = currface.v[3]
+			else:
+				p2 = currface.v[0]
+			p3 = (p2.co - p1.co)/2 + p1.co
+			ve2 = Vert(p3[0],p3[1],p3[2])
+			ve2.sel = 0
+			fp = []
+	
+			#make first protrusion
+			if rotation < 0.5:
+				if orientation < 0.5:
+					verti = currface.v[3]
+					fp.append(verti.index)
+					v1 = verti.index
+					verti = currface.v[0]
+					fp.append(verti.index)
+					v2 = verti.index
+					layer2verts.extend([newmesh.verts[currface.v[1].index],newmesh.verts[currface.v[2].index]])
+				else:
+					verti = currface.v[0]
+					fp.append(verti.index)
+					v1 = verti.index
+					verti = currface.v[1]
+					fp.append(verti.index)
+					v2 = verti.index
+					layer2verts.extend([newmesh.verts[currface.v[2].index],newmesh.verts[currface.v[3].index]])
+				newmesh.verts.append(ve1)
+				newmesh.verts.append(ve2)
+				index = len(newmesh.verts) - 2
+				v4 = index + 1
+				v3 = index
+				center = Vector([0]*3)
+				for pt in [newmesh.verts[v1],newmesh.verts[v2],newmesh.verts[v3],newmesh.verts[v4]]:
+					center = center + pt.co
+				center = center/4
+				prot = randnum(minimumheight,maximumheight)
+				layer2inds.extend([v3,v4])
+				tempface = extrude(center,currface.no,prot,v1,v2,v3,v4,selectface3)
+				if makedoodads == 1:
+					if doodonselectedfaces == 1:
+						if currface.sel:
+							tempmesh = NMesh.GetRaw()
+							tempmesh = defaultdoodads.createDoodad(doodadArray, tempface, doodadminsize, doodadmaxsize, doodadminheight,doodadmaxheight, selectdoodad, doodadminperface, doodadmaxperface, doodadfacepercent)
+							newmesh.verts.extend(tempmesh.verts)
+							newmesh.faces.extend(tempmesh.faces)
+					else:
+						tempmesh = NMesh.GetRaw()
+						tempmesh = defaultdoodads.createDoodad(doodadArray, tempface, doodadminsize, doodadmaxsize, doodadminheight,doodadmaxheight, selectdoodad, doodadminperface, doodadmaxperface, doodadfacepercent)
+						newmesh.verts.extend(tempmesh.verts)
+						newmesh.faces.extend(tempmesh.faces)
+			#Still first protrusion
+			else:
+				if orientation < 0.5:
+					verti = currface.v[1]
+					fp.append(verti.index)
+					v1 = verti.index
+					verti = currface.v[2]
+					fp.append(verti.index)
+					v2 = verti.index
+					layer2verts.extend([newmesh.verts[currface.v[0].index],newmesh.verts[currface.v[3].index]])
+				else:
+					verti = currface.v[2]
+					fp.append(verti.index)
+					v1 = verti.index
+					verti = currface.v[3]
+					fp.append(verti.index)
+					v2 = verti.index
+					layer2verts.extend([newmesh.verts[currface.v[1].index],newmesh.verts[currface.v[0].index]])
+				newmesh.verts.append(ve2)
+				newmesh.verts.append(ve1)
+				index = len(newmesh.verts) - 2
+				v4 = index
+				v3 = index + 1
+				center = Vector([0]*3)
+				for pt in [newmesh.verts[v1],newmesh.verts[v2],newmesh.verts[v3],newmesh.verts[v4]]:
+					center = center + pt.co
+				center = center/4
+				prot = randnum(minimumheight,maximumheight)
+				layer2inds.extend([index, index +1])
+				tempface = extrude(center,currface.no,prot,v1,v2,v4,v3,selectface3)
+				if makedoodads == 1:
+					if doodonselectedfaces == 1:
+						if currface.sel:
+							tempmesh = NMesh.GetRaw()
+							tempmesh = defaultdoodads.createDoodad(doodadArray, tempface, doodadminsize, doodadmaxsize, doodadminheight,doodadmaxheight, selectdoodad, doodadminperface, doodadmaxperface, doodadfacepercent)
+							newmesh.verts.extend(tempmesh.verts)
+							newmesh.faces.extend(tempmesh.faces)
+					else:
+						tempmesh = NMesh.GetRaw()
+						tempmesh = defaultdoodads.createDoodad(doodadArray, tempface, doodadminsize, doodadmaxsize, doodadminheight,doodadmaxheight, selectdoodad, doodadminperface, doodadmaxperface, doodadfacepercent)
+						newmesh.verts.extend(tempmesh.verts)
+						newmesh.faces.extend(tempmesh.faces)
+			
+			#split next rect(pre-arranged, no orientation crud)--make flag in extruder for only one existing vert in mesh
+			p1 = newmesh.verts[layer2inds[0]]
+			p2 = newmesh.verts[layer2inds[1]]
+			p3 = (p2.co - p1.co)/2 + p1.co
+			ve3 = Vert(p3[0],p3[1],p3[2])
+			ve3.sel = 0
+			p1 = layer2verts[0]
+			p2 = layer2verts[1]
+			p3 = (p2.co - p1.co)/2 + p1.co
+			ve4 = Vert(p3[0],p3[1],p3[2])
+			ve4.sel = 0
+			newmesh.verts.append(ve3)
+			newmesh.verts.append(ve4)
+			tempindex = len(newmesh.verts) - 2
+			v5 = tempindex
+			v6 = tempindex + 1
+			verti = layer2verts[0]
+			t0 = verti.index
+			center = Vector([0]*3)
+			for pt in [newmesh.verts[v5],newmesh.verts[v6],newmesh.verts[t0],newmesh.verts[v3]]:
+				center = center + pt.co
+			center = center/4
+			prot = randnum(minimumheight,maximumheight)
+			if rotation < 0.5: flino = 1
+			else: flino = 0
+			tempface = extrude(center,currface.no,prot,v3,v5,v6,t0,selectface3,flino)
+			if makedoodads == 1:
+				if doodonselectedfaces == 1:
+					if currface.sel:
+						tempmesh = NMesh.GetRaw()
+						tempmesh = defaultdoodads.createDoodad(doodadArray, tempface, doodadminsize, doodadmaxsize, doodadminheight,doodadmaxheight, selectdoodad, doodadminperface, doodadmaxperface, doodadfacepercent)
+						newmesh.verts.extend(tempmesh.verts)
+						newmesh.faces.extend(tempmesh.faces)
+					tempmesh = NMesh.GetRaw()
+					tempmesh = defaultdoodads.createDoodad(doodadArray, tempface, doodadminsize, doodadmaxsize, doodadminheight,doodadmaxheight, selectdoodad, doodadminperface, doodadmaxperface, doodadfacepercent)
+					newmesh.verts.extend(tempmesh.verts)
+					newmesh.faces.extend(tempmesh.faces)
+			if rotation < 0.5:
+				face = Face()
+				fpt = t0
+				face.v.extend([newmesh.verts[fp[1]],newmesh.verts[fpt],newmesh.verts[v3]])
+				newmesh.faces.append(face)
+			else:
+				face = Face()
+				fpt = t0
+				face.v.extend([newmesh.verts[fp[0]],newmesh.verts[v3],newmesh.verts[fpt]])
+				newmesh.faces.append(face)
+			verti = layer2verts[1]
+			tempindex = verti.index
+			center = Vector([0]*3)
+			for pt in [newmesh.verts[v5],newmesh.verts[v6],newmesh.verts[tempindex],newmesh.verts[v4]]:
+				center = center + pt.co
+			center = center/4
+			prot = randnum(minimumheight,maximumheight)
+			tempface = extrude(center,currface.no,prot,v6,v5,v4,tempindex,selectface3,flino)
+			if makedoodads == 1:
+				if doodonselectedfaces == 1:
+					if currface.sel:
+						tempmesh = NMesh.GetRaw()
+						tempmesh = defaultdoodads.createDoodad(doodadArray, tempface, doodadminsize, doodadmaxsize, doodadminheight,doodadmaxheight, selectdoodad, doodadminperface, doodadmaxperface, doodadfacepercent)
+						newmesh.verts.extend(tempmesh.verts)
+						newmesh.faces.extend(tempmesh.faces)
+				else:
+					tempmesh = NMesh.GetRaw()
+					tempmesh = defaultdoodads.createDoodad(doodadArray, tempface, doodadminsize, doodadmaxsize, doodadminheight,doodadmaxheight, selectdoodad, doodadminperface, doodadmaxperface, doodadfacepercent)
+					newmesh.verts.extend(tempmesh.verts)
+					newmesh.faces.extend(tempmesh.faces)
+			if rotation < 0.5:
+				face = Face()
+				face.v.extend([newmesh.verts[tempindex],newmesh.verts[fp[0]],newmesh.verts[v4]])
+				newmesh.faces.append(face)
+				face = Face()
+				face.v.extend([newmesh.verts[fpt],newmesh.verts[tempindex],newmesh.verts[v6]])
+				newmesh.faces.append(face)
+			else:
+				face = Face()
+				face.v.extend([newmesh.verts[tempindex],newmesh.verts[v4],newmesh.verts[fp[1]]])
+				newmesh.faces.append(face)
+				face = Face()
+				face.v.extend([newmesh.verts[tempindex],newmesh.verts[fpt],newmesh.verts[v6]])
+				newmesh.faces.append(face)
+			
+		else:
+			#get all points
+			verti = currface.v[0]
+			p0 = verti.index
+			
+			verti = currface.v[1]
+			p1 = verti.index
+		
+			pt = (newmesh.verts[p1].co - newmesh.verts[p0].co)/2 + newmesh.verts[p0].co
+			v1 = Vert(pt[0],pt[1],pt[2])
+			v1.sel = 0
+	
+			verti = currface.v[2]
+			p2 = verti.index
+
+			pt = (newmesh.verts[p2].co - newmesh.verts[p1].co)/2 + newmesh.verts[p1].co
+			v2 = Vert(pt[0],pt[1],pt[2])
+			v2.sel = 0
+
+			verti = currface.v[3]
+			p3 = verti.index
+
+			pt = (newmesh.verts[p3].co - newmesh.verts[p2].co)/2 + newmesh.verts[p2].co
+			v3 = Vert(pt[0],pt[1],pt[2])
+			v3.sel = 0
+
+			pt = (newmesh.verts[p0].co - newmesh.verts[p3].co)/2 + newmesh.verts[p3].co
+			v4 = Vert(pt[0],pt[1],pt[2])
+			v4.sel = 0
+
+			pt = (v3.co - v1.co)/2 + v1.co
+			m = Vert(pt[0],pt[1],pt[2])
+			m.sel = 0
+			
+			#extrusion 1
+			newmesh.verts.extend([v1,m,v4])
+			index = len(newmesh.verts) - 3
+			v1 = index
+			m = index + 1
+			v4 = index + 2
+			center = Vector([0]*3)
+			for pt in [newmesh.verts[p0],newmesh.verts[v1],newmesh.verts[m],newmesh.verts[v4]]:
+				center = center + pt.co
+			center = center/4
+			prot = randnum(minimumheight,maximumheight)
+			tempface = extrude(center,currface.no,prot,p0,v1,m,v4,selectface4)
+			if makedoodads == 1:
+				if doodonselectedfaces == 1:
+					if currface.sel:
+						tempmesh = NMesh.GetRaw()
+						tempmesh = defaultdoodads.createDoodad(doodadArray, tempface, doodadminsize, doodadmaxsize, doodadminheight,doodadmaxheight, selectdoodad, doodadminperface, doodadmaxperface, doodadfacepercent)
+						newmesh.verts.extend(tempmesh.verts)
+						newmesh.faces.extend(tempmesh.faces)
+				else:
+					tempmesh = NMesh.GetRaw()
+					tempmesh = defaultdoodads.createDoodad(doodadArray, tempface, doodadminsize, doodadmaxsize, doodadminheight,doodadmaxheight, selectdoodad, doodadminperface, doodadmaxperface, doodadfacepercent)
+					newmesh.verts.extend(tempmesh.verts)
+					newmesh.faces.extend(tempmesh.faces)
+			
+			#extrusion 2
+			newmesh.verts.extend([v2])
+			index = len(newmesh.verts) - 1
+			v2 = index
+			center = Vector([0]*3)
+			for pt in [newmesh.verts[m],newmesh.verts[v1],newmesh.verts[p1],newmesh.verts[v2]]:
+				center = center + pt.co
+			center = center/4
+			prot = randnum(minimumheight,maximumheight)
+			tempface = extrude(center,currface.no,prot,m,v1,p1,v2,selectface4)
+			if makedoodads == 1:
+				if doodonselectedfaces == 1:
+					if currface.sel:
+						tempmesh = NMesh.GetRaw()
+						tempmesh = defaultdoodads.createDoodad(doodadArray, tempface, doodadminsize, doodadmaxsize, doodadminheight,doodadmaxheight, selectdoodad, doodadminperface, doodadmaxperface, doodadfacepercent)
+						newmesh.verts.extend(tempmesh.verts)
+						newmesh.faces.extend(tempmesh.faces)
+				else:
+					tempmesh = NMesh.GetRaw()
+					tempmesh = defaultdoodads.createDoodad(doodadArray, tempface, doodadminsize, doodadmaxsize, doodadminheight,doodadmaxheight, selectdoodad, doodadminperface, doodadmaxperface, doodadfacepercent)
+					newmesh.verts.extend(tempmesh.verts)
+					newmesh.faces.extend(tempmesh.faces)
+			
+			#extrusion 3
+			newmesh.verts.extend([v3])
+			index = len(newmesh.verts) - 1
+			v3 = index
+			center = Vector([0]*3)
+			for pt in [newmesh.verts[m],newmesh.verts[v2],newmesh.verts[p2],newmesh.verts[v3]]:
+				center = center + pt.co
+			center = center/4
+			prot = randnum(minimumheight,maximumheight)
+			tempface = extrude(center,currface.no,prot,m,v2,p2,v3,selectface4)
+			if makedoodads == 1:
+				if doodonselectedfaces == 1:
+					if currface.sel:
+						tempmesh = NMesh.GetRaw()
+						tempmesh = defaultdoodads.createDoodad(doodadArray, tempface, doodadminsize, doodadmaxsize, doodadminheight,doodadmaxheight, selectdoodad, doodadminperface, doodadmaxperface, doodadfacepercent)
+						newmesh.verts.extend(tempmesh.verts)
+						newmesh.faces.extend(tempmesh.faces)
+				else:
+					tempmesh = NMesh.GetRaw()
+					tempmesh = defaultdoodads.createDoodad(doodadArray, tempface, doodadminsize, doodadmaxsize, doodadminheight,doodadmaxheight, selectdoodad, doodadminperface, doodadmaxperface, doodadfacepercent)
+					newmesh.verts.extend(tempmesh.verts)
+					newmesh.faces.extend(tempmesh.faces)
+			
+			#extrusion 4
+			center = Vector([0]*3)
+			for pt in [newmesh.verts[m],newmesh.verts[v3],newmesh.verts[p3],newmesh.verts[v4]]:
+				center = center + pt.co
+			center = center/4
+			prot = randnum(minimumheight,maximumheight)
+			tempface = extrude(center,currface.no,prot,v4,m,v3,p3,selectface4)
+			if makedoodads == 1:
+				if doodonselectedfaces == 1:
+					if currface.sel:
+						tempmesh = NMesh.GetRaw()
+						tempmesh = defaultdoodads.createDoodad(doodadArray, tempface, doodadminsize, doodadmaxsize, doodadminheight,doodadmaxheight, selectdoodad, doodadminperface, doodadmaxperface, doodadfacepercent)
+						newmesh.verts.extend(tempmesh.verts)
+						newmesh.faces.extend(tempmesh.faces)
+				else:
+					tempmesh = NMesh.GetRaw()
+					tempmesh = defaultdoodads.createDoodad(doodadArray, tempface, doodadminsize, doodadmaxsize, doodadminheight,doodadmaxheight, selectdoodad, doodadminperface, doodadmaxperface, doodadfacepercent)
+					newmesh.verts.extend(tempmesh.verts)
+					newmesh.faces.extend(tempmesh.faces)
+			
+			face = Face()
+			face.v.extend([newmesh.verts[p0],newmesh.verts[p1],newmesh.verts[v1]])
+			newmesh.faces.append(face)
+			face = Face()
+			face.v.extend([newmesh.verts[p1],newmesh.verts[p2],newmesh.verts[v2]])
+			newmesh.faces.append(face)
+			face = Face()
+			face.v.extend([newmesh.verts[p2],newmesh.verts[p3],newmesh.verts[v3]])
+			newmesh.faces.append(face)
+			face = Face()
+			face.v.extend([newmesh.verts[p3],newmesh.verts[p0],newmesh.verts[v4]])
+			newmesh.faces.append(face)
+			
+	#NMesh.PutRaw(newmesh)
+	if deselface == 1:
+		for unvert in origmesh.verts:
+			newmesh.verts[unvert.index].sel = 0
+	if makenewobj == 1:
+		newobj = Object.New('Mesh')
+		copyObjStuff(origobj,newobj)
+		newobj.link(newmesh)
+		scene = Blender.Scene.getCurrent()
+		scene.link(newobj)
+		origobj.select(0)
+		newobj.select(1)
+	else:
+		origobj.link(newmesh)
+	
+	#Return to Editmode if previously in it
+	if editmode: Window.EditMode(1)
+
+
+####################### gui ######################
+from Blender.BGL import *
+from Blender.Draw import *
+
+def ErrorText(errortext):
+	Window.WaitCursor(0)
+	Text(errortext)
+	PupMenu("ERROR: %s" % errortext.lower())
+
+#Global Buttons
+makenewobject = Create(makenewobj)
+messagetext = Create(errortext)
+
+#Protrusion Buttons
+doprots = Create(makeprots)
+facechange = Create(faceschangedpercent*100)
+minheight = Create(minimumheight)
+maxheight = Create(maximumheight)
+sub1 = Create(subface1)
+sub2 = Create(subface2)
+sub3 = Create(subface3)
+sub4 = Create(subface4)
+mintaper = Create(minimumtaperpercent*100)
+maxtaper = Create(maximumtaperpercent*100)
+useselected = Create(useselectedfaces)
+selface1 = Create(selectface1)
+selface2 = Create(selectface2)
+selface3 = Create(selectface3)
+selface4 = Create(selectface4)
+deselectvertices = Create(deselface)
+#selectbyverts = Create(vertselected)
+
+#Doodad Buttons
+dodoodads = Create(makedoodads)
+doodadfacechange = Create(doodadfacepercent*100)
+seldoodad = Create(selectdoodad)
+onprot = Create(onlyonprotrusions)
+dood1 = Create(doodad1)
+dood2 = Create(doodad2)
+dood3 = Create(doodad3)
+dood4 = Create(doodad4)
+dood5 = Create(doodad5)
+dood6 = Create(doodad6)
+doodadminamount = Create(doodadminperface)
+doodadmaxamount = Create(doodadmaxperface)
+doodsizemin = Create(doodadminsize*100)
+doodsizemax = Create(doodadmaxsize*100)
+doodheightmin = Create(doodadminheight)
+doodheightmax = Create(doodadmaxheight)
+doodonselface = Create(doodonselectedfaces)
+seldoodtop = Create(selectdoodadtoponly)
+
+
+# Events
+EVENT_NONE = 1
+EVENT_DISCOMBOBULATE = 2
+EVENT_EXIT = 3
+
+def colorbox(x,y,xright,bottom):
+   glColor3f(0.75, 0.75, 0.75)
+   glRecti(x + 1, y + 1, xright - 1, bottom - 1)
+
+def draw():
+	
+	#Protrusions
+	global doprots
+	global facechange
+	global minheight
+	global maxheight
+	global sub1
+	global sub2
+	global sub3
+	global sub4
+	global mintaper
+	global maxtaper
+	global useselected
+	global selface1
+	global selface2
+	global selface3
+	global selface4
+	global deselectvertices
+	#global selectbyverts
+	
+	#Doodads
+	global dodoodads
+	global doodadfacechange
+	global seldoodad
+	global onprot
+	global dood1
+	global dood2
+	global dood3
+	global dood4
+	global dood5
+	global dood6
+	global doodadminamount
+	global doodadmaxamount
+	global doodsizemin
+	global doodsizemax
+	global doodheightmin
+	global doodheightmax
+	global doodonselface
+	global seldoodtop
+	
+	#Global Settings
+	global makenewobject
+	global messagetext
+	global errortext
+	global EVENT_NONE,EVENT_DRAW,EVENT_EXIT
+	
+	#Height Addition, this is for changing the gui
+	hadd = 10
+	
+	#Title :420high
+	glClearColor(0.6, 0.6, 0.6, 1.0)
+	glClear(GL_COLOR_BUFFER_BIT)
+	glColor3f(0.0,0.0,0.0)
+	glRasterPos2d(8, 400+hadd)
+	Text("Discombobulator v5.3.5.406893.potato")
+	
+	#Protrusion
+	colorbox(8,385+hadd,312,230+hadd)
+	glColor3f(0.0,0.0,0.0)
+	glRasterPos2d(12, 375+hadd)
+	Text("Protrusions:")
+	doprots = Toggle("Make Protrusions",EVENT_NONE,12,352+hadd,145,18,doprots.val,"Make Protrusions?")
+	facechange = Number("Face %: ",EVENT_NONE,162,352+hadd,145,18,facechange.val,0,100,"Percentage of faces that will grow protrusions")
+	useselected = Toggle("Only selected faces",EVENT_NONE,12,332+hadd,145,18,useselected.val,"If on, only selected faces will be modified")
+	deselectvertices = Toggle("Deselect Selected",EVENT_NONE,162,332+hadd,145,18,deselectvertices.val,"Deselects any selected vertex except for ones selected by \"Select Tops\"")
+	
+	#Protrusion properties
+	glColor3f(0.0,0.0,0.0)
+	glRasterPos2d(12, 315+hadd)
+	Text("Protrusion Properties:")
+	minheight = Number("Min Height: ",EVENT_NONE,12,292+hadd,145,18,minheight.val,-100.0,100.0,"Minimum height of any protrusion")
+	maxheight = Number("Max Height: ",EVENT_NONE,162,292+hadd,145,18,maxheight.val,-100.0,100.0,"Maximum height of any protrusion")
+	mintaper = Number("Min Taper %: ",EVENT_NONE,12,272+hadd,145,18,mintaper.val,0,100,"Minimum taper percentage of protrusion")
+	maxtaper = Number("Max Taper %: ",EVENT_NONE,162,272+hadd,145,18,maxtaper.val,0,100,"Maximum taper percentage of protrusion")
+	glRasterPos2d(19, 257+hadd)
+	Text("Number of protrusions:")
+	sub1 = Toggle("1",EVENT_NONE,12,235+hadd,34,18,sub1.val,"One Protrusion")
+	sub2 = Toggle("2",EVENT_NONE,48,235+hadd,34,18,sub2.val,"Two Protrusions")
+	sub3 = Toggle("3",EVENT_NONE,84,235+hadd,34,18,sub3.val,"Three Protrusions")
+	sub4 = Toggle("4",EVENT_NONE,120,235+hadd,34,18,sub4.val,"Four Protrusions")
+	glRasterPos2d(195, 257+hadd)
+	Text("Select tops of:")
+	selface1 = Toggle("1",EVENT_NONE,165,235+hadd,34,18,selface1.val,"Select the tip of the protrusion when it is created")
+	selface2 = Toggle("2",EVENT_NONE,201,235+hadd,34,18,selface2.val,"Select the tips of each protrusion when they are created")
+	selface3 = Toggle("3",EVENT_NONE,237,235+hadd,34,18,selface3.val,"Select the tips of each protrusion when they are created")
+	selface4 = Toggle("4",EVENT_NONE,273,235+hadd,34,18,selface4.val,"Select the tips of each protrusion when they are created")
+	
+	#Doodad
+	colorbox(8,220+hadd,312,40+hadd)
+	glColor3f(0.0,0.0,0.0)
+	glRasterPos2d(12, 210+hadd)
+	Text("Doodads:")
+	dood1 = Toggle("1 Box",EVENT_NONE,12,207+hadd-20,45,18,dood1.val,"Creates a rectangular box")
+	dood2 = Toggle("2 Box",EVENT_NONE,61,207+hadd-20,45,18,dood2.val,"Creates 2 side-by-side rectangular boxes")
+	dood3 = Toggle("3 Box",EVENT_NONE,110,207+hadd-20,45,18,dood3.val,"Creates 3 side-by-side rectangular boxes")
+	dood4 = Toggle("\"L\"",EVENT_NONE,164,207+hadd-20,45,18,dood4.val,"Creates a Tetris-style \"L\" shape")
+	dood5 = Toggle("\"T\"",EVENT_NONE,213,207+hadd-20,45,18,dood5.val,"Creates a Tetris-style \"T\" shape")
+	dood6 = Toggle("\"S\"",EVENT_NONE,262,207+hadd-20,45,18,dood6.val,"Creates a sort-of \"S\" or \"Z\" shape")
+	dodoodads = Toggle("Make Doodads",EVENT_NONE,12,165+hadd,145,18,dodoodads.val,"Make Doodads?")
+	doodadfacechange = Number("Face %: ",EVENT_NONE,162,165+hadd,145,18,doodadfacechange.val,0,100,"Percentage of faces that will gain doodads")
+	seldoodad = Toggle("Select Doodads",EVENT_NONE,12,145+hadd,145,18,seldoodad.val,"Selects doodads when they are created")
+	seldoodtop = Toggle("Only Select Tops",EVENT_NONE,162,145+hadd,145,18,seldoodtop.val,"Only Selects tops of doodads when\"Select Doodads\" is on")
+	doodonselface = Toggle("Only selected faces",EVENT_NONE,12,125+hadd,145,18,doodonselface.val,"Only create doodads on selected faces")
+	onprot = Toggle("Only on Protrusions",EVENT_NONE,162,125+hadd,145,18,onprot.val,"Only place doodads on protrusions")
+	glColor3f(0.0,0.0,0.0)
+	glRasterPos2d(12, 108+hadd)
+	Text("Doodad Properties:")
+	doodadminamount = Number("Min Amount: ",EVENT_NONE,12,85+hadd,145,18,doodadminamount.val,0,100,"Minimum number of doodads per face")
+	doodadmaxamount = Number("Max Amount: ",EVENT_NONE,162,85+hadd,145,18,doodadmaxamount.val,0,100,"Maximum number of doodads per face")
+	doodheightmin = Number("Min Height: ",EVENT_NONE,12,65+hadd,145,18,doodheightmin.val,0.0,100.0,"Minimum height of any doodad")
+	doodheightmax = Number("Max Height: ",EVENT_NONE,162,65+hadd,145,18,doodheightmax.val,0.0,100.0,"Maximum height of any doodad")
+	doodsizemin = Number("Min Size %: ",EVENT_NONE,12,45+hadd,145,18,doodsizemin.val,0.0,100.0,"Minimum size of any doodad in percentage of face")
+	doodsizemax = Number("Max Size %: ",EVENT_NONE,162,45+hadd,145,18,doodsizemax.val,0.0,100.0,"Maximum size of any doodad in percentage of face")
+	
+	#Global Parts
+	glColor3f(1.0,0.0,0.0)
+	glRasterPos2d(10,35)
+	messagetext = Text(errortext)
+	glColor3f(0.0,0.0,0.0)
+	makenewobject = Toggle("Copy Before Modifying",EVENT_NONE,162,10,145,18,makenewobject.val,"If selected, the original object will be copied before it is changed")
+	Button("Discombobulate",EVENT_DISCOMBOBULATE,12,10,100,18)
+	Button("Exit",EVENT_EXIT,120,10,30,18)
+
+def event(evt, val):	
+	if (evt == QKEY and not val): 
+		Exit()
+
+def bevent(evt):
+	
+	#Protrusions
+	global doprots
+	global facechange
+	global minheight
+	global maxheight
+	global sub1
+	global sub2
+	global sub3
+	global sub4
+	global mintaper
+	global maxtaper
+	global useselected
+	global selface1
+	global selface2
+	global selface3
+	global selface4
+	global deselectvertices
+	#global selectbyverts
+	
+	#Doodads
+	global dodoodads
+	global doodadfacechange
+	global seldoodad
+	global onprot
+	global dood1
+	global dood2
+	global dood3
+	global dood4
+	global dood5
+	global dood6
+	global doodadminamount
+	global doodadmaxamount
+	global doodsizemin
+	global doodsizemax
+	global doodheightmin
+	global doodheightmax
+	global doodonselface
+	global seldoodtop
+	
+	#Global Settings
+	global makenewobject
+	global messagetext
+	global errortext
+	global EVENT_NONE,EVENT_DRAW,EVENT_EXIT
+
+	######### Manages GUI events
+	if evt==EVENT_EXIT: 
+		Exit()
+	elif evt==EVENT_DISCOMBOBULATE:
+		Window.WaitCursor(1)
+		discombobulate(doprots.val,facechange.val/100,minheight.val,maxheight.val,sub1.val,sub2.val,sub3.val,sub4.val,mintaper.val/100,maxtaper.val/100,useselected.val,selface1.val,selface2.val,selface3.val,selface4.val,deselectvertices.val,makenewobject.val,dodoodads.val,doodadfacechange.val/100,seldoodad.val,onprot.val,dood1.val,dood2.val,dood3.val,dood4.val,dood5.val,dood6.val,doodadminamount.val,doodadmaxamount.val,doodsizemin.val/100,doodsizemax.val/100,doodheightmin.val,doodheightmax.val,doodonselface.val,seldoodtop.val)
+		Window.WaitCursor(0)
+		Blender.Redraw()
+
+Register(draw, event, bevent)