import bpy
import os
import time

#bpy.data.meshes.remove(my_mesh)
#bpy.ops.object.convert(target='MESH',keep_original=True)

active_object=None
selected_objects=[]
active_object_mode=''
temp_object=None
all_scene=True

#texture swap count
texture_swap_count=0
current_texture_list=[]
exported_mesh_list=[]

def object_deselect_all():
    bpy.ops.object.select_all(action='DESELECT')
    
def object_select(obj):
    object_deselect_all()
    bpy.ops.object.select_pattern(pattern=obj.name)

def object_select_list(lobj):
    object_deselect_all()
    for o in lobj:
        bpy.ops.object.select_pattern(pattern=o.name,extend=True)
        
def object_active(obj):
    bpy.context.scene.objects.active=obj    

def object_select_and_active(obj):
    object_deselect_all()
    object_select(obj)
    object_active(obj)

    
def save_state(context):
    global active_object,selected_objects,active_object_mode
    
    print ("Saving State")
    
    active_object=context.active_object
    if active_object!=None:
        active_object_mode = context.object.mode
        #Switch to object mode as default
        bpy.ops.object.mode_set(mode='OBJECT')
    
    selected_objects = context.selected_objects
    

def restore_state(context):
    global selected_objects,active_object,active_object_mode
    
    print ("Restoring State.")

    #Switch to object mode
    ob=context.object
    if ob!=None:
        if ob.mode=='EDIT':
            bpy.ops.object.mode_set(mode='OBJECT')
            
    if active_object!=None:
        object_active(active_object)

    object_select_list(selected_objects)
    
    if active_object_mode=='EDIT':
        bpy.ops.object.mode_set(mode='EDIT')        

def convert_to_mesh(obj):
    global temp_object
    
    print ("Creating temporary working Mesh for {}.".format(obj))
    
    object_select_and_active(obj)
    
    if obj.type=='MESH':
        bpy.ops.object.duplicate()
    else:
        bpy.ops.object.convert(target='MESH',keep_original=True) 
    
    if (len(bpy.context.selected_objects)!=1):
        raise ("Should never happen ")
        
    temp_object=bpy.context.selected_objects[0]
    object_active(temp_object)
      
    for modifier in temp_object.modifiers:
        print ("Applying modifier %s"%modifier.name)
        try:
            bpy.ops.object.modifier_apply(modifier=modifier.name)
        except:
            print ("Error applying modifier")
            pass
    
#    m=obj.to_mesh(bpy.context.scene,True,"RENDER")
#    bpy.ops.object.add(type='MESH')
#    temp_object=bpy.context.active_object
#    temp_object.data=m

    temp_object.name = "Mesh_"+obj.name
            
    return temp_object

def convert_quad_to_tri(obj):
    print ("Triangulate Faces with pattern")
    object_select_and_active(obj)
    bpy.ops.object.mode_set(mode='EDIT')
    bpy.ops.mesh.reveal() 
    bpy.ops.mesh.select_all(action='SELECT')
    bpy.ops.mesh.quads_convert_to_tris()
    bpy.ops.object.mode_set(mode='OBJECT')

def export_vertice(vert,face,me,obj,f):
    global all_scene
    
    if all_scene:
        rot = obj.matrix_world
        pos = obj.location
        vloc,qrot,vscale = rot.decompose()
    
    v=me.vertices[vert].co.copy()
    
    if face.use_smooth:
        n=me.vertices[vert].normal.copy()
    else:
        n=face.normal.copy()
    
    if all_scene:
        v = (rot * v)
        n = qrot * n

    f.write("%+0f %+0f %+0f"%(v[0],v[1],v[2]))
    f.write("  %+0f %+0f %+0f"%(n[0],n[1],n[2]))

def build_vertex_color_list(i_vert,i_face,me):
       
    tex_list=[]
    for vcol in me.tessface_vertex_colors:
        if i_vert==0:
            col = vcol.data[i_face].color1
        if i_vert==1:
            col = vcol.data[i_face].color2
        if i_vert==2:
            col = vcol.data[i_face].color3
        r=col[0]
        g=col[1]
        b=col[2]
        texture=("rgb(%3.2f,%3.2f,%3.2f)"%(r,g,b))
        tex_list.append({'u':0.0,'v':0.0,'tex':texture})

    return tex_list

def build_uv_texture_list(i_vert,i_face,me,obj):
    global texture_swap_count,current_texture_list
    
    tex_list=[]
    tex_name_list=[]
    for uvt in me.tessface_uv_textures:
        if uvt.data[i_face].image!=None:
            if i_vert==0:
                uv=uvt.data[i_face].uv1
            if i_vert==1:
                uv=uvt.data[i_face].uv2
            if i_vert==2:
                uv=uvt.data[i_face].uv3
            texture=os.path.basename(uvt.data[i_face].image.filepath)
            
            name=uvt.data[i_face].image.name
            if (tex_name_list.count(name)==0):
                tex_name_list.append(name)
                
            if not(os.path.isfile(texture)) or uvt.data[i_face].image.file_format!='TARGA':
                print ("New Image Texture",texture)
                image=uvt.data[i_face].image
                image.file_format='TARGA'
                if image.filepath:
                    image.filepath_raw=os.path.basename(image.filepath).rsplit('.',1)[0]+'.tga'
                else:
                    image.filepath=image.name+".tga"
                try:
                    print ("Sauvegarde image ",image.filepath)
                    image.save()
                except:
                    pass
                texture=os.path.basename(uvt.data[i_face].image.filepath)
            map=uvt.data[i_face].image.mapping;
                
            tex_list.append({'u':uv[0],'v':uv[1],'tex':texture,'map':map});

    for i in range(len(tex_name_list)):
        try:
            if (tex_name_list[i]!=current_texture_list[i]):
                current_texture_list[i]=tex_name_list[i]
                texture_swap_count+=1
        except:
            current_texture_list.append(tex_name_list[i])
            texture_swap_count+=1
    
    return tex_list

def selected(faces):

    bpy.ops.object.mode_set(mode='OBJECT')
    n=0
    for face in faces:
        if face.select:
            n=n+1 
    bpy.ops.object.mode_set(mode='EDIT')    
    return n

def unselect_unhide():
    bpy.ops.object.mode_set(mode='EDIT')
    bpy.ops.mesh.select_all(action='DESELECT')
    bpy.ops.mesh.reveal()
    bpy.ops.object.mode_set(mode='OBJECT')
    return

def select_same_image():
    bpy.ops.object.mode_set(mode='EDIT')            
    bpy.ops.mesh.select_similar(type='IMAGE')   
    bpy.ops.object.mode_set(mode='OBJECT')
    return   

def hide_unselected():
    bpy.ops.object.mode_set(mode='EDIT')                
    bpy.ops.mesh.hide(unselected=True)
    bpy.ops.object.mode_set(mode='OBJECT')

def export_mesh(obj,f):
    
    #me=obj.data

    me=obj.to_mesh(scene=bpy.context.scene,apply_modifiers=True,settings='RENDER')
    
    me.update(calc_tessface=True)
    
    nf=len(me.tessfaces)
    lper=-11
    print ("Exporting mesh %s, %d faces, %d vertices"%(obj.data.name,len(me.tessfaces),len(me.vertices)))

    cpt=0 
#   for i_tface,tface in enumerate(me.faces):
    #depth, texture name, texture mode, indice
    faces_array=[[0,'',i] for i in range(nf)]
        

    print ("Working on %d faces" % len(me.tessfaces))
    
    print ("Building faces texture list")
    for i,face in enumerate(me.tessfaces):
        for uvt in me.tessface_uv_textures:
            if uvt.data[i].image!=None:
                faces_array[face.index][1]+='|'+uvt.data[i].image.name
                faces_array[face.index][0]=uvt.data[i].image.depth # used to set rbga texture at the end of file
                
    for i,face in enumerate(me.tessfaces):
        for vc in me.tessface_vertex_colors:
            if vc.data[i].color1!=None:
                texture=build_vertex_color_list(0,i,me)
                for t in texture:
                    faces_array[face.index][1]+='|'+t['tex']
            
    print ("Sorting texture list")
    faces_array.sort()
    

    print ("Exporting sorted list")
    #for i_face,face in enumerate(me.faces):
    for fa in faces_array:
        
        face = me.tessfaces[fa[2]]
        i_face = face.index
        
        per=((cpt+1)*100)/nf
        if per>lper+10:
            print("%d%% (%d)"%(per,cpt))
            lper=per
        #print (i_face)
        verts = face.vertices
      
        for i_vert,vert in enumerate(verts):
            export_vertice(vert,face,me,obj,f)

            tex_list=build_uv_texture_list(i_vert,i_face,me,obj)
            if (len(tex_list)==0):
                tex_list+=build_vertex_color_list(i_vert,i_face,me)
            
           
            if len(tex_list)==0:
                tex_list.append({'u':0.0,'v':0.0,'tex':'rgb(0.6,0.6,0.6)'})
                
            tex=tex_list[0]
            f.write("  %f %f %s"%(tex['u'],tex['v'],tex['tex']))
            ref_tex=tex_list[0] # used to find special multi texture without uv coordinates
            tex_list.remove(tex)
            for tex in tex_list:
                #ugly way to specify a texture without inherited uv mapping
                if (tex['map']=='UV'):
                    if (abs(tex['u']-50.0*ref_tex['u'])<1e-5) and (abs(tex['v']-50.0*ref_tex['v'])<1e-5):
                        f.write(";%s"%(tex['tex']))
                    else:
                        f.write(";%f|%f|%s"%(tex['u'],tex['v'],tex['tex']))
                else:
                    f.write("#%s"%(tex['tex']))

            f.write("\n")
        cpt+=1
        
                        
    print ("%d%% (%d)"%(per,nf))
    #bpy.data.meshes.remove(me) 

def write_some_data(context, filepath, save_elements,save_position):
    global all_scene,texture_swap_count
    global exported_mesh_list

    exported_mesh_list=[]
    
    pos_file_name = os.path.basename(filepath) + ".pos"

    print ("Using file name: %s Working directory: %s"%(os.path.basename(filepath),os.path.dirname(filepath)))
    
    print ("Changing working directory to %s"%os.path.dirname(filepath))
    os.chdir(os.path.dirname(filepath))
   
    if save_elements:
        print ("Saving Each element in its own file according to mesh name.")
        all_scene=False
    else:
        all_scene=True
    
    if save_position:
        print ("Saving elements positions in %s file."%pos_file_name)
        f_pos=open(pos_file_name,'w')
    
    save_state(context)
    
    if len(context.selected_objects)==0:
        bpy.ops.object.select_all(action='SELECT')
        print ("No object selected, selecting all objects.")    

    selected_objects = context.selected_objects
    
    texture_swap_count=0
    print ("%d objects to export."%(len(selected_objects)))
    
    big_wobj=None
                           
    for i_obj,obj in enumerate(selected_objects):
        
        try:
            mesh_name=obj.data.name
        except:
            mesh_name=""
              
        if save_position:
            n1=obj.name.replace(" ","_")
            n2=mesh_name.replace(" ","_")
            f_pos.write("%32.32s %32.32s %f %f %f %f %f %f\n"%(n1,n2,obj.location[0],obj.location[1],obj.location[2],obj.rotation_euler[0],obj.rotation_euler[1],obj.rotation_euler[2]))
 
        if obj.type=='LAMP' or obj.type=='CAMERA' or obj.type=='CURVE':
            print ("Skipping Export of object {}.".format(obj))
            continue

        #mesh_name=obj.data.name
        #print (len(mesh_name),mesh_name)
        
        if len(mesh_name)==0:
            print ("Not exporting empty mesh")
            continue
        
        if mesh_name[0]=='.':
            print ("Not exporting %s hidden mesh (begin with a . "%mesh_name)
            continue
        
        if not (mesh_name in exported_mesh_list):
            exported_mesh_list.append(mesh_name)
        else:
            print ("Skipping %s already exported"%mesh_name)
            continue
        
        #deselect_all()
        #bpy.ops.object.select_name(name=obj.name)
        #bpy.ops.object.select_pattern(pattern=obj.name)
        object_select(obj)
        
        print ("Exporting {} / {} Type:{}".format(obj,obj.name,obj.type))
           
        wobj = convert_to_mesh(obj)
        convert_quad_to_tri(wobj)
        
        if all_scene:
            if big_wobj==None:
                print("Creating One big object/mesh for all scene.\n")
                big_wobj=wobj
                big_wobj.name="Export_Object"
                big_wobj.data.name="Export_Mesh"
            else:
                print ("Joining %s and %s\n"%(big_wobj.name,wobj.name))
                object_select_and_active(big_wobj)
                bpy.ops.object.select_pattern(pattern=wobj.name,extend=True)
                bpy.ops.object.join()
                
        if not all_scene:
            file_name=mesh_name
            file_name+='.tri'
            print ("Opening %s for writing."%file_name)
            f =open(file_name,'w')
            print ("Version 1 tri file")
            f.write("1\n")
            export_mesh(wobj,f)
            print("Closing %s file."%file_name)
            f.close()            
            
            print ("Removing temporary object.")
            object_select_and_active(wobj)
            bpy.ops.object.delete()

    if all_scene:
        print ("Saving all scene in one file.")
        print ("Opening %s for writing."%os.path.basename(filepath))
        f =open(os.path.basename(filepath),'w')
        print ("Version 1 tri file")
        f.write("1\n")
        export_mesh(big_wobj,f);
        print ("Closing tri file.")
        f.close()
        print ("Removing temporary big object.")
        object_select_and_active(big_wobj)
        bpy.ops.object.delete()
        
    if save_position:
        print ("Closing position file.")
        f_pos.close()
        
    restore_state(context)
    print ("Texture swap count:%d."%texture_swap_count)
    return {'FINISHED'}


def read_some_data(context,filepath,clean_mesh):
    
    print ("Using file name: %s Working directory: %s"%(os.path.basename(filepath),os.path.dirname(filepath)))
    
    print ("Changing working directory to %s"%os.path.dirname(filepath))
    os.chdir(os.path.dirname(filepath))
    print ("importing %s."%filepath)
    
    finf=os.stat(filepath)
    fsiz=finf.st_size
    file=open(filepath,'r')
    name=os.path.basename(filepath).split('.')[0]
    ver = file.readline()
    print (ver)
    ver=int(ver)
    if ver != 1 and ver!= 0 :
        print ("Not a version 1 tri file. Not supported.")
        return {'CANCELLED'}
 
    print ('Creating Object')
    bpy.ops.object.add(type='MESH')
    #print ('Creating Mesh %s'%name)
    #bpy.data.meshes.new(name)
    #me=bpy.data.meshes[name]
    #bpy.context.object.data=me
    me=bpy.context.object.data
    print ("Reading datas.")

    nv=0
    ne=0
    nf=0

    v=me.vertices
    e=me.edges
    f=me.tessfaces
    
    n=0
    while 1:
        vert=file.readline() 
        n=n+1
        if not vert:
            break
        
    file.seek(0)    #rewind file
    file.readline() #skip first line (version)
    
    #allocate vertices,edges face, very very faster this way 
    v.add(n)
    f.add(n/3)
    e.add(n)
    
    ltt=[] #last texture table, used to count texture changes
    texture_change_count=0 
    
    image_not_found=[]

    lper=-11    
    while 1:
        vert=file.readline() 
        
        if not vert:
            break


        per=(nv+2)*100/n;
        if per>lper+10:
            print ("%d%% (%d)"%(per,nf))
            lper=per
        
        vs=vert.split()
        ivs=0

        v[nv].co=[float(vs[0]),float(vs[1]),float(vs[2])]
        ivs=3

        if ver==1:
            v[nv].normal=[float(vs[3]),float(vs[4]),float(vs[5])]
            ivs=6

        #now compute texture information
        tu=[]
        tv=[]
        tt=[]
        tu.append(float(vs[ivs])) #remember it will be tu[0] 
        tv.append(float(vs[ivs+1]))
        
        t=vs[ivs+2] #full texture name
        
        t=t.split(';') #split textures name, first name only, others u|v|name
        temp=[];
        for it in t:
            ts=it.split('#');
            if len(ts)==1:
                temp.append([ts[0],0]);
            else:
                temp.append([ts[0],0]);
                temp.append([ts[1],1]); # if we can split, the second is environnement texture.
                
        t=temp;
        
        tt.append(t[0]) #add first texture name to texture list
        t.remove(t[0])
        
        for itt  in t:
            it=itt[0]; # get texture string
            map=itt[1]; 
            #print (it)
            iit=it.split('|')
            #u and v coordinate and texture name
            if len(iit)==3:
                tu.append(float(iit[0]))
                tv.append(float(iit[1]))
                tt.append([iit[2],map])
                
            #only texture name using raydium hard coded scale factor of 50 from first texture coordinate
            if len(iit)==1:
                tu.append(tu[0]*50) #first texture it's ALWAYS in 0
                tv.append(tv[0]*50)
                tt.append([iit[0],map])
        
        ntt=0 # number of texture layers
        ntc=0 # number of vertex color layers
        
        for i,ti in enumerate(tt): #for each texture
            t=ti[0];
            map=ti[1];
            if t.find('rgb')==0:
                ntc=ntc+1
                if ntc > len(me.tessface_vertex_colors):
                    print ("Adding RGB texture layer")
                    me.tessface_vertex_colors.new()
                l=t.split('(')
                l=l[1]
                l=l.split(',')
                l[2]=l[2].split(')')[0]
                if (nv%3)==0:
                    me.tessface_vertex_colors[ntc-1].data[nf].color1=[float(l[0]),float(l[1]),float(l[2])]
                if (nv%3)==1:
                    me.tessface_vertex_colors[ntc-1].data[nf].color2=[float(l[0]),float(l[1]),float(l[2])]
                if (nv%3)==2:
                    me.tessface_vertex_colors[ntc-1].data[nf].color3=[float(l[0]),float(l[1]),float(l[2])]
            else:
                ntt=ntt+1
                #print (t)
                if ntt > len (me.uv_textures):
                    print ("Adding uv texture layer")
                    me.uv_textures.new()
                
                im=bpy.data.images.get(t)

                if (image_not_found.count(t)==0):
                    if not(isinstance(im,bpy.types.Image)):
                        print ("Loading image %s."%t)
                        try:
                            print ("trying")
                            bpy.data.images.load(t)
                            print ("end trying")
                        except:
                            print ("except")
                            image_not_found.append(t)
                            print ("Not found image:%s."%t)
                            pass
                    
                im=bpy.data.images.get(t)
                if (im==None):
                    continue
                me.tessface_uv_textures[ntt-1].data[nf].image=im
                if map==0:
                    me.tessface_uv_textures[ntt-1].data[nf].image.mapping='UV';
                else:
                    me.tessface_uv_textures[ntt-1].data[nf].image.mapping='REFLECTION';
                #me.uv_textures[ntt-1].data[nf].use_image=True
                if(nv%3)==0:
                    me.tessface_uv_textures[ntt-1].data[nf].uv1=[tu[i],tv[i]]
                if(nv%3)==1:
                    me.tessface_uv_textures[ntt-1].data[nf].uv2=[tu[i],tv[i]]
                if(nv%3)==2:
                    me.tessface_uv_textures[ntt-1].data[nf].uv3=[tu[i],tv[i]]
        
        for i,t in enumerate(tt): #Count texture changes
            try:
                lt=ltt[i]
            except:
                ltt.append(t)
                texture_change_count+=1
                
            if (t!=ltt[i]):
                texture_change_count+=1
                ltt[i]=t
                           

        nv=nv+1

        if (nv%3)==0:
            e[ne].vertices=[(nv-3),(nv-2)]
            e[ne+1].vertices=[(nv-2),(nv-1)]
            e[ne+2].vertices=[(nv-1),(nv-3)]
            ne=ne+3
            
            f[nf].vertices=[(nv-3),(nv-2),(nv-1)]
            
            if v[nv-3].normal==v[nv-2].normal and v[nv-2].normal==v[nv-1].normal:
                f[nf].use_smooth=False
            else:
                f[nf].use_smooth=True
                
            nf=nf+1
    me.update(calc_edges=True,calc_tessface=True)
    print ("%d%% (%d)"%(per,nf))
    print (".tri file need %d textures swap"% texture_change_count)
    
    for t in image_not_found:
        print ("Error image %s not found."%t)
        
    print ("Mesh Imported Vertices:%d Edges:%d Faces:%d."%(len(v),len(e),len(f)))
    #me.from_pydata(v,e,f)
    bpy.ops.object.mode_set(mode='EDIT')
    print("close file.")
    file.close()  
    if clean_mesh:  
        print("Clean Up Mesh")
        bpy.ops.mesh.remove_doubles(mergedist=0.0001)
        bpy.ops.mesh.tris_convert_to_quads()
        
    bpy.ops.object.mode_set(mode='OBJECT')
    return {'FINISHED'} 

# ExportHelper is a helper class, defines filename and
# invoke() function which calls the file selector.
from bpy_extras.io_utils import ExportHelper,ImportHelper
from bpy.props import StringProperty, BoolProperty, EnumProperty


class ExportSomeData(bpy.types.Operator, ExportHelper):
    '''Export Raydium .tri file.'''
    bl_idname = "export.raydium_tri"  # this is important since its how bpy.ops.export.some_data is constructed
    bl_label = "Export Raydium Tri File"

    # ExportHelper mixin class uses this
    filename_ext = ".tri"

    filter_glob = StringProperty(default="*.tri", options={'HIDDEN'})

    # List of operator properties, the attributes will be assigned
    # to the class instance from the operator settings before calling.
    save_elements = BoolProperty(name="Save Each Element", description="Save each object as one file, using mesh name", default=False)
    save_position = BoolProperty(name="Save Each Element Pos/Rot",description="Save Position and rotation of each element",default=False)

#   type = EnumProperty(items=(('OPT_A', "First Option", "Description one"),
#                            ('OPT_B', "Second Option", "Description two."),
#                            ),
#                     name="Example Enum",
#                     description="Choose between two items",
#                     default='OPT_A')
#
    @classmethod
    def poll(cls, context):
        #return context.active_object != None
        return len(context.selectable_objects)>0

    def execute(self, context):
        now=time.time()
        print ("----------------New Export------------------------")        
        ret=write_some_data(context, self.filepath, self.save_elements,self.save_position)
        print ("Elapsed: %f"%(time.time()-now))
        return ret
    
class ImportSomeData(bpy.types.Operator,ImportHelper):
    '''Import Raydium .tri file.'''
    bl_idname = "import_mesh.raydium_tri"  # this is important since its how bpy.ops.export.some_data is constructed
    bl_label = "Import Raydium Tri File"

    # ExportHelper mixin class uses this
    filename_ext = ".tri"

    filter_glob = StringProperty(default="*.tri", options={'HIDDEN'})

    # List of operator properties, the attributes will be assigned
    # to the class instance from the operator settings before calling.
    clean_mesh = BoolProperty(name="Clean Up Mesh", description="Remove doubles vertices and try to make quads faces", default=False)

#   type = EnumProperty(items=(('OPT_A', "First Option", "Description one"),
#                            ('OPT_B', "Second Option", "Description two."),
#                            ),
#                     name="Example Enum",
#                     description="Choose between two items",
#                     default='OPT_A')
#
    @classmethod
    def poll(cls, context):
        return True
        #return context.active_object != None
        #return len(context.selectable_objects)>0

    def execute(self, context):
        now=time.time()
        print ("----------------New Import------------------------")
        ret=read_some_data(context,self.filepath,self.clean_mesh) 
        print ("Elapsed: %f"%(time.time()-now))
        return ret


# Only needed if you want to add into a dynamic menu
def menu_func_export(self, context):
    self.layout.operator(ExportSomeData.bl_idname, text="Raydium (.tri)")

def menu_func_import(self, context):
    self.layout.operator(ImportSomeData.bl_idname, text="Raydium (.tri)")

def register():
    bpy.utils.register_class(ExportSomeData)
    bpy.types.INFO_MT_file_export.append(menu_func_export)
    bpy.utils.register_class(ImportSomeData)
    bpy.types.INFO_MT_file_import.append(menu_func_import)


def unregister():
    bpy.utils.unregister_class(ExportSomeData)
    bpy.types.INFO_MT_file_export.remove(menu_func_export)
    bpy.utils.unregister_class(ImportSomeData)
    bpy.types.INFO_MT_file_export.remove(menu_func_Import)


if __name__ == "__main__":
    #unregister()
    try:
        unregister()
    except:
        pass
    register()

    # test call
    for i in range(20):
        print ("\n")
    
    #bpy.ops.export.raydium_tri('INVOKE_DEFAULT')
    #bpy.ops.import_mesh.raydium_tri('INVOKE_DEFAULT')
    #write_some_data(bpy.context,"../data/capt_vtt.tri",True,False)
    write_some_data(bpy.context,"e:\\test.tri",True,False)
    
    if (0) :
        try:
            bpy.ops.object.mode_set(mode='OBJECT')
        except:
            pass
        print ('remove object')
        bpy.ops.object.select_all(action='SELECT')
        bpy.ops.object.delete()
        print ('removed')
        
        try:
            while 1:
                print ('remove mesh')
                bpy.data.meshes.remove(bpy.data.meshes[0])
                print ('removed')
        except:
            pass    
        
        #read_some_data(bpy.context,'C:\\raydium_win32_sdk_1041\\bin\\Cube.smooth.053.tri')
        now=time.time()   
        read_some_data(bpy.context,'C:\\raydium_win32_sdk_1041\\bin\\a.tri',True)
        print ("Elapsed: %f."%(time.time()-now))