forked from bartvdbraak/blender
7753547b70
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.)
1230 lines
41 KiB
Python
1230 lines
41 KiB
Python
#!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)
|