Exemplo n.º 1
0
def export_selected_mesh(meshname):
    print("Exporting [{0}]...".format(meshname))
    selected = pm.ls(selection=True)
    if len(selected) != 1:
        gui_message = "CowByte: Failed to export - nothing/or too many selected! One mesh at a time!"
        show_message_popup("Export Failure", gui_message)
        print(gui_message)
        return False

    # TODO: error checking, this is assuming selected has first child as Mesh.
    mesh = pm.listRelatives(selected[0])[0]
    pm.polyTriangulate(
        mesh)  # triangulate the mesh first, since CBE only takes triangles.
    faces = mesh.faces
    export_meshfile(meshname, export_folder + meshname + ".mesha")
    export_pos_buf(faces, export_folder + meshname + "_pos.bufa")
    export_index_buf(faces, export_folder + meshname + "_index.bufa")
    export_normal_buf(faces, export_folder + meshname + "_normal.bufa")
    export_uv(faces, export_folder + meshname + "_uv.bufa")

    print("Finished exporting [{0}].".format(meshname))
    show_message_popup(
        "Export Success",
        "Files have been exported to {0}.".format(export_folder))
    return True
Exemplo n.º 2
0
 def __init__(self, mesh):
     # HACK: I should really do the triangulation in memory rather than changing the scene.
     # However, this is fine for now.
     native.polyTriangulate(mesh)
     self.vertices = tuple(tuple(v) for v in mesh.getPoints())
     self.indices = tuple(self._compute_indices(mesh))
     self.uvs = tuple(self._compute_uvs(mesh))
     self.normals = tuple(self._compute_normals(mesh))
Exemplo n.º 3
0
 def __init__(self, mesh):
     # HACK: I should really do the triangulation in memory rather than changing the scene.
     # However, this is fine for now. 
     native.polyTriangulate(mesh)
     self.vertices = tuple(tuple(v) for v in mesh.getPoints())
     self.indices = tuple(self._compute_indices(mesh))
     self.uvs = tuple(self._compute_uvs(mesh))
     self.normals = tuple(self._compute_normals(mesh))
Exemplo n.º 4
0
def writeMeshListToFile(meshList, spaceType, grouping, materials, myFile):
    nrOfPos = 0
    nrOfUVs = 0
    nrOfNor = 0
    for obj in meshList:
        #Triangulate mesh so that the object(s) can be imported correctly later
        pm.polyTriangulate(obj)

        myFile.write('g default\r\n')  #I don't know what this is for
        #Save all positions for the mesh
        for v in obj.vtx:
            pos = v.getPosition(space=spaceType)
            myFile.write('v ' + str(round(pos.x, 6)) + ' ' +
                         str(round(pos.y, 6)) + ' ' + str(round(pos.z, 6)) +
                         '\r\n')

        #Save all UVs for the mesh
        U, V = obj.getUVs()
        UVs = zip(U, V)
        for uv in UVs:
            myFile.write('vt ' + str(round(uv[0], 6)) + ' ' +
                         str(round(uv[1], 6)) + '\r\n')

        #Save all normals for the mesh
        for n in obj.getNormals():
            myFile.write('vn ' + str(round(n.x, 6)) + ' ' +
                         str(round(n.y, 6)) + ' ' + str(round(n.z, 6)) +
                         '\r\n')

        #Write this here if grouping is true
        if grouping is True:
            myFile.write('g ' + obj + '\r\n')

        #Write this here if materials is true
        if materials is True and len(obj.shadingGroups()) > 0:
            myFile.write('usemtl ' + obj.shadingGroups()[0] + '\r\n')

        #Match all values so that they together build triangles
        #Triangles are described like v/vt/vn v/vt/vn v/vt/vn
        for f in obj.faces:
            v_idxs = [v + 1 + nrOfPos for v in f.getVertices()]
            t_idxs = [f.getUVIndex(i) + 1 + nrOfUVs for i in range(3)]
            n_idxs = [f.normalIndex(i) + 1 + nrOfNor for i in range(3)]
            s = 'f ' + str(v_idxs[0]) + '/' + str(t_idxs[0]) + '/' + str(
                n_idxs[0]) + ' '
            s += str(v_idxs[1]) + '/' + str(t_idxs[1]) + '/' + str(
                n_idxs[1]) + ' '
            s += str(v_idxs[2]) + '/' + str(t_idxs[2]) + '/' + str(n_idxs[2])
            myFile.write(
                s +
                '\r\n')  #The result here describes a triangle is a triangle
        myFile.write(
            '\r\n')  #To separate info from this mesh from the next one

        #Increase the nr of pos, uvs & normals for the next mesh
        nrOfPos += len(obj.vtx)
        nrOfUVs += len(UVs)
        nrOfNor += len(obj.getNormals())
Exemplo n.º 5
0
def duplicate_triangulate_mesh(skinned_mesh, dup_namespace=None, dup_parent=None):
    dup_namespace = dup_namespace or pm.namespaceInfo(currentNamespace=True)
    with nsutils.preserve_namespace(dup_namespace):
        dup_skinned_mesh_tri = nsutils.duplicate_to_namespace(
            skinned_mesh, dup_namespace=dup_namespace, dup_parent=dup_parent)[0]
        pm.polyTriangulate(dup_skinned_mesh_tri, ch=True)
        pm.delete(dup_skinned_mesh_tri, constructionHistory=True)
        dup_skin_cluster = bind_mesh_like_mesh(skinned_mesh, dup_skinned_mesh_tri)
        copy_weights(skinned_mesh, dup_skinned_mesh_tri)
    return dup_skinned_mesh_tri, dup_skin_cluster
Exemplo n.º 6
0
def make_bake_mesh( meshes, name = '' ):
  """
  Turn one or more meshes into a single mesh for export to xNormal
  """
  
  arg_string = ''
  meshes = list( set( meshes ) )
  
  pmc.select( clear = True )
  
  if len( meshes ) == 0:
    return False
  
  if len( meshes ) > 1:

    if name == '':
      name = 'bake_mesh'
      
    merged = pmc.polyUnite( meshes, ch = False, name = name )
    
  else:
    merged = meshes[ 0 ]
    
  tr = pmc.polyTriangulate( merged, ch = False)
  
  return merged
Exemplo n.º 7
0
def export(object_name, start, end):
    # select to export
    select_poly_list = pm.ls(selection=True)
    poly_num = len(select_poly_list)
    # triangulate
    for i in xrange(poly_num):
        poly_name = str(select_poly_list[i])
        pm.polyTriangulate(poly_name)
    # select polygon
    pm.select(select_poly_list)
    # export to obj
    for time in xrange(int(start), int(end) + 1):
        pm.currentTime(time)
        obj_name = os.path.join(
            OBJPATH, '{name}_tri.{num:04}.obj'.format(name=object_name,
                                                      num=time))
        pm.exportSelected(obj_name, type='OBJexport')
Exemplo n.º 8
0
def export_fbx(force, transf, triangulate, smooth):
    initial_selection = pmc.ls(sl=True)

    # Duplicate and triangulate if wanted
    dup = None

    if smooth and triangulate:
        dup = pmc.duplicate(transf)
        pmc.polySmooth(dup,
                       mth=0,
                       sdt=2,
                       ovb=1,
                       ofb=1,
                       ofc=0,
                       ost=0,
                       ocr=0,
                       dv=2,
                       bnr=1,
                       c=1,
                       kb=1,
                       ksb=1,
                       khe=0,
                       kt=1,
                       kmb=1,
                       suv=1,
                       peh=0,
                       sl=1,
                       dpe=1,
                       ps=0.1,
                       ro=1,
                       ch=1)
        pmc.polyTriangulate(dup)
        pmc.select(dup)
    elif smooth:
        dup = pmc.duplicate(transf)
        pmc.polySmooth(dup,
                       mth=0,
                       sdt=2,
                       ovb=1,
                       ofb=1,
                       ofc=0,
                       ost=0,
                       ocr=0,
                       dv=2,
                       bnr=1,
                       c=1,
                       kb=1,
                       ksb=1,
                       khe=0,
                       kt=1,
                       kmb=1,
                       suv=1,
                       peh=0,
                       sl=1,
                       dpe=1,
                       ps=0.1,
                       ro=1,
                       ch=1)
        pmc.select(dup)
    elif triangulate:
        dup = pmc.duplicate(transf)
        pmc.polyTriangulate(dup)
        pmc.select(dup)
    else:
        pmc.select(transf)

    export_path = build_export_path(transf=transf, extension=".fbx")

    try:
        pmc.exportSelected(export_path,
                           force=force,
                           preserveReferences=True,
                           type="FBX export")
        success = True
    except RuntimeError as e:
        logger.error("Could not export node {}".format(transf))
        logger.error(e)
        success = False

    # delete triangulated duplicate again (if created)
    if dup:
        pmc.delete(dup)

    pmc.select(initial_selection)

    return success
Exemplo n.º 9
0
def export_obj(force, transf, triangulate, smooth):
    initial_selection = pmc.ls(sl=True)

    # Duplicate and triangulate if wanted
    dup = None

    if smooth and triangulate:
        dup = pmc.duplicate(transf)
        pmc.polySmooth(dup,
                       mth=0,
                       sdt=2,
                       ovb=1,
                       ofb=1,
                       ofc=0,
                       ost=0,
                       ocr=0,
                       dv=2,
                       bnr=1,
                       c=1,
                       kb=1,
                       ksb=1,
                       khe=0,
                       kt=1,
                       kmb=1,
                       suv=1,
                       peh=0,
                       sl=1,
                       dpe=1,
                       ps=0.1,
                       ro=1,
                       ch=1)
        pmc.polyTriangulate(dup)
        pmc.select(dup)
    elif smooth:
        dup = pmc.duplicate(transf)
        pmc.polySmooth(dup,
                       mth=0,
                       sdt=2,
                       ovb=1,
                       ofb=1,
                       ofc=0,
                       ost=0,
                       ocr=0,
                       dv=2,
                       bnr=1,
                       c=1,
                       kb=1,
                       ksb=1,
                       khe=0,
                       kt=1,
                       kmb=1,
                       suv=1,
                       peh=0,
                       sl=1,
                       dpe=1,
                       ps=0.1,
                       ro=1,
                       ch=1)
        pmc.select(dup)
    elif triangulate:
        dup = pmc.duplicate(transf)
        pmc.polyTriangulate(dup)
        pmc.select(dup)
    else:
        pmc.select(transf)

    export_path = build_export_path(transf=transf, extension=".obj")

    try:
        exported_file = pmc.exportSelected(
            export_path,
            force=force,
            preserveReferences=True,
            type="OBJExport",
            options="groups=1;ptgroups=1;materials=1;smoothing=1;normals=1")

        # MAYA BUG WORKAROUND (.obj extension missing)
        if not exported_file[-4:] == ".obj":
            os.rename(exported_file, export_path)
            os.rename(exported_file + "mtl", exported_file + ".mtl")

        success = True
    except RuntimeError as e:
        logger.error("Could not export node {}".format(transf))
        logger.error(e)
        success = False

    # delete triangulated duplicate again (if created)
    if dup:
        pmc.delete(dup)

    pmc.select(initial_selection)

    return success
def doSelInvNRMFace( *args ):
    print "start!"
    # pm.delete( pm.ls(sl=True), ch=1 )
    selShape = pm.ls( sl=True, dag=True, type='shape' )

        
    faceInvertNRM = []
    
    offset = pm.floatFieldGrp( 'valOffset', q=True, value1=True )
    _x = pm.floatFieldGrp( 'valDir', q=True, value1=True )
    _y = pm.floatFieldGrp( 'valDir', q=True, value2=True )
    _z = pm.floatFieldGrp( 'valDir', q=True, value3=True )
    testRayDir = dt.Vector(_x, _y, _z)

    for shape in selShape:
        ## test if selected object type is "mesh"
        if( pm.nodeType(shape) != 'mesh' ):
            pm.confirmDialog( t="Error", message= shape.getParent() + " is not a mesh object! ", icon='critical' )
            return 0
            
        #pm.delete( shape, ch=1 )
        maxValue = float(len(shape.faces))
       
        pm.progressWindow( title='normal test Calculation', progress=0, maxValue=maxValue, isInterruptable=True, status='calculating: 0%' )
        for i, face in enumerate(shape.faces):
            try:
                pm.progressWindow( edit=True, progress=i, status=('calculating: ' + str( math.ceil( 100 * i/ maxValue) ) + '%') )
                
                ## ESC to cancel progress windows
                if pm.progressWindow( query=True, isCancelled=True ):
                    pm.progressWindow(endProgress=1)
                    break
                           
                curr_face = face
                obj_faces = shape.faces
                del_tmp_obj = [] 
                #// Test if face is NGon   
                if face.numTriangles() > 2:
                    tmp_obj = pm.duplicate( selShape, rr=True )[0]
                    del_face_id = [ id for id in range( len(obj_faces) ) if id != i  ]
                    pm.delete( tmp_obj.getShape().f[del_face_id] )
                    
                    #// triangulate N-Gon
                    pm.polyTriangulate( tmp_obj, ch=False )
                    
                    #//
                    curr_face = tmp_obj.getShape().f[0]
                    
                    #//
                    del_tmp_obj.append(tmp_obj)
                    
                    
                    
                pm.select( curr_face, r=1) 
                cenPos = getFaceCenter()
    
                faceNRM = curr_face.getNormal('world')
                offsetPos = cenPos + faceNRM * offset
                #testObj = pm.polySphere( r=5, sx=4, sy=4 )
                #testObj[0].setTranslation(offsetPos)
                
                ## test if point inside object
                testInside = isPointInsdeObject( shape, offsetPos, testRayDir )
                pm.delete(del_tmp_obj)
                
                if( testInside ):
                    faceInvertNRM.append( face )
            except:
                continue
   
    pm.progressWindow(endProgress=1) 
    pm.select( faceInvertNRM, r=1 )    
        
    return 1