| #F. Hiba, C. Mendes, B. Lefebvre, P. Hubert | |
| import maya.api.OpenMaya as om | |
| import maya.cmds as cmds | |
| from math import radians, degrees, sin, cos | |
| from random import gauss, random, uniform, shuffle | |
| from copy import copy | |
| #4 utilities function related to transformations | |
| #give the quaternion corresponding to the rottion from vector 1 to vector 2 | |
| def getQuaternion (vector1=om.MVector (0,0,0), vector2=om.MVector (0,0,0)): | |
| dot = vector1^vector2 #get axis | |
| dot = dot.normalize() # normalize axis | |
| angle = vector1.angle(vector2) #get angle (in rad) | |
| quaternion = om.MQuaternion (dot[0]*sin(angle/2),dot[1]*sin(angle/2),dot[2]*sin(angle/2),cos(angle/2)) #convert. to quaternion | |
| return quaternion | |
| #convert axis + angle to quaternion | |
| def toQuaternion (axe=om.MVector (0,1,0), angle=0): | |
| angle = radians(angle) | |
| quaternion = om.MQuaternion (axe[0]*sin(angle/2),axe[1]*sin(angle/2),axe[2]*sin(angle/2),cos(angle/2)) | |
| return quaternion | |
| def getMatrix(MVectorx,MVectory,MVectorz,MVectorPos): | |
| matrix = om.MMatrix([ | |
| MVectorx.x,MVectorx.y,MVectorx.z,0, | |
| MVectory.x,MVectory.y,MVectory.z,0, | |
| MVectorz.x,MVectorz.y,MVectorz.z,0, | |
| MVectorPos.x,MVectorPos.y,MVectorPos.z,1 | |
| ]) | |
| return matrix | |
| #return closest point on the mesh and the corresponding normal. Result as [mVector,mVector] | |
| def getPointNormal (mMesh, point): | |
| point = om.MPoint(point) | |
| result = mMesh.getClosestPointAndNormal(point, om.MSpace.kWorld) | |
| res0 = om.MVector(result[0]) | |
| result = [res0,result[1]] | |
| return result | |
| def getClosestVertex(mayaMesh,mVector): | |
| selectionList = om.MSelectionList() | |
| selectionList.add(mayaMesh) | |
| dPath = selectionList.getDagPath(0) | |
| mMesh = om.MFnMesh(dPath) | |
| ID = mMesh.getClosestPoint(om.MPoint(mVector), space=om.MSpace.kWorld)[1] #getting closest face ID | |
| list = cmds.ls( cmds.polyListComponentConversion (mayaMesh+'.f['+str(ID)+']',ff=True,tv=True),flatten=True)#face's vertices list | |
| #setting vertex [0] as the closest one | |
| d = mVector-om.MVector(cmds.xform(list[0], t=True, ws=True, q=True)) | |
| smallerDist2 = d.x*d.x+d.y*d.y+d.z*d.z #using distance squared to compare distance | |
| closest = list[0] | |
| #iterating from vertex [1] | |
| for i in range(1,len(list)) : | |
| d = mVector-om.MVector(cmds.xform(list[i], t=True, ws=True, q=True)) | |
| d2 = d.x*d.x+d.y*d.y+d.z*d.z | |
| if d2<smallerDist2: | |
| smallerDist2=d2 | |
| closest=list[i] | |
| return closest | |
| def getLastVertex(mayaMesh): | |
| list = cmds.ls(cmds.polyListComponentConversion(mayaMesh, tv=True),flatten=True) | |
| last = list[-1] | |
| return last | |
| def getFirstVertex(mayaMesh): | |
| list = cmds.ls(cmds.polyListComponentConversion(mayaMesh, tv=True), flatten=True) | |
| first = list[0] | |
| return first | |
| #CLASSES | |
| #custom mesh class. Used to point open maya's mMesh object (will be mesh.mMesh) | |
| class Mesh: | |
| def setmMesh(self, mayamesh): | |
| self.mayamesh = mayamesh | |
| self.refMesh = cmds.duplicate(self.mayamesh, n='referenceMesh')[0] | |
| cmds.parent(self.refMesh, grp.grp) | |
| cmds.polySetToFaceNormal(self.refMesh) | |
| cmds.hide (self.refMesh) | |
| selectionList = om.MSelectionList() | |
| selectionList.add(self.refMesh) | |
| dPath = selectionList.getDagPath(0) | |
| self.mMesh = om.MFnMesh(dPath) | |
| def reset(self): | |
| self.refMesh = cmds.duplicate(self.mayamesh, n='referenceMesh')[0] | |
| cmds.parent(self.refMesh, grp.grp) | |
| cmds.polySetToFaceNormal(self.refMesh) | |
| cmds.hide (self.refMesh) | |
| selectionList = om.MSelectionList() | |
| selectionList.add(self.refMesh) | |
| dPath = selectionList.getDagPath(0) | |
| self.mMesh = om.MFnMesh(dPath) | |
| # Add is used to add a copy of a given mesh to the reference. Used to update ref. mesh in real time. | |
| def add(self, mayamesh): | |
| self.toAdd = cmds.duplicate(mayamesh, n='referenceMesh')[0] | |
| self.refMesh = cmds.polyUnite([self.refMesh,self.toAdd], ch=False)[0] | |
| cmds.parent(self.refMesh, grp.grp) | |
| cmds.hide(self.refMesh) | |
| selectionList = om.MSelectionList() | |
| selectionList.add(self.refMesh) | |
| dPath = selectionList.getDagPath(0) | |
| self.mMesh = om.MFnMesh(dPath) | |
| #class to point locator | |
| class Locator: | |
| def setup(self, locator): | |
| self.pos = om.MVector(cmds.xform(locator, query=True, t=True, worldSpace=True)) | |
| #custom group class. Used to store generated geo. | |
| class Grp: | |
| def __init__(self): | |
| self.grp = cmds.group (em=True, n='generation') | |
| def reset (self): | |
| if hasattr(self, 'grp'): | |
| if cmds.objExists (self.grp): | |
| cmds.delete (self.grp) | |
| print 'deleted' | |
| self.grp = cmds.group (em=True, n='generation') | |
| def unite(self): | |
| geo = cmds.polyUnite(cmds.listRelatives (self.grp), ch=False, n='Geometry') | |
| return geo | |
| # custom Vector class. Vectors associate : Vector direction (as openmaya MVector), | |
| # Vector position (as om MVector), corresponding normal and point on mesh (both as om MVector), | |
| # and corresponding NEXT normal and Point (Normal an Point at vector's extremity). Theses last | |
| # parameters are used to calculate next vector's position | |
| class Vector: | |
| def __init__(self): #creates a standard Vector. On position 0, value 1 z, normal 1 y | |
| self.mVector = om.MVector(0, 0, 1)*var.scaleFactor | |
| self.pos = om.MVector() | |
| self.mNormal = om.MVector(0, 1, 0) | |
| def firstSetup(self, locator, mMesh): #set up the first vector : establish his parameters for a given mesh(mMesh custom class) and a given starting postion(locator custom class). | |
| self.__init__() #to avoid glitch when used on a allready set up vector | |
| self.pos = locator.pos #moves vector to locator's position | |
| result= getPointNormal(mMesh, self.pos) #get point an normal on mesh | |
| self.mNormal = result[1] | |
| self.pos = result[0]+(self.mNormal*var.distance) #move vector next to the surface. Distance controlled by var.distance. | |
| quat = getQuaternion (om.MVector(0,1,0), self.mNormal) #get quat. corresponding to the rotation between y axis and the normal on starting point. | |
| self.mVector = self.mVector.rotateBy(quat) #uses quad to align vector tangent to the surface. | |
| self.mVector = self.mVector.normalize()*var.scaleFactor #scale vector's length by var.scaleFactor | |
| result = getPointNormal(mMesh, self.pos+self.mVector) #calculate next point and normal to pass it to the next vector | |
| self.pointNext = result[0] | |
| self.mNormalNext = result[1] | |
| def startRotation (self, mMesh, angle=0.0): #apply a rotation to a given allready set up vector. Use for first vector setup and for bigger angle variation at divisions | |
| self.origin = self.mVector | |
| self.mVector = self.origin.rotateBy(toQuaternion (self.mNormal, angle)) #modify start angle | |
| #redefine other parameters | |
| self.mVector = self.mVector.normalize()*var.scaleFactor | |
| result = getPointNormal(mMesh, self.pos+self.mVector) | |
| self.pointNext = result[0] | |
| self.mNormalNext = result[1] | |
| # Setup method sets up a vector from a given previous vector. Use to align one vector after the other. | |
| def setup (self, mMesh, vector, distance) : #vector must be of type : custom Vector class. | |
| self.mVector = vector.mVector #get previous vector's parameter | |
| self.pos = vector.pos+vector.mVector #get his new position | |
| self.mNormal = vector.mNormalNext #get his normal and point (calculated by previous vector) | |
| self.point = vector.pointNext | |
| #apply a rotation. Random variation based on gauss distrib. with variance = var.angleAmplitude | |
| self.mVector=self.mVector.rotateBy(toQuaternion (self.mNormal, gauss(0, var.angleAmplitude))) | |
| #calculate next normal and point | |
| result = getPointNormal(mMesh,self.pos+self.mVector) | |
| self.pointNext = result[0] | |
| self.mNormalNext = result[1] | |
| #adjust vector with parameters : next point and next normal. Normalize en rescale to keep a constant length. | |
| self.mVector = (self.pointNext + (self.mNormalNext*distance) - self.pos).normalize()*var.scaleFactor | |
| #mehtod similar to setup without angle variation and without correction. Used to obtain vector colinear to the previous one. | |
| #Used at divisions to avoid extrusion glitch. | |
| def setupStraight (self,mMesh, vector, distance) : | |
| self.mVector = vector.mVector #get previous vector's parameter | |
| self.pos = vector.pos+vector.mVector #get his new position | |
| self.mNormal = vector.mNormalNext #get his normal and point (calculated by previous vector) | |
| self.point = vector.pointNext | |
| result= getPointNormal(mMesh,self.pos+self.mVector) #calculate next normal and point | |
| self.pointNext = result[0] | |
| self.mNormalNext = result[1] | |
| #creates a new point on the bezier curve 'bezier' corresponding to self.pos. Used to store points during generation loop. | |
| def display(self, bezier) : | |
| cmds.curve (bezier, append=True, p=(self.pos+self.mVector)) | |
| #invert vector. Used to create the reverse branch on first iteration (to fill hole) | |
| def invert(self): | |
| self.copy = copy(self) | |
| self.pos = self.copy.pos+self.copy.mVector | |
| self.mVector = -(self.copy.mVector) | |
| #branch class is used to create vectors un loop and store them as a maya bezier curve. Has a fonction to create geo too. | |
| #firstVector and lastVector are first and last vectors of the branch. first vector used for extrusion and last vector used to align next branch. | |
| class Branch: | |
| #make a branch from a single vector. Used for first vector. | |
| def firstSetup(self, vector): | |
| self.bezier = cmds.curve (p=vector.pos, d=1) #creates a curve | |
| cmds.parent(self.bezier, grp.grp) #parent to grp.grp (custom group class) | |
| vector.display(self.bezier) #add point | |
| self.firstVector = copy(vector) #fistvector used to set up extrusion in makeGeo | |
| self.lastVector = self.firstVector | |
| #similar to firstSetup but without creating geo. and inverting first vector. Used to fill hole at strat (expand in both extremities) | |
| def firstSetupInv(self, branch): | |
| self.firstVector = copy(branch.firstVector) #fistvector used to set up extrusion in makeGeo | |
| self.lastVector = self.firstVector | |
| self.lastVector.invert() | |
| self.geo=branch.geo | |
| #Setup a branch for a given previous branch. Store points in a bezier curve. | |
| #use vector.setup in a loop | |
| #creates 2 vectors before starting the loop : | |
| #the first one is a straight one (to avoid extrusion glitch) | |
| #the second one gets an extra rotation to make branches expand at division. | |
| def setup (self, branch, iterations, close=False): | |
| i = 0 | |
| self.bezier = cmds.curve(p=branch.lastVector.pos+branch.lastVector.mVector, d=2) #creates curve | |
| cmds.parent(self.bezier, grp.grp ) | |
| #first vector | |
| self.vector0 = Vector() #creates vector0 | |
| self.vector0.setupStraight (myMesh.mMesh, branch.lastVector, distance=var.distance)#set up vector0 | |
| self.vector0.display(self.bezier) #add point to the curve | |
| self.firstVector = copy(self.vector0)#store firstVector in memory | |
| #second vector = the one affected by the "rotation at division" factor. | |
| self.vector1 = Vector() #creates and sets up a second vector (not straight) | |
| self.vector1.setup(myMesh.mMesh, self.vector0, distance=var.distance) | |
| self.vector1.startRotation(mMesh=myMesh.mMesh, angle=gauss(0,var.angleAmplitudeDiv)) #rotates it for a bigger offset | |
| self.vector1.display(self.bezier) | |
| self.vector0 = self.vector1 | |
| #loop | |
| while i < iterations-2: | |
| if close == True : #close is used for last branches. The vector as to be progressively closer to match with the extrusion witch will have a reduced diamater. | |
| self.vector1.setup (myMesh.mMesh,self.vector0,distance=var.distance*(1-i/(iterations-2)) ) | |
| else: | |
| self.vector1.setup (myMesh.mMesh,self.vector0,distance=var.distance) | |
| leaves.append(copy(self.vector1)) | |
| self.vector1.display(self.bezier) | |
| self.vector0=self.vector1 | |
| i = i + 1 | |
| self.lastVector = self.vector1 #point last vector | |
| #makeGeo extrude the curve. Close argument used for extremities. | |
| def makeGeo(self, branch=0, close=False, inv=False, first=False): | |
| if first == True : | |
| z = self.firstVector.mVector | |
| y = self.firstVector.mNormal | |
| x = (y^z).normal() | |
| y = z^x | |
| mat1 = getMatrix(x.normal(), y.normal(), z.normal(), self.firstVector.pos) | |
| sliceTest = cmds.circle(r=var.radius, s=8)[0]#creating the "slice" circle for extrusion | |
| cmds.xform (sliceTest, matrix=mat1) #rotating and moving it to match curve | |
| else : | |
| #vertex = om.MVector(cmds.xform (getClosestVertex (branch.geo,self.firstVector.pos),t=True,ws=True,q=True)) | |
| if inv == True: | |
| vertex = om.MVector(cmds.xform(getFirstVertex(branch.geo), t=True, ws=True, q=True)) | |
| else : | |
| vertex = om.MVector(cmds.xform(getLastVertex(branch.geo), t=True, ws=True, q=True)) | |
| x = (vertex-self.firstVector.pos).normal() | |
| z = self.firstVector.mVector.normal() | |
| y = z^x | |
| #cmds.curve(p=[self.firstVector.pos,self.firstVector.pos+x],d=1) | |
| mat1 = getMatrix(x.normal(), y.normal(), z.normal(), self.firstVector.pos) | |
| sliceTest = cmds.circle(r=var.radius, s=8)[0]#creating the "slice" circle for extrusion | |
| cmds.xform (sliceTest, matrix=mat1) #rotating and moving it to match curve | |
| if close == True: | |
| self.nurbs=cmds.extrude (sliceTest, self.bezier, po=0, upn=False, scale=0)[0] #[0] : extrude returns a list | |
| else : | |
| self.nurbs=cmds.extrude (sliceTest, self.bezier, po=0, upn=False, scale=1)[0] | |
| self.geo = cmds.nurbsToPoly(self.nurbs, f=3, pt=1, mnd=True)[0] | |
| cmds.delete(self.nurbs) | |
| cmds.parent(self.geo, grp.grp) | |
| cmds.delete(self.bezier) | |
| cmds.delete(sliceTest) | |
| return self.geo | |
| #Branchlist class is used to makes several branches. It stores the list of the last branches and | |
| # uses this list to creates new branches at their extremities | |
| class Branchlist: | |
| def __init__(self): | |
| self.list = [] | |
| self.listClose = [] | |
| def initialize(self,branch,branchInv): | |
| self.list = [branch] | |
| self.branchInv = branchInv | |
| #print self.branchInv.lastVector.mVector | |
| #print self.list[0].lastVector.mVector | |
| def iterate(self, number=1): | |
| #Check if this is the first iteration. If yes, sets up an extra branch to fill hole. | |
| if var.firstIteration == True : | |
| print 'first' | |
| var.firstIteration = False | |
| branchI = Branch() | |
| branchI.setup(branch = self.branchInv, iterations=var.iterations + (var.iterations-1)*var.iterationsVar*uniform(-1,1), close=True) | |
| geo=copy(branchI.makeGeo(branch=self.branchInv, first=False, inv=True, close=True)) | |
| myMesh.add(geo) | |
| cmds.refresh() | |
| #Next block is the loop generation algorithm | |
| n = 0 | |
| while n<number: | |
| n = n+1 | |
| self.listClose = [] | |
| shuffle(self.list) | |
| self.templist = [] | |
| self.delIndex = [] | |
| if len(self.list) > 1: | |
| for i in range(1, len(self.list)): | |
| if random() < var.closeRate : | |
| self.listClose.append(copy(self.list[i])) | |
| self.delIndex.append(i) | |
| if len(self.delIndex) > 0: | |
| for i in sorted (self.delIndex, reverse=True) : | |
| del (self.list[i]) | |
| for branch in self.list: | |
| branch1 = Branch() | |
| branch1.setup(branch=branch,iterations = var.iterations+(var.iterations-1)*var.iterationsVar*uniform(-1,1)) | |
| geo1 = copy(branch1.makeGeo(branch=branch)) | |
| self.templist.append(branch1) | |
| cmds.refresh() | |
| if random() < var.divRate: | |
| branch2 = Branch() | |
| branch2.setup(branch = branch,iterations=var.iterations+(var.iterations-1)*var.iterationsVar*uniform(-1,1)) | |
| geo2 = copy(branch2.makeGeo(branch=branch)) | |
| myMesh.add(geo2) | |
| self.templist.append(branch2) | |
| cmds.refresh() | |
| myMesh.add(geo1) | |
| self.list = copy(self.templist) | |
| for branch in self.listClose: | |
| branch1 = Branch() | |
| branch1.setup(branch=branch,iterations=var.iterations+(var.iterations-1)*var.iterationsVar*uniform(-1,1),close=True) | |
| geo = copy(branch1.makeGeo(branch=branch, close=True)) | |
| myMesh.add(geo) | |
| cmds.refresh() | |
| def close(self): | |
| for branch in self.list: | |
| branch1 = Branch() | |
| branch1.setup(branch=branch,iterations=var.iterations+(var.iterations-1)*var.iterationsVar*uniform(-1,1),close=True) | |
| geo = copy(branch1.makeGeo(branch=branch, close=True)) | |
| myMesh.add(geo) | |
| cmds.refresh() | |
| #variables class. Is used to create a single object representing all the variables. | |
| class Var: | |
| def __init__(self): | |
| self.scaleFactor = 1 | |
| self.radius=0.5 | |
| self.penetration = 0 | |
| self.distance=self.radius*(1-self.penetration) | |
| self.startAngle = 0 | |
| self.angleAmplitude = 30 | |
| self.angleAmplitudeDiv = 45 | |
| self.iterations = 50 | |
| self.iterationsVar = 30 | |
| self.divRate = 0.3 | |
| self.closeRate = 0.2 | |
| self.loopNumber = 1 | |
| self.leafScaleVar = 0.2 | |
| self.leafRot1Var = 15 | |
| self.leavesDensity = 0.4 | |
| self.firstIteration = True | |
| #updates value based on sliders. Called by slider. | |
| def update(self): | |
| self.scaleFactor = cmds.floatSliderGrp(scaleFactor, v=True, query = True) | |
| self.radius = cmds.floatSliderGrp(radius, v=True, query = True) | |
| self.penetration = cmds.floatSliderGrp(penetration, v=True, query = True) | |
| self.distance = self.radius*(1-self.penetration) | |
| self.startAngle = cmds.intSliderGrp(startAngle, v=True, query = True) | |
| self.angleAmplitude = cmds.floatSliderGrp(angleAmplitude, v=True, query = True) | |
| self.angleAmplitudeDiv = cmds.floatSliderGrp(angleAmplitudeDiv, v=True, query = True) | |
| self.iterations = cmds.intSliderGrp(iterations, v=True, query = True) | |
| self.iterationsVar = cmds.floatSliderGrp(iterationsVar, v=True, query = True) | |
| self.divRate = cmds.floatSliderGrp(divRate, v=True, query = True) | |
| self.closeRate = cmds.floatSliderGrp(closeRate, v=True, query = True) | |
| self.loopNumber = cmds.intSliderGrp(loopNumber, v=True, query=True) | |
| self.leavesScaleVar = cmds.floatSliderGrp(leavesScaleVar, v=True, query=True) | |
| self.leavesRot1Var = cmds.intSliderGrp(leavesRot1Var, v=True, query=True) | |
| self.leavesDensity = cmds.floatSliderGrp(leavesDensity, v=True, query=True) | |
| self.leavesPlacementIntMin = cmds.intSliderGrp (leavesPlacementIntMin, v=True, query=True) | |
| self.leavesPlacementIntMax = cmds.intSliderGrp (leavesPlacementIntMax, v=True, query=True) | |
| #leaves class is used to store a vector list and to place leaves along these vectors. | |
| class Leaves: | |
| def __init__(self): | |
| self.vectorList = [] | |
| def setMesh(self, mayamesh): | |
| cmds.xform(mayamesh, piv=(0,0,0)) | |
| cmds.makeIdentity (mayamesh, apply=True) | |
| self.mesh = mayamesh | |
| def append (self,vector): | |
| self.vectorList.append(vector) | |
| def reset (self): | |
| if hasattr(self,'grp'): | |
| if cmds.objExists (self.grp): | |
| print 'del' | |
| cmds.delete (self.grp) | |
| self.grp = cmds.group (em=True, n='Leaves') | |
| '''cmds.parent (self.grp,grp.grp)''' | |
| def placeGeo(self): | |
| for vector in self.vectorList: | |
| if random() < var.leavesDensity: | |
| z = vector.mVector.normal() | |
| x = vector.mNormal | |
| y = z^x | |
| x = y^z | |
| pos = vector.pos | |
| mat1 = getMatrix(x, y, z, pos) | |
| mat2 = getMatrix(x, -y, z, pos) | |
| leaf = cmds.duplicate (self.mesh) | |
| loc = cmds.spaceLocator () | |
| cmds.parent(leaf,loc) | |
| if uniform (0, 1)>0.5: | |
| cmds.xform (loc, matrix=mat1 )#place on the branch | |
| else: | |
| cmds.xform (loc, matrix=mat2 )#place on the branch | |
| cmds.move(0.9*var.radius,0,0,leaf,os=True,r=True)#place on the surface | |
| placementAngle = uniform (var.leavesPlacementIntMin,var.leavesPlacementIntMax) | |
| cmds.rotate (0, 0, -placementAngle, loc, os=True, r=True, fo=True)#place at various angle around Z. Zero angle = leaf orientation follows normal. | |
| cmds.rotate(gauss(0, var.leavesRot1Var),gauss(0, var.leavesRot1Var),0, leaf, os=True, r=True, fo=True) #random rotation | |
| s=gauss(1, var.leavesScaleVar) | |
| cmds.scale(s, s, s, leaf, r=True) | |
| cmds.parent(leaf,world=True) | |
| cmds.parent(leaf,self.grp) | |
| cmds.delete (loc) | |
| cmds.refresh() | |
| #FONCTIONS CALL BY BUTTONS | |
| #update vector with new variables and set it relative to locator. Use to tweak the first vector's parameters or to display it after reset. | |
| def updateVector (vector): | |
| var.update() | |
| vector.firstSetup(locator=myLocator, mMesh=myMesh.mMesh) | |
| vector.startRotation(mMesh=myMesh.mMesh, angle=var.startAngle) | |
| if hasattr(branch0, 'bezier'): | |
| if cmds.objExists (branch0.bezier): | |
| cmds.delete (branch0.bezier) | |
| branch0.firstSetup(vector0) | |
| if hasattr(branch0, 'geo'): | |
| if cmds.objExists (branch0.geo): | |
| cmds.delete (branch0.geo) | |
| branch0.makeGeo(first=True) | |
| branchInv.firstSetupInv(branch0) | |
| branchlist.initialize(branch0,branchInv)#put first branch in branchlist | |
| def reset(): | |
| grp.reset() | |
| myMesh.reset() | |
| leaves.reset() | |
| vector0.__init__() | |
| branch0 = Branch() | |
| branchInv = Branch() | |
| branchlist = Branchlist() | |
| updateVector(vector0) | |
| leaves.vectorList = [] | |
| def resetButton(): | |
| var.firstIteration = True | |
| try: | |
| reset() | |
| except: | |
| print 'Nothing to reset !' | |
| def setLocatorButton (): #launched when setlocator button is pressed. | |
| myLocator.setup (cmds.ls(sl=True)[0]) #point locator via custom locator class | |
| updateVector(vector0) #update to display vector | |
| cmds.viewFit(cmds.ls(sl=True)[0]) | |
| def setMeshButton(): | |
| try: | |
| mesh = cmds.ls(sl=True)[0] | |
| grp.reset() | |
| myMesh.setmMesh(mesh) | |
| except : | |
| print 'please select a mesh object !' | |
| def iterateButton(): | |
| try: | |
| if var.firstIteration == True : | |
| reset() | |
| branchlist.iterate(var.loopNumber) | |
| except: | |
| print 'set mesh and location first !' | |
| def finishButton(): | |
| try: | |
| branchlist.close() | |
| cmds.delete(myMesh.refMesh) | |
| except: | |
| print 'No generation to terminate !' | |
| def combineGeo(): | |
| try: | |
| geo = grp.unite() | |
| grp.reset() | |
| var.firstIteration=True | |
| cmds.select(geo) | |
| except: | |
| print 'No geo to combine !' | |
| def setLeafButton(): | |
| leaves.setMesh(cmds.ls(sl=True)[0]) | |
| def placeLeavesButton(): | |
| leaves.reset() | |
| leaves.placeGeo() | |
| #Objects created at launch to easy variable access. | |
| var = Var() | |
| myMesh = Mesh() | |
| vector0 = Vector() | |
| myLocator = Locator() | |
| branch0 = Branch() | |
| branchInv = Branch() | |
| branchlist = Branchlist() | |
| grp = Grp() | |
| leaves = Leaves() | |
| #WINDOW | |
| if (cmds.window('RootsAndIvy', exists=True)): | |
| cmds.deleteUI('RootsAndIvy', window=True ) | |
| myWindow = cmds.window('RootsAndIvy', iconName='mw' ) | |
| if (cmds.windowPref( myWindow, exists=True )): | |
| cmds.windowPref( myWindow, remove=True ) | |
| #MENU | |
| menuBarLayout = cmds.menuBarLayout() | |
| cmds.menu(label='File') | |
| cmds.menuItem(label='Reset') | |
| cmds.menu(label='Help', helpMenu=True) | |
| cmds.menuItem( label='About...') | |
| #MAIN LAYOUT | |
| mainColumn = cmds.columnLayout(adjustableColumn=True, w=500, co=['both',5]) | |
| #FRAME 1 | |
| frame1 = cmds.frameLayout (label='Initial setup', mw=5, parent=mainColumn) | |
| f1r = cmds.rowLayout(numberOfColumns=2, parent=frame1, rat=[1,'top',0], adj=2) | |
| frame11 = cmds.frameLayout (label='Mesh setup', mw=5, mh=2, parent=f1r, bgs=True) | |
| frame12 = cmds.frameLayout (label='Standard division setup', mw=5, parent=f1r, bgs=True) | |
| cmds.rowColumnLayout(numberOfColumns=2, parent=frame11, rs=[[2,5]], cs=[2,5], cal=[1,'right']) | |
| cmds.text(label='Reference Mesh') | |
| cmds.button( label='Set mesh', command=('setMeshButton()')) | |
| cmds.text(label='') | |
| cmds.button(label='Create locator', command=("cmds.spaceLocator(n='StartLocator')") ) | |
| cmds.text(label='Start position') | |
| cmds.button(label='Set position', command=('setLocatorButton()') ) | |
| cmds.rowLayout(numberOfColumns=2, parent=frame12) | |
| #FRAME 2 | |
| frame2 = cmds.frameLayout (label=" Generation's setup",mw=5,parent=mainColumn,bgs=True) | |
| scaleFactor = cmds.floatSliderGrp(label = 'Scale factor (length)\n Affects precision',field=True,minValue=0.0, maxValue=0.5, fieldMinValue=0.0, fieldMaxValue=5, step=0.01, value=0.1,columnWidth3 = (100,50,50), columnAlign3=('right','center','center'),cc = 'updateVector(vector0)',dc= 'updateVector(vector0)',parent=frame12,ad3=1 ) | |
| startAngle = cmds.intSliderGrp(label = 'Angle',field=True,minValue=0.0, maxValue=360, fieldMinValue=0.0, fieldMaxValue=360, step=1, value=0,columnWidth3 = (100,50,50), columnAlign3=('right','center','center'),cc = 'updateVector(vector0)',dc= 'updateVector(vector0)' ,parent=frame12,ad3=1) | |
| radius = cmds.floatSliderGrp(label = 'Radius',field=True,minValue=0.0, maxValue=0.5, fieldMinValue=0.0, fieldMaxValue=2, step=0.05, value=0.05,columnWidth3 = (100,50,50), columnAlign3=('right','center','center'),cc = 'updateVector(vector0)',dc= 'updateVector(vector0)',parent=frame12,ad3=1 ) | |
| penetration = cmds.floatSliderGrp(label = 'Penetration',field=True,minValue=0.0, maxValue=1, fieldMinValue=0.0, fieldMaxValue=1, step=0.05, value=0.05,columnWidth3 = (100,50,50), columnAlign3=('right','center','center'),cc = 'updateVector(vector0)',dc= 'updateVector(vector0)',parent=frame12,ad3=1 ) | |
| iterations = cmds.intSliderGrp(label='Branches average length', field=True,minValue=1, maxValue=100, fieldMinValue=1, fieldMaxValue=100, step=1, value=20,columnWidth3 = (100,50,50), columnAlign3=('right','center','center'),cc = 'var.update()',dc= 'var.update()' ,ad3=1,co3=[0,0,30],ct3=('right','center','right')) | |
| iterationsVar = cmds.floatSliderGrp(label='Length variation amplitude', field=True,minValue=0, maxValue=1, fieldMinValue=0, fieldMaxValue=1, step=0.05, value=0.3,columnWidth3 = (100,50,50), columnAlign3=('right','center','center'),cc = 'var.update()',dc= 'var.update()',ad3=1,co3=[0,0,30],ct3=('right','center','right') ) | |
| angleAmplitude = cmds.floatSliderGrp(label='Angle randomness variance',field=True,minValue=0.0, maxValue=45, fieldMinValue=0.0, fieldMaxValue=90, step=1, value=15,columnWidth3 = (100,50,50),columnAlign3=('right','center','center'),cc = 'var.update()',dc= 'var.update()',ad3=1,co3=[0,0,30],ct3=('right','center','right')) | |
| angleAmplitudeDiv = cmds.floatSliderGrp(label='Angle randomness variance\nat divisions',field=True,minValue=0.0, maxValue=45, fieldMinValue=0.0, fieldMaxValue=90, step=1, value=25,columnWidth3 = (100,50,50), columnAlign3=('right','center','center'),cc = 'var.update()',dc= 'var.update()',ad3=1,co3=[0,0,30],ct3=('right','center','right')) | |
| divRate = cmds.floatSliderGrp(label='Divisions rate', field=True, minValue=0, maxValue=1, fieldMinValue=0, fieldMaxValue=1, step=0.01, value=0.30,columnWidth3 = (100,50,50), columnAlign3=('right','center','center'),cc = 'var.update()',dc= 'var.update()' ,ad3=1,co3=[0,0,30],ct3=('right','center','right')) | |
| closeRate = cmds.floatSliderGrp(label='Closing rate', field=True, minValue=0, maxValue=1, fieldMinValue=0, fieldMaxValue=1, step=0.01, value=0.20,columnWidth3 = (100,50,50), columnAlign3=('right','center','center'),cc = 'var.update()',dc= 'var.update()',ad3=1,co3=[0,0,30],ct3=('right','center','right') ) | |
| cmds.text (label='A high (division rate/closing rate) ratio will lead to exponential generation !') | |
| #FRAME 3 | |
| frame3 = cmds.frameLayout(label='Create geometry',mw=5,parent=mainColumn) | |
| frame31 = cmds.frameLayout(label='Main structure',mw=5,parent=frame3,bgs=True) | |
| #ROWCOLUMN with 2 column | |
| f31r = cmds.rowColumnLayout(numberOfColumns=2,rs=[[2,5]],cs=[2,5],cal=[1,'right']) | |
| #1 | |
| loopNumber = cmds.intSliderGrp(label = 'Number of \n iteration\'s \nloop',field=True,minValue=1, maxValue=10, fieldMinValue=1, fieldMaxValue=50, step=1, value=1,columnWidth3 = (100,50,50), ad3=1,columnAlign3=('right','center','center'),cc = 'var.update()',dc= 'var.update()', parent=f31r ) | |
| #2 | |
| cmds.button(label='Iterate', command=('iterateButton()')) | |
| #3 | |
| cmds.rowLayout(numberOfColumns=2,parent=f31r) | |
| cmds.text (label='Reset current generation') | |
| cmds.button( label='reset', command=('resetButton()') ) | |
| #4 | |
| cmds.rowLayout(numberOfColumns=2, parent=f31r) | |
| cmds.text(label='Terminate\n (Plug extremities)') | |
| cmds.button(label='Terminate', command=('finishButton()') ) | |
| #FRAME4 | |
| frame32 = cmds.frameLayout(label='Leaves',mw=5,parent=frame3,bgs=True) | |
| cmds.text(label='Leaf primitive orientation must be : \n UP = global Y, leaf direction = global Z, stem basis = 0,0,0') | |
| f32r=cmds.rowLayout(numberOfColumns=2,ad2=2,ct2=('right','right')) | |
| f32rc=cmds.columnLayout() | |
| f32rr=cmds.rowLayout(numberOfColumns=2) | |
| cmds.text (label = 'Set leave primitive',parent=f32rr) | |
| cmds.button( label='Set Mesh', command=('setLeafButton()'),parent=f32rr) | |
| leavesDensity= cmds.floatSliderGrp(label = 'Density',field=True,minValue=0, maxValue=1, fieldMinValue=0, fieldMaxValue=1, step=0.01, value=0.4,columnWidth3 = (100,50,50), columnAlign3=('right','center','center'),cc = 'var.update()',dc= 'var.update()',ad3=1,co3=[0,0,30],ct3=('right','center','right'),parent=f32rc ) | |
| leavesScaleVar= cmds.floatSliderGrp(label = 'Scale\n variance',field=True,minValue=0, maxValue=1, fieldMinValue=0, fieldMaxValue=1, step=0.01, value=0.3,columnWidth3 = (100,50,50), columnAlign3=('right','center','center'),cc = 'var.update()',dc= 'var.update()',ad3=1,co3=[0,0,30],ct3=('right','center','right'),parent=f32rc ) | |
| leavesRot1Var= cmds.intSliderGrp(label = 'Rotation\n variance',field=True,minValue=0, maxValue=30, fieldMinValue=0, fieldMaxValue=45, step=1, value=15,columnWidth3 = (100,50,50), columnAlign3=('right','center','center'),cc = 'var.update()',dc= 'var.update()',ad3=1,co3=[0,0,30],ct3=('right','center','right'),parent=f32rc ) | |
| cmds.columnLayout (parent=f32r) | |
| cmds.text (label = 'Positionning interval (0 = normal, 90 = lateral segment) : ') | |
| leavesPlacementIntMin = cmds.intSliderGrp(label = 'min',field=True,minValue=0, maxValue=90, fieldMinValue=0, fieldMaxValue=90, step=1, value=45,columnWidth3 = (100,50,50), columnAlign3=('right','center','center'),cc = 'var.update()',dc= 'var.update()',ad3=1,co3=[0,0,30],ct3=('right','center','right')) | |
| leavesPlacementIntMax = cmds.intSliderGrp(label = 'max',field=True,minValue=0, maxValue=90, fieldMinValue=0, fieldMaxValue=90, step=1, value=85,columnWidth3 = (100,50,50), columnAlign3=('right','center','center'),cc = 'var.update()',dc= 'var.update()',ad3=1,co3=[0,0,30],ct3=('right','center','right') ) | |
| cmds.rowColumnLayout(numberOfColumns=2,rs=[[2,5]],cs=[2,5],cal=[1,'right']) | |
| cmds.button(label='Place leaves', command=('placeLeavesButton()')) | |
| cmds.button(label='Reset', command=('leaves.reset()')) | |
| #FRAME 5 | |
| frame5=cmds.frameLayout (label='Utility', mw=5, parent=mainColumn, bgs=True) | |
| cmds.rowLayout(numberOfColumns=2) | |
| cmds.text (label='Combine geometry') | |
| cmds.button(label='Combine geo', command=('combineGeo()') ) | |
| var.update() | |
| cmds.showWindow('RootsAndIvy') |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment