Python display函数代码示例

def parse_file( fname, points, transform ):
	f = open(fname, 'r')
	screen = new_screen()
	while 1:
		l = f.readline()
		if len(l) == 0:
			break
		if l[0] == 'l':
			s = map(float, f.readline().split(' '))
			add_edge(points, s[0], s[1], s[2], s[3], s[4], s[5])
		elif l[0] == 'i':
			transform = ident(transform)
		elif l[0] == 's':
			s = map(float, f.readline().split(' '))
			transform = matrix_mult(make_scale(s[0], s[1], s[2]), transform)
		elif l[0] == 't':
			s = map(float, f.readline().split(' '))
			transform = matrix_mult(make_translate(s[0], s[1], s[2]), transform)
		elif l[0] == 'x' or l[0] == 'y' or l[0] == 'z':
			func = [make_rotX, make_rotY, make_rotZ][ord(l[0])-ord('x')]
			s = float(f.readline())
			transform = matrix_mult(func(s*math.pi / 180.0), transform)
		elif l[0] == 'a':
			points = matrix_mult(points, transpose(transform))
		elif l[0] == 'v':
		#	print points
			draw_lines(points, screen, [255, 255, 255])
			display(screen)
		elif l[0] == 'g':
			s = f.readline().strip()
			draw_lines(points, screen, [255, 255, 255])
			save_extension(screen, s)
			clear_screen(screen)

def game_loop():
	speed = [10, 0]
	invader = Invader(width-48, height-48, "graphics/character/boss/boss1/InvaderA_00.png", "graphics/character/boss/boss1/InvaderA_01.png", "graphics/character/boss/boss1/InvaderA_01.png", speed)

	# Idem, on cree notre hero en tant qu'objet MyHero
	my_hero = MyHero(width/2, height/2, "graphics/character/hero/heror.png", "graphics/character/hero/herowr.png", "graphics/character/hero/hero.png")

	# Boucle de jeu
	while 1:
		for event in pygame.event.get():
			if event.type == pygame.QUIT:
				sys.exit()

		# Deplacement
		invader.movement(width, height)
		my_hero.movement(width, height)

		# Test de collision
		# On utilise 'collidepoint', qui test si le centre de
		# My_Hero est convenu dans le rectangle de l'Invader
		if invader.get_rect().colliderect(my_hero.get_rect()):
			display_game_over(screen, background_image, background_position)
			sys.exit()
		else:
			# Affichage
			display(screen, background_image, background_position, invader, my_hero)

def parse_file( fname, points, transform, screen, color ):
    f = open( fname )
    data = f.read()
    data = data.split("\n")
    i = 0
    while i < len(data):
        if data[i] == "line":
            param = data[i+1].split(' ')
            add_edge( points, float(param[0]), float(param[1]), float(param[2]), float(param[3]), float(param[4]), float(param[5]) )
            i += 2
        elif data[i] == "circle":
            param = data[i+1].split(' ')
            add_circle( points, float(param[0]), float(param[1]), 0, float(param[2]), 1 )
            i += 2
        elif data[i] == "hermite":
            param = data[i+1].split(' ')
            add_curve( points, float(param[0]), float(param[1]), float(param[2]), float(param[3]), float(param[4]), float(param[5]), float(param[6]), float(param[7]), 0.001, "hermite" )
            i += 2
        elif data[i] == "bezier":
            param = data[i+1].split(' ')
            add_curve( points, float(param[0]), float(param[1]), float(param[2]), float(param[3]), float(param[4]), float(param[5]), float(param[6]), float(param[7]), 0.001, "bezier" )
            i += 2
        elif data[i] == "xrotate":
            param = data[i+1]
            trans = make_rotX(math.radians(float(param)))
            matrix_mult(trans, transform)
            i += 2
        elif data[i] == "yrotate":
            param = data[i+1]
            trans = make_rotY(math.radians(float(param)))
            i += 2
        elif data[i] == "zrotate":
            param = data[i+1]
            trans = make_rotZ(math.radians(float(param)))
            i += 2
        elif data[i] == "ident":
            ident( transform )
        elif data[i] == "apply":
            matrix_mult( transform, points )
        elif data[i] == "scale":
            param = data[i+1].split( " " )
            m = make_scale(float(prama[0]), float(param[1]), float(param[2]), transform )
            matrix_mult( m, transform )
        elif data[i] == "translate":
            param = data[i+1].split(' ')
            matrix_mult( make_translate(float(param[0]), float(param[1]), float(param[2]), transform ) )
        elif data[i] == "display":
            clear_screen(screen)
            draw_lines(points, screen, color)
            display( screen )
            i += 1
        elif data[i] == "save":
            fname = data[i+1]
            save_ppm( screen, fname )
            i += 2
        elif data[i] == "quit":
            return

        else:
            print ""

def run(filename):
    """
    This function runs an mdl script
    """
    color = [255, 255, 255]
    tmp = new_matrix()
    ident(tmp)
    p = mdl.parseFile(filename)
    if p:
        (commands, symbols) = p
    else:
        print "Parsing failed."
        return

    stack = [ tmp ]
    screen = new_screen()
        
    for command in commands:
        #print command
        matrix = []
        if command[0] == "push":
            stack.append(copy.deepcopy(stack[-1]))
        elif command[0] == "pop":
            stack.pop()
        elif command[0] == "line":
            add_edge(matrix, command[1],command[2],command[3],command[4], command[5],command[6])
            draw_lines( matrix, screen, color )
            matrix=[];
        elif command[0] in ["sphere","box","torus"]:
            if command[0] == "sphere":
                add_sphere(matrix,command[1],command[2],command[3],command[4],5)
            elif command[0] == "box":
                add_box(matrix, command[1],command[2],command[3],command[4], command[5],command[6])
            else:
                add_torus(matrix, command[1],command[2],command[3],command[4], command[5],5)
            matrix_mult(stack[-1],matrix)
            draw_polygons( matrix, screen, color )
            matrix=[];
        elif command[0] in ["move","scale","rotate"]:
            if command[0] == "move":
                t= make_translate(command[1],command[2],command[3])
            elif command[0] == "scale":
                t = make_scale(command[1],command[2],command[3])
            else:
                r = command[2]*(math.pi/180.0)
                if command[1] == "x":
                    t = make_rotX(r)
                elif command[1] == "y":
                    t = make_rotY(r)
                elif command[1] == "z":
                    t = make_rotZ(r)
            matrix_mult(stack[-1],t)
            stack[-1]=t
        elif command[0] == "display":
            display( screen )
        elif command[0] == "save":
            save_extension( screen, command[1] )

def parse_file( fname, points, transform ):
    f = open(fname, 'r')
    file = f.readlines()
    #print file
    f.close()

    i = 0
    while (i<len(file)):
        line = file[i].strip('\n')
        if line == 'g':
            draw_lines(points, screen, color)
            save_extension(screen, file[i+1].strip('\n'))
            i += 2
        elif line == 'a':
            matrix_mult(transform, points)
            i += 1
        elif line == 'v':
            draw_lines(points, screen, color)
            display(screen)
            i += 1
        elif line == 'l':
            pts = file[i+1].strip('\n').split(" ")
            add_edge(points,
                     float(pts[0]),
                     float(pts[1]),
                     float(pts[2]),
                     float(pts[3]),
                     float(pts[4]),
                     float(pts[5]))
            i += 2
        elif line == 's':
            ps = file[i+1].strip('\n').split(" ")
            s = make_scale(float(ps[0]), float(ps[1]), float(ps[2]))
            transform = matrix_mult(s, transform)
            i += 2
        elif line == 't':
            ps = file[i+1].strip('\n').split(" ")
            t = make_translation(float(ps[0]), float(ps[1]), float(ps[2]))
            transform = matrix_mult(t, transform)
            i+=2
        elif line == 'x':
            theta = file[i+1].strip('\n')
            x = make_rotX(theta)
            transform = matrix_mult (x, transform)
            i += 2
        elif line == 'y':
            theta = file[i+1].strip('\n')
            y = make_rotY(theta)
            transform = matrix_mult (y, transform)
            i += 2
        elif line == 'z':
            theta = file[i+1].strip('\n')
            z = make_rotZ(theta)
            transform = matrix_mult(z, transform)
            i += 2
        else:
            i += 1

def parse_file( fname, points, transform, screen, color ):
    filer = open(fname, 'r')
    data = filer.read()
    filer.close()
    lines = data.split("\n")
    counter = 0
    while counter < len(lines):
        print lines[counter]
        if lines[counter] == "line":
            counter += 1
            parameters = lines[counter].split(" ")
            add_edge(points, int(parameters[0]), int(parameters[1]), int(parameters[2]), int(parameters[3]), int(parameters[4]), int(parameters[5]))
        elif lines[counter] == "circle" or lines[counter] == "c":
            counter += 1
            parameters = lines[counter].split(" ")
            add_circle(points, int(parameters[0]), int(parameters[1]), 0, int(parameters[2]), 64)
        elif lines[counter] == "hermite" or lines[counter] == "h":
            counter += 1
            parameters = lines[counter].split(" ")
            add_curve(points, int(parameters[0]), int(parameters[1]), int(parameters[2]), int(parameters[3]), int(parameters[4]), int(parameters[5]), int(parameters[6]), int(parameters[7]), 32, 0)
        elif lines[counter] == "bezier" or lines[counter] == "b":
            counter += 1
            parameters = lines[counter].split(" ")
            add_curve(points, int(parameters[0]), int(parameters[1]), int(parameters[2]), int(parameters[3]), int(parameters[4]), int(parameters[5]), int(parameters[6]), int(parameters[7]), 32, 1)
        elif lines[counter] == "ident":
            ident(transform)
        elif lines[counter] == "scale":
            counter += 1
            parameters = lines[counter].split(" ")
            matrix_mult(make_scale(float(parameters[0]), float(parameters[1]), float(parameters[2])), transform)
        elif lines[counter] == "translate":
            counter += 1
            parameters = lines[counter].split(" ")
            matrix_mult(make_translate(int(parameters[0]), int(parameters[1]), int(parameters[2])), transform)
        elif lines[counter] == "xrotate":
            counter += 1
            matrix_mult(make_rotX(int(lines[counter])), transform)
        elif lines[counter] == "yrotate":
            counter += 1
            matrix_mult(make_rotY(int(lines[counter])), transform)
        elif lines[counter] == "zrotate":
            counter += 1
            matrix_mult(make_rotZ(int(lines[counter])), transform)
        elif lines[counter] == "apply":
            matrix_mult(transform, points)
        elif lines[counter] == "display":
            color = [0, 255, 0]
            screen = new_screen()
            draw_lines(points, screen, color)
            display(screen)
        elif lines[counter] == "save":
            counter += 1
            save_extension(screen, lines[counter])
        else:
            print "Invalid command: " + lines[counter]
        counter += 1

def parse_file( fname, points, transform ):
    f = open(fname,"r")
    lines = f.readlines()
    f.close()
    i = 0
    while i < len(lines):
        l = lines[i].replace("\n","")
        if l == "l":
            coor = lines[i+1].replace("\n","").split(" ")
            coor = [float(q) for q in coor]
            add_edge(points, coor[0], coor[1], coor[2], coor[3], coor[4], coor[5])
        elif l == "c":
            values = [float(q) for q in lines[i+1].replace("\n","").split(" ")]
            add_circle(points, values[0], values[1], 0, values[2], 0.01)
        elif l == "h":
            values = [float(q) for q in lines[i+1].replace("\n","").split(" ")]
            add_curve(points,values[0],values[1],values[2],values[3],values[4],
                      values[5],values[6],values[7],0.01,"hermite")
        elif l == "b":
            values = [float(q) for q in lines[i+1].replace("\n","").split(" ")]
            add_curve(points,values[0],values[1],values[2],values[3],values[4],
                      values[5],values[6],values[7],0.01,"bezier")
        elif l == "i":
            ident(transform)
        elif l == "s":
            values = lines[i+1].replace("\n","").split(" ")
            values = [float(q) for q in values]
            matrix_mult(make_scale(values[0], values[1], values[2]),transform)
        elif l == "t":
            values = lines[i+1].replace("\n","").split(" ")
            values = [float(q) for q in values]
            matrix_mult(make_translate(values[0], values[1], values[2]),transform)
        elif l == "x":
            theta = float(lines[i+1].replace("\n",""))
            matrix_mult(make_rotX(theta),transform)
        elif l == "y":
            theta = float(lines[i+1].replace("\n",""))
            matrix_mult(make_rotY(theta),transform)
        elif l == "z":
            theta = float(lines[i+1].replace("\n",""))
            matrix_mult(make_rotZ(theta),transform)
        elif l == "a":
            matrix_mult(transform,points)
        elif l == "v":
            screen = new_screen()
            draw_lines(points, screen, color)
            display(screen)
        elif l == "g":
            fname = lines[i+1].replace("\n","")
            screen = new_screen()
            draw_lines(points, screen, color)
            save_ppm(screen, fname)
        i += 1

def parse_file( fname, points, transform, screen, color ):
    f = open(fname, 'r').read()
    l = f.split('\n')
    i = 0
    while i < len(l):
        cmd = l[i].strip()
        print cmd
        if cmd in commands:
            i += 1
            args = l[i].split()
            j = 0
            while j < len(args):
                args[j] = float(args[j])
                j+= 1
            if cmd == 'line':
                add_edge( points, args[0], args[1], args[2], args[3], args[4], args[5] )
            elif cmd == 'circle':
                add_circle( points, args[0], args[1], 0, args[2], 0.01 )
            elif cmd == 'hermite':
                add_curve( points, args[0], args[1], args[2], args[3], args[4], args[5], args[6], args[7], 0.01, HERMITE )
            elif cmd == 'bezier':
                add_curve( points, args[0], args[1], args[2], args[3], args[4], args[5], args[6], args[7], 0.01, BEZIER )
            elif cmd == 'scale':
                matrix_mult(make_scale(args[0], args[1], args[2]), transform)
            elif cmd == 'translate':
                matrix_mult(make_translate(args[0], args[1], args[2]), transform)
            elif cmd == 'xrotate':
                matrix_mult(make_rotX(args[0]), transform)
            elif cmd == 'yrotate':
                matrix_mult(make_rotY(args[0]), transform)
            elif cmd == 'zrotate':
                matrix_mult(make_rotZ(args[0]), transform)
        else:
            if cmd == 'ident':
                ident(transform)
            elif cmd == 'apply':
                matrix_mult(transform,points)
            elif cmd == 'display':
                screen = new_screen()
                draw_lines( points, screen, color )
                display(screen)
            elif cmd == 'save':
                screen = new_screen()
                draw_lines( points, screen, color )
                i += 1
                out = l[i]
                save_extension(screen,out)
            elif cmd[0] == '#':
                pass
            else:
                print "Invalid command."
        i += 1

def run(filename):
    """
    This function runs an mdl script
    """

    p = mdl.parseFile(filename)
    
    if p:
        (commands, symbols) = p
    else:
        print "Parsing failed."
        return

    for command in commands:
        cmd = command[0]
        if cmd == "push":
            stack.append(copy.deepcopy(stack[len(stack)-1]))
        if cmd == "pop":
            stack.pop()
        if cmd == "move":
            mult(make_translate(command[1], command[2], command[3]))
        if cmd == "rotate":
            t = command[2]*math.pi/180
            axis = command[1]
            if axis == 'x':
                mult(make_rotX(t))
            if axis == 'y':
                mult(make_rotY(t))
            if axis == 'z':
                mult(make_rotZ(t))
        if cmd == "scale":
            mult(make_scale(command[1], command[2], command[3]))
        if cmd in ["box", "sphere", "torus"]:
            polygons = []
            if cmd == "box":
                add_box(polygons, command[1],command[2],command[3],command[4],command[5],command[6])
            if cmd == "sphere":
                add_sphere(polygons, command[1],command[2],command[3],command[4],5)
            if cmd == "torus":
                add_torus(polygons, command[1],command[2],command[3],command[4],command[5],5)
            matrix_mult(stack[len(stack)-1], polygons)
            draw_polygons(polygons, screen, color)
        if cmd == "line":
            points = []
            add_edge(points, command[1],command[2],command[3],command[4],command[5],command[6])
            matrix_mult(stack[len(stack)-1], points)
            draw_lines(polygons, screen, color)
        if cmd == "save":
            save_extension(screen, cmd[1])
        if cmd == "display":
            display(screen)

def parse_file( filename, points, transform ):
    screen = new_screen()
    f = open(filename, 'r')

    while 1:
        l = f.readline()
        if len(l) == 0:
            break
        elif l[0] == 'l':
            s = map(float, f.readline().split(' '))
            add_edge(points, s[0],s[1],s[2],s[3],s[4],s[5])
        elif l[0] == 'i':
            transform = ident(transform)
        elif l[0] == 's':
            s = map(float, f.readline().split(' '))
            transform = matrix_mult(scale(s[0],s[1],s[2]),transform)
        elif l[0] == 't':
            s = map(float, f.readline().split(' '))
            transform = matrix_mult(translate(s[0],s[1],s[2]),transform)
        elif l[0] == 'x':
            s = map(float, f.readline().split(' '))
            transform = matrix_mult(rotateX(s[0]),transform)
        elif l[0] == 'y':
            s = map(float, f.readline().split(' '))
            transform = matrix_mult(rotateY(s[0]),transform)
        elif l[0] == 'z':
            s = map(float, f.readline().split(' '))
            transform = matrix_mult(rotateZ(s[0]),transform)
        elif l[0] == 'a':
            points = matrix_mult(points, transform)
        elif l[0] == 'v':
            screen = new_screen()
            draw_lines(points, screen, [255,255,255])
            display(screen)
        elif l[0] == 'g':
            s = f.readline().split()
            draw_lines(points, screen, [255,255,255])
            save_extension(screen, s)
            clear_screen(screen)
        elif l[0] == 'c':
            s = map(float, f.readline().split(' '))
            addCircle(points, s[0], s[1], 0, s[2], .01)
        elif l[0] == 'b':
            s = map(float, f.readline().split(' '))
            print s
            addCurve(points, s[0], s[1], s[2], s[3], s[4], s[5], s[6], s[7],
                     .01, "bezier")
        elif l[0] == 'h':
            s = map(float, f.readline().split(' '))
            addCurve(points, s[0], s[1], s[2], s[3], s[4], s[5], s[6], s[7],
                     .01, "hermite")

def parse_file(fname, points, matrix):
    f = open(fname, "r")
    script = f.read()
    # read in each line and parse and do specific transformation
    commands = script.split("\n")
    line = 0
    length = len(commands)
    master = ident(new_matrix())
    while line < length:
        if commands[line] == "":
            line += 1
        # six arguments all in one list
        if commands[line] in "lstxyzg":
            ele = commands[line + 1].split()
            if commands[line] == "l":
                add_edge(points, ele[0], ele[1], ele[2], ele[3], ele[4], ele[5])

            # three arguments all in one list
            elif commands[line] == "s":
                master = matrix_mult(master, make_scale(float(ele[0]), float(ele[1]), float(ele[2])))
            elif commands[line] == "t":
                master = matrix_mult(master, make_translate(float(ele[0]), float(ele[1]), float(ele[2])))
            elif commands[line] == "x":
                master = matrix_mult(master, make_rotX(float(ele[0])))
            elif commands[line] == "y":
                master = matrix_mult(master, make_rotY(float(ele[0])))
            elif commands[line] == "z":
                master = matrix_mult(master, make_rotZ(float(ele[0])))
            elif commands[line] == "g":
                el = ele[0]  # ele.split(".")[0] + "."
                screen = new_screen()
                draw_lines(points, screen, randcolor())
                save_extension(screen, el)

            line += 2
        # one argument-> as in one element in the list
        else:
            if commands[line] == "i":
                master = ident(master)
            elif commands[line] == "a":
                points = matrix_mult(master, points)
                master = ident(master)
            elif commands[line] == "v":
                screen = new_screen()
                draw_lines(points, screen, randcolor())
                display(screen)

            line = line + 1

def game_loop():
    #declaration du personnage
    my_hero = MyHero(200, 200, "data/char_hero/face_hero.jpg", "data/char_hero/latD_hero.jpg", "data/char_hero/latG_hero.jpg")
# Boucle de jeu
    while 1:
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                os._exit(1)

        #######################################################################
        #instruction de jeu
        #######################################################################
        # mouvement des entitées
        my_hero.movement()
        #affichage de la fenetre
        # Affichage
        display(screen, background_image, background_position,my_hero)

def parse_file( fname, points, transform, screen, color ):
    f = open(fname,'r')
    text = f.read()
    lines = text.split('\n')
    n = 0
    while(n < len(lines)):
        if(lines[n] == "ident"):
            ident(transform)
        elif(lines[n] == "apply"):
            matrix_mult(transform,points)
        elif(lines[n] == "display"):
            clear_screen(screen)
            draw_lines(points,screen,color)
            display(screen)
        else:
            func = lines[n]
            n += 1
            argstring = lines[n].split(' ')
            args = map(float,argstring)
            argsint = map(int,args)
            if(func == "scale"):
                matrix_mult(make_scale(args[0],args[1],args[2]),transform)
            elif(func == "translate"):
                matrix_mult(make_translate(args[0],args[1],args[2]),transform)
            elif(func == "xrotate"):
                matrix_mult(make_rotX(args[0]),transform)
            elif(func == "yrotate"):
                matrix_mult(make_rotY(args[0]),transform)
            elif(func == "zrotate"):
                matrix_mult(make_rotZ(args[0]),transform)
            elif(func == "line"):
                add_edge(points,argsint[0],argsint[1],argsint[2],argsint[3],argsint[4],argsint[5])
            elif(func == "circle"):
                add_circle(points,argsint[0],argsint[1],0,argsint[2],STEP)
            elif(func == "hermite"):
                add_curve(points,argsint[0],argsint[1],argsint[2],argsint[3],
                          argsint[4],argsint[5],argsint[6],argsint[7],
                          STEP,HERMITE)
            elif(func == "bezier"):
                add_curve(points,argsint[0],argsint[1],argsint[2],argsint[3],
                          argsint[4],argsint[5],argsint[6],argsint[7],
                          STEP,BEZIER)
            elif(func == "save"):
                save_ppm(screen,argstring[0])
        n += 1
    f.close()

def parse_file( fname, points, transform, screen, color ):
    f = open(fname, 'r')
    r = f.read()
    l = r.split('\n')
    c = 0
    while(c < len(l)):
        print str(c + 1) +"\n"
        if(l[c] == "ident"):
            ident(transform)
        elif(l[c] == "apply"):
            matrix_mult(transform,points)
        elif(l[c] == "display"):
            clear_screen(screen)
            draw_lines(points,screen,color)
            display(screen)
        else:
            c += 1
            t = l[c].split(' ')
            if(l[c - 1] == "line"):
                add_edge(points,int(t[0]),int(t[1]),int(t[2]),int(t[3]),int(t[4]),int(t[5]))
            elif(l[c - 1] == "circle"):
                add_circle(points,int(t[0]),int(t[1]),0,int(t[2]),0.02)
            elif(l[c - 1] == "hermite"):
                add_curve(points,int(t[0]),int(t[1]),int(t[2]),int(t[3]),int(t[4]),int(t[5]),int(t[6]),int(t[7]),0.02,0)
            elif(l[c - 1] == "bezier"):
                add_curve(points,int(t[0]),int(t[1]),int(t[2]),int(t[3]),int(t[4]),int(t[5]),int(t[6]),int(t[7]),0.02,1)
            elif(l[c - 1] == "scale"):
                q = make_scale(float(t[0]),float(t[1]),float(t[2]))
                matrix_mult(q,transform)
            elif(l[c - 1] == "translate"):
                q = make_translate(int(t[0]),int(t[1]),int(t[2]))
                matrix_mult(q,transform)
            elif(l[c - 1] == "xrotate"):
                q = make_rotX(float(t[0]))
                matrix_mult(q,transform)
            elif(l[c - 1] == "yrotate"):
                q = make_rotY(float(t[0]))
                matrix_mult(q,transform)
            elif(l[c - 1] == "zrotate"):
                q = make_rotZ(float(t[0]))
                matrix_mult(q,transform)
            elif(l[c - 1] == "save"):
                save_ppm(screen,t[0])
        c+=1
    f.close()    

def parse_file( fname, points, transform ):
	f = open(fname, 'r')
	screen = new_screen()
	while 1:
		l = f.readline()
		if len(l) == 0:
			break
		if l[0] in 'lchbpmdstxyz':
			s = map(float, f.readline().split(' '))
		if l[0] == 'l':
			add_edge(points, *s)
		elif l[0] == 'c':
			add_circle(points, *s)
		elif l[0] == 'h':
			add_hermite(points, *s)
		elif l[0] == 'b':
			add_bezier(points, *s)
		elif l[0] == 'p':
			add_prism(points, *s)
		elif l[0] == 'm':
			add_sphere(points, *s)
		elif l[0] == 'd':
			add_torus(points, *s)
		elif l[0] == 'i':
			transform = ident(transform)
		elif l[0] == 's':
			transform = matrix_mult(make_scale(*s), transform)
		elif l[0] == 't':
			transform = matrix_mult(make_translate(*s), transform)
		elif l[0] == 'x' or l[0] == 'y' or l[0] == 'z':
			func = [make_rotX, make_rotY, make_rotZ][ord(l[0])-ord('x')]
			transform = matrix_mult(func(s[0]*math.pi / 180.0), transform)
		elif l[0] == 'a':
			points = matrix_mult(points, transpose(transform))
		elif l[0] == 'w':
			points = []
		elif l[0] == 'v':
			draw_lines(points, screen, [255, 255, 255])
			display(screen)
		elif l[0] == 'g':
			s = f.readline().strip()
			draw_lines(points, screen, [255, 255, 255])
			save_extension(screen, s)
			clear_screen(screen)