Exemple #1
0
def a_ring():
	
	ring_diameter = 22 # outer diameter 
	ring_thickness = 1.5
	divit_diameter = 1.5
	divit_depth = .75
	ring_height = 4
	#divit_spacing = .5

	divits = []
	cmds.polyPipe(radius=ring_diameter/2, height=ring_height*2, thickness=ring_thickness, name='ring0')
	cmds.setAttr( 'polyPipe1.subdivisionsAxis', 20 )
	
	for x in range(0,6):
		for y in range(0,3):	
			letter = initials[x]
			symbol = letter[y]
			myName = "_c" + str(x) + str(y)
			
			if symbol == 0 :
				cmds.polyCylinder(axis=[0,0,1], radius=(divit_diameter/2), height=divit_depth, name=myName)
			elif symbol == 2:
				cmds.polyCylinder(axis=[0,0,1], radius=(divit_diameter/2), height=ring_thickness * 2.1, name=myName)
		
			if symbol != 1:
				divits.append(myName)	
				y_off = 0
				cmds.move(0,y_off,(ring_diameter/2 - divit_depth/2 + .3),myName)
				cmds.rotate(0,(x*3+y)*20,0,myName, pivot=[0,0,0])
		
	rn = 0;	
	for d in divits[:]:
		print 'ring' + str(rn) + " " + d
		cmds.polyBoolOp('ring' + str(rn), d, op=2, n='ring' + str(rn+1), )
		rn += 1
Exemple #2
0
def cut_one_with_one(cutter, target):
  print 'Cutting 1:1 %s with %s' % (target, cutter)

  # Duplicate targets
  targetA = cmds.duplicate(target, returnRootsOnly=True)[0]
  targetB = cmds.duplicate(target, returnRootsOnly=True)[0]

  prep(targetA)
  prep(targetB)

  cmds.delete(target)

  # Set up cutters
  cutterA = cmds.duplicate(cutter, returnRootsOnly=True)[0]
  cutterB = cmds.duplicate(cutter, returnRootsOnly=True)[0]

  prep(cutterA)
  prep(cutterB)

  # Flip second cutter's normals
  cmds.polyNormal(cutterB, normalMode=0, userNormalMode=0, constructionHistory=0)

  # Perform intersections
  newTargetA = cmds.polyBoolOp(cutterA, targetA, op=3, constructionHistory=False)[0]
  newTargetB = cmds.polyBoolOp(cutterB, targetB, op=3, constructionHistory=False)[0]

  return [newTargetA, newTargetB]
Exemple #3
0
def createCrossAxel():

    length = createMainAxel("CrossAvelWidth")
    cmds.select(cu[0])
    cmds.scale(1, 1, 1.5)
    sideCylin1 = cmds.polyCylinder(r=0.4, h=length, sz=12, sx=12, sy=12)
    cmds.rotate(90, 0, 0)
    cmds.delete(ch=True)
    cu[0] = cmds.polyBoolOp(sideCylin1[0], cu[0], op=2, n="block", ch=False)
    Tor = cmds.polyTorus(sx=2, sy=2, r=0.377, sr=0.037)
    cmds.rotate(90, 0, 0)
    cmds.delete(ch=True)
    cu[0] = cmds.polyBoolOp(Tor[0], cu[0], op=1, n="block", ch=False)
    Tor2 = cmds.polyTorus(sx=2, sy=2, r=0.377, sr=0.037)
    cmds.rotate(90, 0, 0)
    cmds.move(length / 3.2, moveZ=True)
    cmds.delete(ch=True)
    cu[0] = cmds.polyBoolOp(Tor2[0], cu[0], op=1, n="block", ch=False)
    Tor3 = cmds.polyTorus(sx=2, sy=2, r=0.377, sr=0.037)
    cmds.rotate(90, 0, 0)
    cmds.move(-1 * (length / 3.2), moveZ=True)
    cmds.delete(ch=True)
    cu[0] = cmds.polyBoolOp(Tor3[0], cu[0], op=1, n="block", ch=False)
    cmds.select(cu[0])
    cmds.rotate(0, 0, 45)
    distance1 = 0.33
    distance2 = 0.35
    createSideEdgesAxel(length, distance1, distance2)
Exemple #4
0
def createSideEdgesAxel(length, distance1, distance2):

    cyl1 = cmds.polyCylinder(r=0.15, h=length + 0.1, sz=4, sy=24)
    cmds.rotate(90, 0, 0)
    cmds.move((distance1), moveY=True, a=True)
    cmds.move((distance2), moveX=True, a=True)
    cmds.move((-1 * (0.003)), moveZ=True, a=True)
    cmds.delete(ch=True)
    cu[0] = cmds.polyBoolOp(cu[0], cyl1[0], op=2, n="block", ch=False)

    cyl2 = cmds.polyCylinder(r=0.15, h=length + 0.1, sz=4, sy=12)
    cmds.rotate(90, 0, 0)
    cmds.move((distance1), moveY=True, a=True)
    cmds.move((-1 * (distance2)), moveX=True, a=True)
    cmds.move((-1 * (0.003)), moveZ=True, a=True)
    cmds.delete(ch=True)
    cu[0] = cmds.polyBoolOp(cu[0], cyl2[0], op=2, n="block", ch=False)

    cyl3 = cmds.polyCylinder(r=0.15, h=length + 0.1, sz=4, sy=12)
    cmds.rotate(90, 0, 0)
    cmds.move((-1 * (distance1)), moveY=True, a=True)
    cmds.move((distance2), moveX=True, a=True)
    cmds.move((-1 * (0.003)), moveZ=True, a=True)
    cmds.delete(ch=True)
    cu[0] = cmds.polyBoolOp(cu[0], cyl3[0], op=2, n="block", ch=False)

    cyl4 = cmds.polyCylinder(r=0.15, h=length + 0.1, sz=4, sy=12)
    cmds.rotate(90, 0, 0)
    cmds.move((-1 * (distance1)), moveY=True, a=True)
    cmds.move((-1 * (distance2)), moveX=True, a=True)
    cmds.move((-1 * (0.003)), moveZ=True, a=True)
    cmds.delete(ch=True)
    cu[0] = cmds.polyBoolOp(cu[0], cyl4[0], op=2, n="block", ch=False)
Exemple #5
0
    def cleanUp(self):
        '''
        This is impossible without an external script. Maya's booleans are to finnicky 
        to work with and make the mesh just disappear. :(
        '''

        #union all together, and smooth!!

        #works range 0-6
        for sectNum in range(0, self.val - 1):
            #for sectNum in range(0, 2):

            #Unions pairs of two branches into "sections"
            if sectNum == 0:
                firstB = "Tree_trunk_" + str(sectNum)  #Tree_trunk_0
                secondB = "Tree_trunk_" + str(sectNum + 1)  #Tree_trunk_1
                cmds.polyBoolOp(firstB,
                                secondB,
                                op=1,
                                n="sect_" + str(sectNum))  #sect_0
            else:
                lastSect = "sect_" + str(sectNum - 1)
                nextB = "Tree_trunk_" + str(sectNum + 1)
                cmds.polyBoolOp(lastSect,
                                nextB,
                                op=1,
                                n="sect_" + str(sectNum))
Exemple #6
0
def booleanLoop():
    #1. Make an array of all selections
    target = mc.ls(sl=1)

    #2. Boolean union each item in the array to the next
    for i in range(0,len(target)-1,2):
        mc.polyBoolOp(target[i],target[i+1])
        
        #3. Delete construction history
        mc.delete(ch=True)

        #4. Recenter the pivot
        mc.xform(cp=True)
Exemple #7
0
def Fond(Stre, Freq, Ampl, colors={222, 202, 163}):
    cmds.file(f=True, new=True)

    # Stre=cmds.floatSliderGrp(field_strenth,q=True,v=True)
    # Freq=cmds.floatSliderGrp(field_frequency,q=True,v=True)
    # Ampl=cmds.floatSliderGrp(field_amplitude,q=True,v=True)

    #---------Creation Objet--------#
    cmds.polyCube(w=20, d=20, h=8, sx=80, sz=80, name="roche")  #20 20 / 50
    cmds.polySphere(r=10, sa=60, sy=60, name="contenant")  #8 / 12
    cmds.move(0, 6.5, 0, "contenant")
    cmds.polyBoolOp('contenant', 'roche', op=3, n='fond')
    cmds.delete(ch=True)
    cmds.move(0, -4, 0, "fond")

    #---------Selection Face--------#
    for i in range(0, 1707):
        cmds.select("fond.f[" + str(i) + "]", add=True)
        sl = cmds.ls(sl=True)

    #---------Texture Deformer--------#

    td = cmds.textureDeformer(s=Stre, ps="World", name="Textu".format(sl))
    n = cmds.shadingNode("noise".format(sl), asTexture=True)

    #--------Attributre Noise-------#
    cmds.setAttr("noise1.threshold", 0.014)
    cmds.setAttr("noise1.amplitude", Ampl)
    cmds.setAttr("noise1.ratio", 0.15)
    cmds.setAttr("noise1.frequency", Freq)
    cmds.setAttr("noise1.falloff", 1)

    cmds.connectAttr(n + ".outColor", td[0] + ".texture", force=True)

    Color = cmds.shadingNode('aiStandardSurface', name="colo", asShader=True)
    cmds.setAttr("colo.specular", 0)
    cmds.setAttr(Color + ".baseColor", colors[0], colors[1], colors[2])

    cmds.select("fond", hi=True, add=True)
    cmds.hyperShade(assign=Color)


#cmds.window()
#cmds.columnLayout()
#sliderStrenght=cmds.floatSliderGrp(field=True,label="Strenth",minValue=0,maxValue=3,value=1.5,w=400)
#sliderFreq=cmds.floatSliderGrp(field=True,label="Frequency",minValue=0,maxValue=1,value=0.3,w=400)
#sliderAmplitude=cmds.floatSliderGrp(field=True,label="Amplitude",minValue=0,maxValue=1,value=0.4,w=400)

#cmds.button(label="Fond", c="Fond()")
#cmds.showWindow()
  def generate(cls, *args):
    components = []
    boolean = []
    width = cmds.intSliderGrp(cls.get_prefix() + Labels["width_label"], query=True, value=True)
    rgb = cmds.colorSliderGrp(cls.get_prefix() + Labels["color_label"], query=True, rgbValue=True)

    block_width = width * Constants["block_width_unit"]
    block_height = Constants["block_height_unit"]
    block_depth = Constants["block_depth_unit"]

    for x in range(0, width):
      stub = cmds.polyCylinder(name=get_unique_name(cls.get_prefix(), "Stub"), radius=Constants["stub_radius"], height = Constants["stub_height"])
      components.append(stub[0])
      cmds.move(Constants["block_width_unit"] * x + half(Constants["block_width_unit"]), half(Constants["block_height_unit"]) + half(Constants["stub_height"]), half(Constants["block_depth_unit"]), stub[0])
      
    for x in range(0, width-1):
      hole = cmds.polyCylinder(name=get_unique_name(cls.get_prefix(), "Hole"), radius=Constants["perforation_radius"], height=Constants["block_depth_unit"] + 0.2)
      boolean.append(hole[0])
      cmds.rotate('90deg', 0, 0, hole[0])
      cmds.move(Constants["block_width_unit"] * x + Constants["block_width_unit"], 0, half(Constants["block_depth_unit"]), hole[0])

    cube = cmds.polyCube(sx=5,sy=2,sz=2,name=get_unique_name(cls.get_prefix(), "block"), width=block_width, height=block_height, depth=block_depth)
    components.append(cube[0])
    cmds.move(half(width * Constants["block_width_unit"]), 0, half(Constants["block_depth_unit"]), cube)
    solid = cmds.polyUnite(components, name=get_unique_name(cls.get_prefix(), ""))
    boolean_group = cmds.polyUnite(boolean, name=get_unique_name(cls.get_prefix(),"boolean"))
    final = cmds.polyBoolOp( solid[0], boolean_group[0], op=2, n=get_unique_name(cls.get_prefix(), "") )

    shader = cmds.shadingNode('blinn', asShader=True, name=get_unique_name(cls.get_prefix(),"mat"))
    cmds.setAttr(shader + ".color", rgb[0],rgb[1],rgb[2], type='double3')
    cmds.select(final[0], r=True)
    cmds.hyperShade(assign=shader)
    def insertDots(self):

        # copy dot object
        # copy cutout object
        # run mesh difference
        # delete the layers
        # delete the groups
        # rename the cutout.

        for dot in self.dots:
            # Copy sphere object from the template object.
            newDot = cmds.duplicate(self.getTemplateObjectName(dot.templateName()))[0]

            for cutout in dot.cutouts:

                # Copy cutout object from the template object, and rotate it.
                newCutout = cmds.duplicate(self.getTemplateObjectName(cutout.shape))[0]
                cutoutDagPath = self.getDagPathFromPath(newCutout)
                mfnTransform = OpenMaya.MFnTransform(cutoutDagPath)

                mfnTransform.rotateBy(cutout.rotation, OpenMaya.MSpace.kTransform)

                # Mesh boolean combine, with 'difference' operator.
                boolOp = cmds.polyBoolOp(newDot, newCutout, op=2)

                # Update the dot copy name and remove history.
                newDot = boolOp[0]
                cmds.delete(newDot, constructionHistory=True)

            dotPath = "dot_{0}".format(dot.name())
            cmds.rename(newDot, dotPath)

            # Move the new dot onto the final grid for printing.
            self.positionDot(dotPath, dot.vertexId)
  def generate_kink_peice(cls, block_width):
    components = []
    boolean = []
    for x in range(0, block_width + 1):
      hole = cmds.polyCylinder(name=get_unique_name(cls.get_prefix(), "Hole"), radius=Constants["perforation_radius"], height=Constants["block_depth_unit"] + 0.2)
      boolean.append(hole[0])
      cmds.rotate('90deg', 0, 0, hole[0])
      cmds.move(Constants["block_width_unit"] * x , 0, half(Constants["block_depth_unit"]), hole[0])

    cube = cmds.polyCube(sx=5,sy=2,sz=2,name=get_unique_name(cls.get_prefix(), "block"), width=block_width, height=Constants["block_height_unit"], depth=Constants["block_depth_unit"])
    components.append(cube[0])
    cmds.delete(cube[0] + ".f[40:47]")
    cmds.move(half(block_width * Constants["block_width_unit"]), 0, half(Constants["block_depth_unit"]), cube)

    #caps
    cap_one = cmds.polyCylinder(sc=1, sy=2, radius=half(Constants["block_height_unit"]), height=Constants["block_depth_unit"],name=get_unique_name(cls.get_prefix(), "cap"))
    cmds.rotate('90deg',0,0,cap_one[0])
    cmds.move(0,0,half(Constants["block_depth_unit"]),cap_one[0])
    cmds.delete(cap_one[0] + ".f[0:3]", cap_one[0] + ".f[14:23]", cap_one[0] + ".f[34:43]", cap_one[0] + ".f[54:63]", cap_one[0] + ".f[74:79]")
    components.append(cap_one[0])

    #caps
    cap_two = cmds.polyCylinder(sc=1, sy=2, radius=half(Constants["block_height_unit"]), height=Constants["block_depth_unit"])
    cmds.rotate('90deg','180deg',0,cap_two[0])
    cmds.delete(cap_two[0] + ".f[0:3]", cap_two[0] + ".f[14:23]", cap_two[0] + ".f[34:43]", cap_two[0] + ".f[54:63]", cap_two[0] + ".f[74:79]")
    cmds.move(block_width,0,half(Constants["block_depth_unit"]),cap_two[0])
    components.append(cap_two[0])

    solid = cmds.polyUnite(components, name=get_unique_name(cls.get_prefix(), ""))
    boolean_group = cmds.polyUnite(boolean, name=get_unique_name(cls.get_prefix(),"boolean"))
    cmds.polyMergeVertex( solid[0], d=0.15 )
    cmds.delete(solid[0],ch=1)
    return cmds.polyBoolOp( solid[0], boolean_group[0], op=2, n=get_unique_name(cls.get_prefix(), "") )
Exemple #11
0
def createGroovedAxel(length):

    for i in range(2):

        cylTop = cmds.polyCylinder(r=0.15, h=1, sz=4, sy=12)
        cmds.rotate(0, 0, 90)
        if i == 0:
            cmds.move(((length / 3.5)), moveZ=True, a=True)
        else:
            cmds.move((-1 * ((length / 3.5))), moveZ=True, a=True)
        cmds.move((0.34), moveY=True, a=True)
        cmds.delete(ch=True)
        cu[0] = cmds.polyBoolOp(cu[0], cylTop[0], op=2, n="block", ch=False)

        cylTop = cmds.polyCylinder(r=0.15, h=1, sz=4, sy=12)
        cmds.rotate(0, 0, 90)
        if i == 0:
            cmds.move(((length / 3.5)), moveZ=True, a=True)
        else:
            cmds.move((-1 * ((length / 3.5))), moveZ=True, a=True)
        cmds.move((-0.34), moveY=True, a=True)
        cmds.delete(ch=True)
        cu[0] = cmds.polyBoolOp(cu[0], cylTop[0], op=2, n="block", ch=False)

        cylTop2 = cmds.polyCylinder(r=0.15, h=1, sz=4, sy=12)
        cmds.rotate(0, 0, 180)
        if i == 0:
            cmds.move(((length / 3.5)), moveZ=True, a=True)
        else:
            cmds.move((-1 * ((length / 3.5))), moveZ=True, a=True)
        cmds.move((0.29), moveY=True, a=True)
        cmds.move((0.34), moveX=True, a=True)
        cmds.delete(ch=True)
        cu[0] = cmds.polyBoolOp(cu[0], cylTop[0], op=2, n="block", ch=False)

        cylTop2 = cmds.polyCylinder(r=0.15, h=1, sz=4, sy=12)
        cmds.rotate(0, 0, 180)
        if i == 0:
            cmds.move(((length / 3.5)), moveZ=True, a=True)
        else:
            cmds.move((-1 * ((length / 3.5))), moveZ=True, a=True)
        cmds.move((0.29), moveY=True, a=True)
        cmds.move((-0.34), moveX=True, a=True)
        cmds.delete(ch=True)
        cu[0] = cmds.polyBoolOp(cu[0], cylTop[0], op=2, n="block", ch=False)
Exemple #12
0
def make_base():
    """
    crane base
    """

    base = cmds.polyCube(w=4, h=2, d=4, name="base")
    cmds.move(0, 1, 0, base)

    swivel = cmds.polyCylinder(axis=(0,1,0), h=.5,radius=1.5, name="swivel")
    cmds.move(0, 2.25, 0, swivel)

    sarm1 = cmds.polyCube(w=2, h=1, d=.2, name="sarm1")
    cmds.move(0, 3, .5, sarm1)

    sarm2 = cmds.polyCube(w=2, h=1, d=.2, name="sarm2")
    cmds.move(0, 3, -.5, sarm2)

    b1 = cmds.polyBoolOp(swivel[0], sarm1[0], op=1, name="b1")
    b2 = cmds.polyBoolOp(b1[0], sarm2[0], op=1, name="b2")
Exemple #13
0
def createTire():
    global cu
    cu = cmds.polyTorus(sx=2, sy=2, r=0.5, sr=0.25)
    cmds.scale(1, 1.712, 1)
    cmds.delete(ch=True)
    middle = cmds.polyCylinder(r=0.45, h=2, sz=4, sy=12)
    cu[0] = cmds.polyBoolOp(cu[0], middle[0], op=2, n="block", ch=False)
    extrudeForTire()
    cmds.delete(ch=True)
    pip1 = cmds.polyPipe(r=0.4906, h=1.5094, t=0.0755)
    cu[0] = cmds.polyUnite(cu[0], pip1[0], n="block", ch=False)
    pip2 = cmds.polyPipe(r=0.4150, h=1.1321, t=0.0)
    cu[0] = cmds.polyUnite(cu[0], pip2[0], n="block", ch=False)
 def makeWindows(self, name_, windowShaders, booleans):
     '''
     Creates windows for a cylinder or pipe house. 
     
     self: Object of the class House.
     name_: A string with the name the polygonal house object will have.
     windowShader: A list with shaders for the windows.
     booleans: A boolean variable which determines whether the windows should be 
               combined with the house using boolean difference or not. 
     On exit: Columns of windows are created using makeWindowColumn(...) and these
              are then duplicated around the house. The windows are assigned shaders
              using assignWindowShaders(...), and are then combined with the 
              house. The House object's name attribute is updated.        
     '''
     windowHeight = random.uniform(0.5,1.9)
     # Make sure the window height is not too close to 1.6 since the window edge
     # in that case will be too close to a edge loop on the house and the boolean
     # operation will fail.
     if booleans and (windowHeight > 1.59 and windowHeight < 1.61):
         windowHeight = random.choice([1.59, 1.61])
     floorHeight = int(math.ceil(windowHeight))
     heightNum = int((self.height - (1 + floorHeight/2.0))/floorHeight)
     if heightNum == 0:
         return
     angleR = 2.0 * math.pi / self.sides
     angleD = math.degrees(angleR)
     distance = math.cos(angleR / 2.0) * self.radius
     sideWidth = 2.0 * self.radius * math.sin(angleR / 2.0)
     windowWidth = random.uniform((sideWidth -0.2)/ 2.0, sideWidth - 0.2)
     if windowWidth <= 0.1:
         return
     windowColumn = makeWindowColumn(windowWidth, windowHeight, heightNum, floorHeight)
     cmds.rotate(90 - angleD / 2.0, windowColumn[0], y = True)
     for j in range(self.sides): # Copy the column faces around the house. 
         cmds.polyChipOff(windowColumn[0] + ".f[0:" + str((heightNum * 6) - 1) + "]", dup = True, kft = True, 
                          translate = (math.sin(math.pi/2.0 - angleR/2.0 + angleR * j) * distance,0,math.cos(math.pi/2.0 - angleR/2.0 + angleR * j) *  distance))
         cmds.select(windowColumn[0] + ".f[0:" + str((heightNum * 6) - 1) + "]")
         cmds.rotate(angleD, y = True)
         cmds.delete(all = True, ch = True)
         cmds.refresh()
     cmds.delete(windowColumn[0] + ".f[0:" + str((heightNum * 6) - 1) + "]")
     windowNum = self.sides * heightNum
     assignWindowShaders(windowColumn, windowNum, windowShaders)
     cmds.select(windowColumn[0] + ".f[0:" + str(windowNum * 6 - 1) +"]")
     cmds.polySubdivideFacet()
     if booleans == True:
         result = cmds.polyBoolOp(self.name,windowColumn[0], op = 2, n = name_)
     else:
         result = cmds.polyUnite(self.name,windowColumn[0], n = name_)
     self.name = result[0]
     cmds.delete(all = True, ch = True)
def makeStreetLight():
    '''
    Creates a street light.
    
    On exit: A street light polygonal object has been created and appropriate 
             shaders have been assigned. The street light object is returned.
    '''
    streetLight = cmds.polyCube(name = "streetLight", w = 0.1, d = 0.1, h = 2.4)
    cmds.xform(streetLight, translation = (0, 1.2, 0))
    cmds.select(streetLight[0] + ".f[1]")
    cmds.polyExtrudeFacet(scale = (1.7,1.7,1.7))
    cmds.polyExtrudeFacet(scale = (2.2,2.2,2.2), translate = (0,0.2,0))
    cmds.polyExtrudeFacet(scale = (0.8,0.8,0.8), translate = (0,0.1,0))
    cmds.polyExtrudeFacet(scale = (0.6,0.6,0.6))
    cmds.polyExtrudeFacet(scale = (0.8,0.8,0.8), translate = (0,0.08,0))
    cmds.polyExtrudeFacet(scale = (0.6,0.6,0.6))
    cmds.polyExtrudeFacet(scale = (0.7,0.7,0.7), translate = (0,0.08,0))
    cmds.polyExtrudeFacet(scale = (0.5,0.5,0.5))
    cmds.polyExtrudeFacet(scale = (0.2,0.2,0.2), translate = (0,0.7,0))
    hole = cmds.polyCube(name = "hole", w = 0.16, d = 0.3, h = 0.22)
    cmds.select(hole[0] + ".f[1]")
    cmds.scale(1.9,1.9,1.9)
    cmds.xform(hole, translation = (0,2.59,0))
    hole2 = cmds.duplicate(hole[0])
    cmds.rotate(0,90,0, hole2[0])
    streetLight = cmds.polyBoolOp((streetLight[0],hole[0]),op = 2)
    streetLight = cmds.polyBoolOp((streetLight[0],hole2[0]),op = 2)
    cmds.sets(streetLight[0], edit=True, forceElement="blackMetalGroup")
    light = cmds.polyCube(name = "hole", w = 0.16, d = 0.16, h = 0.22)
    cmds.select(light[0] + ".f[1]")
    cmds.scale(1.9,1.9,1.9)
    cmds.xform(light, translation = (0,2.59,0))
    cmds.select(light)
    cmds.sets(light[0], edit=True, forceElement="whiteLightGroup")
    streetLight = cmds.polyUnite(light,streetLight)
    cmds.delete(streetLight, ch = True)
    cmds.group(streetLight[0], n = "streetLights")
    return streetLight
Exemple #16
0
def createBevels(cubeSizeX, cubeSizeY, cubeSizeZ, blockWidth, blockDepth):

    for i in range(blockWidth - 1):
        cyl = cmds.polyCylinder(r=0.28, h=0.15)
        cmds.move((cubeSizeY - 0.30), moveY=True, a=True)
        cmds.move(((i * 0.8) - (cubeSizeX / 2.0) + 0.8), moveX=True, a=True)
        cmds.move(((0 * 0.05) - (cubeSizeZ / 2.0) + 0.8), moveZ=True, a=True)
        cmds.rotate(90, 0, 0)
        cmds.delete(ch=True)
        cu[0] = cmds.polyBoolOp(cu[0],
                                cyl[0],
                                op=2,
                                n="block" + str(i),
                                ch=False)
Exemple #17
0
def cutMeshBool(mesh,boundingObject):
	'''
	Cut a specified mesh by applying a boolean intersect operation.
	@param mesh: The mesh to cut based on a bounding geometry
	@type mesh: str
	@param boundingObject: The object to intersect
	@type boundingObject: str
	'''
	# ==========
	# - Checks -
	# ==========
	
	# Check Mesh
	if not mc.objExists(mesh):
		raise Exception('Mesh "'+mesh+'" does not exist!')
	if not glTools.utils.mesh.isMesh(mesh):
		raise Exception('Object "'+mesh+'" is not a valid mesh!')
	
	# Check Bounding Mesh
	if not mc.objExists(boundingObject):
		raise Exception('Bounding object "'+boundingObject+'" does not exist!')
	if not glTools.utils.mesh.isMesh(boundingObject):
		raise Exception('Bounding object "'+boundingObject+'" is not a valid mesh!')
	
	# ============
	# - Cut Mesh -
	# ============
	
	# Get Prefix
	prefix = glTools.utils.stringUtils.stripSuffix(boundingObject)
	
	# Triangulate Bounding Mesh
	mc.polyTriangulate(boundingObject,ch=False)
	
	# Cut Mesh
	cutMesh = mc.polyBoolOp(mesh,boundingObject,op=3,n=prefix+'Cut')
	if not cutMesh: raise Exception('Boolean intersection failed!')
	cutMesh = mc.rename(cutMesh[0],prefix+'Geo')
	
	# Cleanup
	mc.polyCloseBorder(cutMesh,ch=False)
	
	# =================
	# - Return Result -
	# =================
	
	return cutMesh
  def generate(cls, *args):
    components = []
    boolean = []
    width = cmds.intSliderGrp(cls.get_prefix() + Labels["width_label"], query=True, value=True)
    rgb = cmds.colorSliderGrp(cls.get_prefix() + Labels["color_label"], query=True, rgbValue=True)

    block_width = width * Constants["block_width_unit"]
    block_height = Constants["block_height_unit"]
    block_depth = Constants["block_depth_unit"]

    for x in range(0, width + 1):
      hole = cmds.polyCylinder(name=get_unique_name(cls.get_prefix(), "Hole"), radius=Constants["perforation_radius"], height=Constants["block_depth_unit"] + 0.2)
      boolean.append(hole[0])
      cmds.rotate('90deg', 0, 0, hole[0])
      cmds.move(Constants["block_width_unit"] * x , 0, half(Constants["block_depth_unit"]), hole[0])

    cube = cmds.polyCube(sx=5,sy=2,sz=2,name=get_unique_name(cls.get_prefix(), "block"), width=block_width, height=block_height, depth=block_depth)
    components.append(cube[0])
    cmds.delete(cube[0] + ".f[40:47]")
    cmds.move(half(width * Constants["block_width_unit"]), 0, half(Constants["block_depth_unit"]), cube)

    #caps
    cap_one = cmds.polyCylinder(sc=1, sy=2, radius=half(Constants["block_height_unit"]), height=Constants["block_depth_unit"],name=get_unique_name(cls.get_prefix(), "cap"))
    cmds.rotate('90deg',0,0,cap_one[0])
    cmds.move(0,0,half(Constants["block_depth_unit"]),cap_one[0])
    cmds.delete(cap_one[0] + ".f[0:3]", cap_one[0] + ".f[14:23]", cap_one[0] + ".f[34:43]", cap_one[0] + ".f[54:63]", cap_one[0] + ".f[74:79]")
    components.append(cap_one[0])

    #caps
    cap_two = cmds.polyCylinder(sc=1, sy=2, radius=half(Constants["block_height_unit"]), height=Constants["block_depth_unit"])
    cmds.rotate('90deg','180deg',0,cap_two[0])
    cmds.delete(cap_two[0] + ".f[0:3]", cap_two[0] + ".f[14:23]", cap_two[0] + ".f[34:43]", cap_two[0] + ".f[54:63]", cap_two[0] + ".f[74:79]")
    cmds.move(block_width,0,half(Constants["block_depth_unit"]),cap_two[0])
    components.append(cap_two[0])

    solid = cmds.polyUnite(components, name=get_unique_name(cls.get_prefix(), ""))
    boolean_group = cmds.polyUnite(boolean, name=get_unique_name(cls.get_prefix(),"boolean"))
    cmds.polyMergeVertex( solid[0], d=0.15 )
    cmds.delete(solid[0],ch=1)
    final = cmds.polyBoolOp( solid[0], boolean_group[0], op=2, n=get_unique_name(cls.get_prefix(), "") )

    shader = cmds.shadingNode('blinn', asShader=True, name=get_unique_name(cls.get_prefix(),"mat"))
    cmds.setAttr(shader + ".color", rgb[0],rgb[1],rgb[2], type='double3')
    cmds.select(final[0], r=True)
    cmds.hyperShade(assign=shader)
Exemple #19
0
def createWheelHub():
    global cu
    cu = cmds.polyCylinder(r=0.4, h=0.8, sz=2, sx=2, sy=2)
    temp = str(cu[0]).rsplit("'", 1)[0]
    cmds.select(temp + ".e[40:59]")
    cmds.scale(0.768657, 0.768657, 0.768657)
    cyl = cmds.polyCylinder(r=0.3, h=1, sz=2, sx=2, sy=2)
    cu[0] = cmds.polyBoolOp(cu[0], cyl[0], op=2, n="block", ch=False)
    cyl2 = cmds.polyCylinder(r=0.35, h=.3, sz=2, sx=2, sy=2)
    cu[0] = cmds.polyBoolOp(cyl2[0], cu[0], op=1, n="block", ch=False)

    Tor1 = cmds.polyPipe(r=0.07, t=0.04, h=0.9434)
    cmds.move(0.128, moveX=True)
    cmds.move(-0.039, moveZ=True)
    cmds.delete(ch=True)
    cu[0] = cmds.polyBoolOp(Tor1[0], cu[0], op=1, n="block", ch=False)
    Tor2 = cmds.polyPipe(r=0.07, t=0.04, h=0.9434)
    cmds.move(0.013, moveX=True)
    cmds.move(-0.134, moveZ=True)
    cmds.delete(ch=True)
    cu[0] = cmds.polyBoolOp(Tor2[0], cu[0], op=1, n="block", ch=False)
    Tor3 = cmds.polyPipe(r=0.07, t=0.04, h=0.9434)
    cmds.move(-0.123, moveX=True)
    cmds.move(-0.082, moveZ=True)
    cmds.delete(ch=True)
    cu[0] = cmds.polyBoolOp(Tor3[0], cu[0], op=1, n="block", ch=False)
    Tor4 = cmds.polyPipe(r=0.07, t=0.04, h=0.9434)
    cmds.move(-0.123, moveX=True)
    cmds.move(0.065, moveZ=True)
    cmds.delete(ch=True)
    cu[0] = cmds.polyBoolOp(Tor4[0], cu[0], op=1, n="block", ch=False)
    Tor5 = cmds.polyPipe(r=0.07, t=0.04, h=0.9434)
    cmds.move(-0.017, moveX=True)
    cmds.move(0.155, moveZ=True)
    cmds.delete(ch=True)
    cu[0] = cmds.polyBoolOp(Tor5[0], cu[0], op=1, n="block", ch=False)
    Tor6 = cmds.polyPipe(r=0.07, t=0.04, h=0.9434)
    cmds.move(0.115, moveX=True)
    cmds.move(0.109, moveZ=True)
    cmds.delete(ch=True)
    cu[0] = cmds.polyBoolOp(Tor6[0], cu[0], op=1, n="block", ch=False)
Exemple #20
0
def createPipeExtrusion(cubeSizeX, cubeSizeY, cubeSizeZ, blockWidth,
                        blockDepth):

    blockWidth = str(blockWidth).rsplit(".", 1)[0]
    blockWidth = int(blockWidth)

    for i in range(blockWidth):
        for j in range(blockDepth):
            cyl = cmds.polyPipe(r=0.24, h=0.34, t=0.05)
            cmds.move((cubeSizeY + 0.05), moveY=True, a=True)
            cmds.move(((i * 0.8) - (cubeSizeX / 2.0) + 0.4),
                      moveX=True,
                      a=True)
            cmds.move(((j * 0.8) - (cubeSizeZ / 2.0) + 0.4),
                      moveZ=True,
                      a=True)
            cmds.delete(ch=True)

            cu[0] = cmds.polyBoolOp(cu[0], cyl[0], op=1, n="block", ch=False)
Exemple #21
0
def createHoles(cubeSizeX, cubeSizeY, cubeSizeZ, blockWidth, blockDepth):

    blockWidth = str(blockWidth).rsplit(".", 1)[0]
    blockWidth = int(blockWidth)

    for i in range(blockWidth - 1):
        cylinderDepth = blockDepth + (blockDepth * 0.3)
        cyl = cmds.polyCylinder(r=0.24, h=cylinderDepth)
        cmds.move((cubeSizeY - 0.30), moveY=True, a=True)
        cmds.move(((i * 0.8) - (cubeSizeX / 2.0) + 0.8), moveX=True, a=True)
        cmds.move(((0 * 0.8) - (cubeSizeZ / 2.0) + 0.25), moveZ=True, a=True)
        cmds.rotate(90, 0, 0)
        cmds.delete(ch=True)
        cu[0] = cmds.polyBoolOp(cu[0],
                                cyl[0],
                                op=2,
                                n="block" + str(i),
                                ch=False)

    createBevels(cubeSizeX, cubeSizeY, cubeSizeZ, blockWidth, blockDepth)
    def voxelize(self, source, voxelSize, gapSize, knifeCount, offset):
        """ Voxelize the first object in source. """
        if len(source) < 1:
            return ""
        objName = source[0]
        boundingBox = cmds.exactWorldBoundingBox(source[0])
        #translation = [(boundingBox[i] + boundingBox[i + 3]) / 2.0 for i in range(3)]
        knifeSize = max(
            [boundingBox[i + 3] * 2 - boundingBox[i] * 2 for i in range(3)])
        knifeSize = max(knifeSize, voxelSize * (1 + max(knifeCount)))

        # Build knife frame and cut the source object
        base = [-voxelSize * (knifeCount[i] - 1) / 2.0 for i in range(3)]

        knifeX = cmds.polyCube(n='knife1', w=gapSize, h=knifeSize, d=knifeSize)
        cmds.move(base[0], 0, 0, knifeX[0])
        cmds.move(offset[0], offset[1], offset[2], knifeX[0], relative=True)
        knifeY = cmds.polyCube(n='knife2', w=knifeSize, h=gapSize, d=knifeSize)
        cmds.move(0, base[1], 0, knifeY[0])
        cmds.move(offset[0], offset[1], offset[2], knifeY[0], relative=True)
        knifeZ = cmds.polyCube(n='knife3', w=knifeSize, h=knifeSize, d=gapSize)
        cmds.move(0, 0, base[2], knifeZ[0])
        cmds.move(offset[0], offset[1], offset[2], knifeZ[0], relative=True)

        for i in range(1, knifeCount[0]):
            knife = cmds.duplicate(knifeX[0])
            cmds.move(voxelSize * i, 0, 0, knife[0], relative=True)
            source = cmds.polyBoolOp(source[0], knife[0], op=2)

        for i in range(1, knifeCount[1]):
            knife = cmds.duplicate(knifeY[0])
            cmds.move(0, voxelSize * i, 0, knife[0], relative=True)
            source = cmds.polyBoolOp(source[0], knife[0], op=2)

        for i in range(1, knifeCount[2]):
            knife = cmds.duplicate(knifeZ[0])
            cmds.move(0, 0, voxelSize * i, knife[0], relative=True)
            source = cmds.polyBoolOp(source[0], knife[0], op=2)

        source = cmds.polyBoolOp(source[0], knifeX[0], op=2)
        source = cmds.polyBoolOp(source[0], knifeY[0], op=2)
        source = cmds.polyBoolOp(source[0], knifeZ[0], op=2)

        cmds.delete(source[0], ch=True)
        objName = cmds.rename(source[0], objName)
        cmds.xform(objName, cpc=True)

        return objName
def makeTrafficLight(glow):
    '''
    Creates a traffic light.
    
    glow: String that determines what colour should be glowing on the traffic
          light. Valid values are "R", "G", "Y" and "RY".
    On exit: A traffic light has been created and the right shaders have been
             assigned to it. The traffic light polygonal object is returned as a
             tuple containing the object name and node name.
    '''
    pole = cmds.polyCube(n = "pole", w = 0.1,d = 0.1, h = 2)
    cmds.xform(pole, translation = (0, 1, 0))
    cmds.sets(pole[0], edit=True, forceElement="blackMetalGroup")
    box = cmds.polyCube(n = "box", w = 0.3, d = 0.3, h = 0.7)
    cmds.xform(box, translation = (0, 2.35, 0))
    cmds.sets(box[0], edit=True, forceElement="blackMetalGroup")
    lights = cmds.polyCylinder(n = "light", r = 0.1, h = 0.2, sx = 12)
    cmds.xform(lights, rotation = (90, 0, 0))
    cmds.xform(lights, translation = (0, 2.575, 0.15), ws = True)
    cmds.polyChipOff(lights[0] + ".f[0:13]" , dup = True, kft = True, 
                             translate = (0, -0.225,0))
    cmds.polyChipOff(lights[0] + ".f[0:13]" , dup = True, kft = True, 
                             translate = (0, -0.45,0))
    if glow == "R" or glow == "RY":
        cmds.sets(lights[0] + ".f[0:13]", edit=True, forceElement="redLightGroup")
    else:
        cmds.sets(lights[0] + ".f[0:13]", edit=True, forceElement="redGroup")
    if glow == "Y" or glow == "RY":
        cmds.sets(lights[0] + ".f[14:27]", edit=True, forceElement="yellowLightGroup")
    else:
        cmds.sets(lights[0] + ".f[14:27]", edit=True, forceElement="yellowGroup")
    if glow == "G":
        cmds.sets(lights[0] + ".f[28:43]", edit=True, forceElement="greenLightGroup")
    else:
        cmds.sets(lights[0] + ".f[28:43]", edit=True, forceElement="greenGroup")
    trafficLight = cmds.polyBoolOp(box[0], lights[0], op = 2)
    trafficLight = cmds.polyUnite(trafficLight[0], pole[0], n = "trafficLight")
    cmds.delete(trafficLight[0], ch = True)
    return trafficLight
Exemple #24
0
def createSideAngles(blockWidth):

    sideCylin1 = cmds.polyCylinder(r=0.31, h=0.8, sz=1)
    cmds.rotate(90, 0, 0)
    cmds.move((-1 * (((blockWidth * 0.8) / 2.0))), moveX=True)
    cmds.move(0.31, moveY=True)
    cmds.delete(ch=True)
    cu[0] = cmds.polyBoolOp(sideCylin1[0], cu[0], op=1, n="block", ch=False)

    sideCylin = cmds.polyCylinder(r=0.31, h=0.8, sz=1)
    cmds.rotate(90, 0, 0)
    cmds.move((((blockWidth * 0.8) / 2.0)), moveX=True)
    cmds.move(0.31, moveY=True)
    cmds.delete(ch=True)
    cu[0] = cmds.polyBoolOp(sideCylin1[0], cu[0], op=1, n="block", ch=False)

    sideCylin2 = cmds.polyCylinder(r=0.28, h=0.15, sz=1)
    cmds.rotate(90, 0, 0)
    cmds.move((-1 * (((blockWidth * 0.8) / 2.0))), moveX=True)
    cmds.move(((0 * 0.05) - (1 / 2.0) + 0.829), moveZ=True)
    cmds.move(0.31, moveY=True)
    cmds.delete(ch=True)
    cu[0] = cmds.polyBoolOp(cu[0], sideCylin2[0], op=2, n="block", ch=False)

    sideCylin3 = cmds.polyCylinder(r=0.28, h=0.15, sz=1)
    cmds.rotate(90, 0, 0)
    cmds.move((((blockWidth * 0.8) / 2.0)), moveX=True)
    cmds.move(((0 * 0.05) - (1 / 2.0) + 0.829), moveZ=True)
    cmds.move(0.31, moveY=True)
    cmds.delete(ch=True)
    cu[0] = cmds.polyBoolOp(cu[0], sideCylin3[0], op=2, n="block", ch=False)

    difference1 = cmds.polyCylinder(r=0.24, h=2)
    cmds.rotate(90, 0, 0)
    cmds.move((-1 * ((blockWidth * 0.8) / 2.0)), moveX=True)
    cmds.move(0.31, moveY=True)
    cmds.delete(ch=True)
    cu[0] = cmds.polyBoolOp(cu[0], difference1[0], op=2, n="block", ch=False)

    difference2 = cmds.polyCylinder(r=0.24, h=2)
    cmds.rotate(90, 0, 0)
    cmds.move((((blockWidth * 0.8) / 2.0)), moveX=True)
    cmds.move(0.31, moveY=True)
    cmds.delete(ch=True)
    cu[0] = cmds.polyBoolOp(cu[0], difference2[0], op=2, n="block", ch=False)
    cmds.polyCube(n='Rempart',w=0.5,h=0.5,d=1)
    cmds.xform(ws=True,piv=(0,-.25,0))
    cmds.move(0,.25,0)
    cmds.move(0,.2,3.2, relative=True)
    cmds.xform(ws=True, rotatePivot=(0,0,0))
    cmds.rotate(0,30*i,0)


for i in range(12):
    cmds.polyCube(n='Fente',w=1,h=.5,d=.1)
    cmds.move(3.2,0,0, relative=True)
    cmds.xform(ws=True, rotatePivot=(0,0,0))
    cmds.rotate(0,30*i,0)



cmds.group('Fente*', n='GroupFentes')
cmds.group('Remp*',n='GroupRempart')

cmds.rotate(0,15,0,)

cmds.polyUnite('Fente*','Rempart*',n='TrouResult')
cmds.polyBoolOp('Remp','TrouResult', op=2, n='RempartResult')
cmds.move(0,0.2,0)

cmds.group('GroupTour','GroupFentes','GroupRempart','RempartResult','TrouResult', n='Tour')

cmds.duplicate('Tour',n='TourHaut')
cmds.move(0,3,0)
cmds.scale(.8,.8,.8)
 def makeWindows(self, name_, windowShaders, booleans):
     '''
     Creates windows for a box house. 
     
     self: Object of the class BoxHouse.
     name_: A string with the name the house will have.
     windowShader: A list with shaders for the windows.
     booleans: A boolean variable which determines whether the windows should be 
               combined with the house using boolean difference or not. 
     On exit: Columns of windows are created using makeWindowColumn(...) and these
              are then duplicated around the house. The windows are assigned shaders
              using assignWindowShaders(...), and are then combined with the 
              house. The House object's name attribute is updated.        
     '''
     windowHeight = random.uniform(0.5,1.9)
     # Make sure the window height is not too close to 1.6 since the window edge
     # in that case will be too close to a edge loop on the house and the boolean
     # operation will fail.
     if booleans and (windowHeight > 1.59 and windowHeight < 1.61):
         windowHeight = random.choice([1.59, 1.61])
     windowWidth = random.uniform(1, 3)
     floorHeight = int(math.ceil(windowHeight))
     heightNum = max(0,int((self.height - (1 + floorHeight/2.0))/floorHeight))
     if heightNum == 0:
         return
     widthNum = max(0,int((self.width - 0.3) / (windowWidth)))
     if (widthNum != 0):
         # Makes it possible for houses to have less windows or no windows on a side.
         widthNum = widthNum - random.randint(0, min(2, widthNum)) 
     # Space between window columns along the width of the house.
     widthSpace = (self.width - (widthNum * windowWidth)) /(widthNum + 1) 
     depthNum = max(0,int((self.depth - 0.3)/ windowWidth))
     if (depthNum != 0):
         # Makes it possible for houses to have less windows or no windows on a side.
         depthNum = depthNum - random.randint(0, min(2, depthNum))
     if (depthNum == 0) and (widthNum == 0):
         return
     # Space between window columns along the width of the house.
     depthSpace = (self.depth - (depthNum * windowWidth)) / (depthNum + 1)
     windowColumn = makeWindowColumn(windowWidth,windowHeight, heightNum, floorHeight)
     for j in range(widthNum):
         # Duplicates all the faces of the first window column and translates the duplicates along the width.
         cmds.polyChipOff(windowColumn[0] + ".f[0:" + str((heightNum * 6) - 1) + "]", dup = True, kft = True, 
                          translate = (-self.width/2.0 + windowWidth/2.0 + widthSpace + (windowWidth + widthSpace) * j,
                          0, self.depth/2.0))
         cmds.polyChipOff(windowColumn[0] + ".f[0:" + str((heightNum * 6) - 1) + "]", dup = True, kft = True, 
                          translate =  (-self.width/2.0 + windowWidth/2.0 + widthSpace + (windowWidth + widthSpace) * j, 
                          0, -self.depth/2.0))       
         cmds.delete(all = True, ch = True)   
         cmds.refresh()
     cmds.select(windowColumn[0] + ".f[0:" + str((heightNum * 6) - 1) + "]")
     cmds.rotate(90, y = True)
     for j in range(depthNum):
         # Duplicates all the faces of the first window column and translates the duplicates along the depth.
         cmds.polyChipOff(windowColumn[0] + ".f[0:" + str((heightNum * 6) - 1) + "]", dup = True, kft = True,
                          translate = (self.width/2.0, 0, -self.depth/2.0 + windowWidth/2.0 + depthSpace + (windowWidth + depthSpace) * j), ws = True)
         cmds.polyChipOff(windowColumn[0] + ".f[0:" + str((heightNum * 6) - 1) + "]", dup = True, kft = True,
                          translate = (-self.width/2.0, 0, -self.depth/2.0 + windowWidth/2.0 + depthSpace + (windowWidth + depthSpace) * j), ws = True)
         cmds.delete(all = True, ch = True)
         cmds.refresh()
     cmds.select(windowColumn[0] + ".f[0:" + str((heightNum * 6) - 1) + "]")
     cmds.delete()
     windowNum = widthNum * heightNum * 2 + depthNum * heightNum * 2 # Total number of windows.
     assignWindowShaders(windowColumn, windowNum, windowShaders)
     cmds.select(windowColumn[0] + ".f[0:" + str(windowNum * 6 - 1) +"]")
     cmds.polySubdivideFacet()
     if booleans:
         result = cmds.polyBoolOp(self.name,windowColumn[0], op = 2, n = name_)
     else:
         result = cmds.polyUnite(self.name,windowColumn[0], n = name_)
     self.name = result[0]
     cmds.delete(self.name, ch = True) 
def cut_by_part(obj, part):
	dup_obj = cmds.duplicate(obj)[0]
	new_cut = cmds.polyBoolOp(dup_obj, part, op=3)[0]
	return new_cut
Exemple #28
0
def rec(remaining, part, move):
	print 'enter step', (move-5)/3

	# last part
	if len(part) == 1: 
		print 'done'
		return True
		# print 'last part!'
		# vol_rem = volume(remaining)
		# vol_part = volume(part)
		# ratio = vol_rem / vol_part
		# if ratio < 15 and ratio > 0.6:
		# 	print 'last part going to return true'
		# 	return True
		# else:
		# 	print 'last part going to return false'
		# 	cmds.delete(remaining)
		# 	return False

	backup_rem = cmds.duplicate(remaining)
	bbox_rem = cmds.exactWorldBoundingBox(remaining)
	for j in range(30):
		# get the cutpart at right position
		cutpart = create_part(part[0])
		cutcenter = rand_center(remaining)
		move_obj_center(cutpart, cutcenter)

		vol_part = volume(cutpart)
		bbox_cut = cmds.exactWorldBoundingBox(cutpart)

		# percentage outside check
		pi = vertices_outside(bbox_rem, bbox_cut)
		if pi <= 6:
			cmds.delete(cutpart)
			continue

		# volumn check
		dum_rem = cmds.duplicate(remaining)
		dum_cut = cmds.duplicate(cutpart)
		new_cut = cmds.polyBoolOp(dum_rem, dum_cut, op=3)[0]
		new_rem = cmds.polyBoolOp(remaining, cutpart, op=2)[0]
		vol_cut = volume(new_cut)
		if vol_cut / vol_part > 0.5:
			# this part might work
			result = rec(new_rem, part[1:], move + 3)
			if result == True:
				print 'sol found, return to upper lv'
				cmds.move(move, 0, 0, new_cut, r=1)
				cmds.delete(backup_rem)
				return True
			else:
				cmds.delete(new_cut)
				remaining = cmds.duplicate(backup_rem)
				print 'try again in step', move
		else:
			cmds.delete(new_cut)
			cmds.delete(new_rem)
			remaining = cmds.duplicate(backup_rem)

	print 'fail in step', (move-5)/3
	cmds.delete(backup_rem)
	cmds.delete(remaining)
	return False
Exemple #29
0
def polyBoolOp(*args, **kwargs):
    res = cmds.polyBoolOp(*args, **kwargs)
    if not kwargs.get('query', kwargs.get('q', False)):
        res = _factories.maybeConvert(res, _general.PyNode)
    return res
Exemple #30
0
def cut_by_part(obj, part):
	dup_obj = cmds.duplicate(obj)[0]
	new_cut = cmds.polyBoolOp(dup_obj, part, op=3, useThresholds=1, preserveColor=1)[0]
	return new_cut
Exemple #31
0
#all rest are the cubes
stencils = cmds.ls(sl=True)[1:]
#print cubes

newObjs = []
count = 0

for stencil in stencil:
    #dupe obj as objDupe
    newObj = cmds.duplicate(obj)
    #put obj dupe in list
    newObjs.append(newObj)
    #bool with the object selections (stencil then obj)
    #polyBoolOp -op 3 -ch 1 -useThresholds 1 -preserveColor 0 pstencil2 pSphere1;
    cmds.polyBoolOp(stencil, newObj, op=3, n="BooledObj_%s"%count)
    #hide stencil
    cmds.setAttr("%s.v"%stencil, 0)
    
    count += 1

    #delete history on the newObjs
	# Deal with transferring the pivot point of cubes to new pieces of geo

    #create an empty group, name it "newObj_Grp"
    #parent the newObjs into the group
    #hide the orig object


# Deal with UV mapping from original to new
def rec(remaining, part, move):
	print 'enter step', (move-5)/3

	if len(part) == 0: 
		print 'done', remaining
		return True

	backup_rem = cmds.duplicate(remaining)
	bbox_rem = cmds.exactWorldBoundingBox(remaining)

	# for all possible centers
	# center must be inside the bounding box
	# here we consider centers lies on one subdivision of axis
	nn = 20
	xsub = nn
	ysub = nn
	zsub = nn
	sum = 0
	for x in xrange(xsub):
		for y in xrange(ysub):
			for z in xrange(zsub):
				# for all possible orientations
				# create part
				cutpart = part_by_aspect(part[0])
				# move part to this center
				cutcenter = center_with_sub_index(bbox_rem, x/float(xsub), y/float(ysub), z/float(zsub))
				move_obj_center(cutpart, cutcenter)

				# store volume
				bbox_cut = cmds.exactWorldBoundingBox(cutpart)
				vol_part = volume_with_bbox(bbox_cut)

				# percentage of vertex outside check
				pi = vertices_outside(bbox_rem, bbox_cut)
				if pi < 6:
					cmds.delete(cutpart)
					continue

				# cut the part out from remaining
				dum_rem = cmds.duplicate(remaining)
				dum_cut = cmds.duplicate(cutpart)
				new_cut = cmds.polyBoolOp(dum_rem, dum_cut, op=3)[0]
				new_rem = cmds.polyBoolOp(remaining, cutpart, op=2)[0]

				# shell check
				# make sure that new_cut contains one single object
				if cmds.polyEvaluate(new_cut, shell = True) != 1:
					cmds.delete(new_rem)
					cmds.delete(new_cut)
					remaining = cmds.duplicate(backup_rem)
					continue

				# volume check
				vol_cut = volume(new_cut)
				if vol_cut / vol_part  > 0.4:
					# this part might work
					result = rec(new_rem, part[1:], move + 3)
					if result == True:
						sum = sum + 1
						print 'sol found, return to upper lv', vol_cut, vol_part
						cmds.move(move, 0, 0, new_cut, r=1)
						cmds.delete(backup_rem)
						return True
				else:
					print vol_cut / vol_part 

					cmds.delete(new_rem)
					cmds.delete(new_cut)
					remaining = cmds.duplicate(backup_rem)
			
	# no solusion after tried all
	print 'fail in step', (move-5)/3, 'try', sum
	cmds.delete(backup_rem)
	cmds.delete(remaining)
	return False
Exemple #33
0
 def uniformVoroPoints(self):
     '''
     Performs voronoi uniform fragmentation
     '''
     # duplicate original shape
     mVoroInputMeshFn = OpenMaya.MFnMesh(self._mVoroInputMeshDAG)
     
     mPoints = OpenMaya.MPointArray()
     mVerticesCount = OpenMaya.MIntArray()
     mVerticesList = OpenMaya.MIntArray()        
     
     mVoroInputMeshFn.getPoints(mPoints, OpenMaya.MSpace.kWorld)
     mVoroInputMeshFn.getVertices(mVerticesCount, mVerticesList)
     mNumPoly = mVoroInputMeshFn.numPolygons()
     
     mCopyMeshFn = OpenMaya.MFnMesh()
     mCopyTrs = mCopyMeshFn.create(mPoints.length(), mNumPoly, mPoints, mVerticesCount, mVerticesList)
     
     mDagPath = OpenMaya.MDagPath()
     OpenMaya.MDagPath.getAPathTo(mCopyTrs, mDagPath)
     mMeshName = mDagPath.fullPathName()             
     
     # create boolean op between sphere and duplicated shape
     mRadius = cmds.getAttr(self._mVoroImpactShape + '.radius')
     mRadius = max(.15, mRadius)
     
     mImpact = cmds.polySphere(r = mRadius, sx = 8, sy = 8)
     cmds.xform(mImpact[0], translation = [self._mOriginPt.x, self._mOriginPt.y, self._mOriginPt.z])
     
     cmds.select(clear = True)       
     mVolume = None
     
     if int(cmds.about(version = True).split()[0]) > 2014:        
         try:
             mVolume = cmds.polyCBoolOp(mMeshName, mImpact[0], op = 3, ch = False, classification = 1, n = 'IS_Volume')
         except:
             pass               
         
     else:
         try:
             mVolume = cmds.polyBoolOp(mMeshName, mImpact[0], op = 3, ch = False, n = 'IS_Volume')
         except:
             pass                    
     
     cmds.flushUndo()
     
     # Check if mVolume is valid
     if mVolume:       
         if cmds.polyEvaluate(mVolume, face = True) == 0:            
             cmds.delete(mVolume)
             mVolume = cmds.polySphere(r = mRadius, sx = 8, sy = 8)
         
     else:
        mVolume = cmds.polySphere(r = mRadius, sx = 8, sy = 8) 
     
     # Fill volume of the boolean object with points
     mSelection = OpenMaya.MSelectionList()
     mSelection.add(mVolume[0])
     mSelection.getDagPath(0, mDagPath)
     mDagPath.extendToShape()
     
     mVerts = OpenMaya.MPointArray()
     triangleCounts, triangleVertices = OpenMaya.MIntArray(), OpenMaya.MIntArray()        
     
     mVolMeshFn = OpenMaya.MFnMesh(mDagPath)
     mVolMeshFn.getPoints(mVerts, OpenMaya.MSpace.kWorld)
     mVolMeshFn.getTriangles(triangleCounts, triangleVertices)
     numTriangles = triangleVertices.length() / 3
     
     mHitPoint = OpenMaya.MFloatPoint()
     mFloatRaySource = OpenMaya.MFloatPoint()
     mFloatRayNormal = OpenMaya.MFloatVector()
     
     # Randomly select a face, find a point on face surface (with bary coords) and launch a ray from the reversed normal
     mAccelerationStructure = mVolMeshFn.autoUniformGridParams()        
     for n in xrange(self._mVoroCount):
         
         triId = rand.randint(0, numTriangles-1)
         v0 = triangleVertices[3 * triId + 0]
         v1 = triangleVertices[3 * triId + 1]
         v2 = triangleVertices[3 * triId + 2]
         
         mVectorAB = mVerts[v1] - mVerts[v0]
         mVectorAC = mVerts[v2] - mVerts[v0]
         mNormal = (mVectorAB ^ mVectorAC) * -1.0
         mNormal.normalize()
         
         u = rand.uniform(0.0,1.0)
         v = rand.uniform(0.0, (1.0 - u))
         
         mSample = (mVerts[v0] + mVectorAB * u + mVectorAC * v) + (mNormal * 0.001)	        
         mFloatRaySource.x, mFloatRaySource.y, mFloatRaySource.z = mSample.x, mSample.y, mSample.z
         mFloatRayNormal.x, mFloatRayNormal.y, mFloatRayNormal.z = mNormal.x, mNormal.y, mNormal.z
         
         hit = mVolMeshFn.closestIntersection(
                                                 mFloatRaySource,
                                                 mFloatRayNormal,
                                                 None,
                                                 None,
                                                 None,
                                                 OpenMaya.MSpace.kWorld,
                                                 99999,
                                                 None,
                                                 mAccelerationStructure,
                                                 mHitPoint,
                                                 None,
                                                 None,
                                                 None,
                                                 None,
                                                 None
                                             )
        
         if hit:
             mDistance = mFloatRaySource.distanceTo(mHitPoint)
             self._mVoroPoints.append(mSample + (mNormal * rand.uniform(0.0, mDistance)))                
     
     mVolMeshFn.freeCachedIntersectionAccelerator()        
     cmds.delete(mVolume)
     
     # hide IShatter sphere helper
     cmds.setAttr(self._mVoroImpactTrs + '.visibility', False)
     cmds.setAttr(self._mVoroImpactShape + '.radius', 0.0001)
     cmds.xform(self._mVoroImpactTrs, translation = [0.0, 0.0, 0.0])
     self._mView.refresh(False, True)        
     
     # update fractureFX
     mel.eval("fxEraseParticles " + self._mVoroParticleObject)
     mVoroParticleSysFn = OpenMayaFX.MFnParticleSystem(self._mVoroParticleSysDAG)
     mVoroParticleSysFn.emit(self._mVoroPoints)
     mVoroParticleSysFn.saveInitialState()                                  
def BOOLEAN(NSTMP, obj1, obj2, OP, RENAME):
    cmds.polyBoolOp(NSTMP + obj1, NSTMP + obj2, op=OP, n="merge")
    cmds.delete(ch=True)
    cmds.rename(RENAME)
Exemple #35
0
def cubeVoro(obj, points, offset, rgb):
	mc.undoInfo( state = False)

	#variables
	usedPoints =[]
	validPoints =[]
	objBB = bbMinMaxMVector(obj)
	
	# open a progress window
	amount = 0
	mc.progressWindow(
	title = "Voronoi Shatter",
	progress = 0,
	status = "Initializing . . .",
	isInterruptable = True,
	maxValue = len(points)  )#end of progress window

	shardsGRP = mc.group(empty = True, name = (obj + '_shardsGRP'))
	color = rgb
	aim = (0,0,1) # Z_direction
	mat = makeMat(obj, color)
	check = 2*(om.MVector.length(objBB[1] - objBB[0]))
	


	for aPos in points:
	
		# Check if the dialog has been cancelled
		if mc.progressWindow( query=True, isCancelled=True ) : break
		# Check if end condition has been reached
		if mc.progressWindow( query=True, progress=True ) >= len(points) : break
		amount += 1
		
		#initialise the setup
		mult = 0.1
		BB1 = makeMVectorBB(aPos, objBB[0], objBB[1], mult)
		radius = om.MVector.length(objBB[1] - objBB[0])*2
		
		
		#initialise the lists
		usedPoints = [] # no used points here
		usedPoints.append(aPos)
		
		#dupe the cell
		shards = cubeCell(obj,shardsGRP,mat,aPos)
		activeShard = shards[0]
		#mc.delete(activeShard, ch = True)
		cutShard = shards[1]
		#mc.delete(cutShard, ch = True)
		
		while om.MVector.length(BB1[1] - BB1[0])< check:

			validPoints = []
			check1 = arePointsInRad(radius, aPos, points)
			check2 = arePointsinBBMVector(BB1[0], BB1[1], points)
			
			for point in check2:
				if point not in usedPoints and point in check1:
					validPoints.append(point)
				
			for bPos in validPoints:

				cutPos = calcMidPointMVector(aPos, bPos, aim, offset)
				cutCell(activeShard, mat, cutPos[0], cutPos[1], shardsGRP)
				usedPoints.append(bPos)
	
				#fit radius to activeShard, which will reduce with cuts
				#activeBB = bbMinMaxMVector(activeShard)
				intersect = BBintersection(activeShard, obj)
				radius = findMaxDistance(intersect[0], intersect[1], aPos)*2
				
			
			#increaseBB1 to get out of while loop
			mult *= 1.1
			BB1 = makeMVectorBB(aPos, objBB[0], objBB[1], mult)
			
		bool = mc.polyBoolOp( activeShard, cutShard, op=3, ch = False, n = (obj + '_shard_1'))
		#mc.delete(bool, ch = True)
		mc.parent(bool, shardsGRP)
		
		mc.progressWindow( edit=True, progress=amount, status=("Voronoi Shatter step %d of %d completed . . ." % (amount, len(points))) )
		mc.refresh()

	mc.progressWindow(endProgress=1)
	mc.undoInfo( state = True)
def cubeVoro(obj, points, offset, rgb):
    mc.undoInfo(state=False)

    #variables
    usedPoints = []
    validPoints = []
    objBB = bbMinMaxMVector(obj)

    # open a progress window
    amount = 0
    mc.progressWindow(title="Voronoi Shatter",
                      progress=0,
                      status="Initializing . . .",
                      isInterruptable=True,
                      maxValue=len(points))  #end of progress window

    shardsGRP = mc.group(empty=True, name=(obj + '_shardsGRP'))
    color = rgb
    aim = (0, 0, 1)  # Z_direction
    mat = makeMat(obj, color)
    check = 2 * (om.MVector.length(objBB[1] - objBB[0]))

    for aPos in points:

        # Check if the dialog has been cancelled
        if mc.progressWindow(query=True, isCancelled=True): break
        # Check if end condition has been reached
        if mc.progressWindow(query=True, progress=True) >= len(points): break
        amount += 1

        #initialise the setup
        mult = 0.1
        BB1 = makeMVectorBB(aPos, objBB[0], objBB[1], mult)
        radius = om.MVector.length(objBB[1] - objBB[0]) * 2

        #initialise the lists
        usedPoints = []  # no used points here
        usedPoints.append(aPos)

        #dupe the cell
        shards = cubeCell(obj, shardsGRP, mat, aPos)
        activeShard = shards[0]
        #mc.delete(activeShard, ch = True)
        cutShard = shards[1]
        #mc.delete(cutShard, ch = True)

        while om.MVector.length(BB1[1] - BB1[0]) < check:

            validPoints = []
            check1 = arePointsInRad(radius, aPos, points)
            check2 = arePointsinBBMVector(BB1[0], BB1[1], points)

            for point in check2:
                if point not in usedPoints and point in check1:
                    validPoints.append(point)

            for bPos in validPoints:

                cutPos = calcMidPointMVector(aPos, bPos, aim, offset)
                cutCell(activeShard, mat, cutPos[0], cutPos[1], shardsGRP)
                usedPoints.append(bPos)

                #fit radius to activeShard, which will reduce with cuts
                #activeBB = bbMinMaxMVector(activeShard)
                intersect = BBintersection(activeShard, obj)
                radius = findMaxDistance(intersect[0], intersect[1], aPos) * 2

            #increaseBB1 to get out of while loop
            mult *= 1.1
            BB1 = makeMVectorBB(aPos, objBB[0], objBB[1], mult)

        bool = mc.polyBoolOp(activeShard,
                             cutShard,
                             op=3,
                             ch=False,
                             n=(obj + '_shard_1'))
        #mc.delete(bool, ch = True)
        mc.parent(bool, shardsGRP)

        mc.progressWindow(
            edit=True,
            progress=amount,
            status=("Voronoi Shatter step %d of %d completed . . ." %
                    (amount, len(points))))
        mc.refresh()

    mc.progressWindow(endProgress=1)
    mc.undoInfo(state=True)