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 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 parse_file( fname, points, transform ): transform = ident(new_matrix()) screen = new_screen() f=open(fname) lines = f.read().split('\n') n = 0 #******* IMPORTANT NOTE ***********# # I have note gotten image magic to work (there is a piazza question evidencing this) # As a result, I have created an alternative where i just create a new image, from 0 to n, each time a or v is entered. I will try and fix my problems (with image magic, not the ones stemming from divorce and an uninterested mother) for i in range(0,len(lines)): line= lines[i] line.strip() i = i + 1 #print_matrix(transform) if line == "l": p = lines[i].split(' ') for x in range(0,len(p)): p[x]=int(p[x]) add_edge(points,p[0],p[1],p[2],p[3],p[4],p[5]) elif line == "s": args = lines[i].split(' ') r = make_scale(float(args[0]),float(args[1]),float(args[2])) transform = matrix_mult(r,transform) elif line == "t": args = lines[i].split(' ') r = make_translate(float(args[0]),float(args[1]),float(args[2])) transform = matrix_mult(r,transform) elif line == "x": arg = lines[i] r = make_rotX(int(arg)) transform = matrix_mult(r,transform) elif line == "y": arg = lines[i] r = make_rotY(int(arg)) transform = matrix_mult(r,transform) elif line == "z": arg = lines[i] r = make_rotZ(int(arg)) transform = matrix_mult(r,transform) elif line == "g": #save_extension(screen,lines[i]) display(screen, str(n)) n = n+1 else: i = i - 1 if line == "i": transform = ident(transform) elif line == "a": points = matrix_mult(transform,points) elif line == "v": clear_screen(screen) draw_lines( points, screen, [255,0,0] ) display(screen, str(n)) n = n+1
def parse_file( fname, points, transform ): data = open(fname, 'r') data = data.read() data = data.splitlines() screen = new_screen() color = [0, 0, 255] for x in data: if (data[x] == 'l'): p = data[i+1].split() add_edge(points, float(p[0]), float(p[1]), float(p[2]), float(p[3]), float(p[4]), float(p[5])) elif (data[x] == 'i'): transform = ident() elif (data[x] == 's'): p = data[x+1].split() transform = matrix_mult(make_scale(float(p[0]), float(p[1]), float(p2[0])), transform) elif (data[x] == 't'): p = data[x+1].split() transform = matrix_mult(make_translate(float(p[0]), float(p[1]), float(p[2])), transform) elif (data[x] == 'x'): transform = matrix_mult(make_rotX(float(data[x+1])), transform) elif (data[x] == 'y'): transform = matrix_mult(make_rotY(float(data[x+1])), transform) elif (data[x] == 'z'): transform = matrix_mult(make_rotZ(float(data[x+1])), transform) elif (data[x] == 'a'): points = matrix_mult(transform, points) elif (data[x] == 'v'): draw_lines(points, screen, color) display(screen) clear_screen(screen) elif (data[x] == 'g'): draw_lines(points, screen, color) display(screen) else:
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 run(filename): 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: points = [] print command cmd = command[0] args = command[1:] top = stack[-1] if cmd == "push": stack.append(copy.deepcopy(top)) elif cmd == "pop": stack.pop() elif cmd in ["move","rotate","scale"]: if cmd == "move": x = make_translate(args[0], args[1], args[2]) elif cmd == "rotate": x = get_rot(args[0],args[1]*(math.pi/180)) elif cmd == "scale": x = make_scale(args[0], args[1], args[2]) matrix_mult(top, x) stack[-1] = x elif cmd in ["box","sphere","torus"]: if cmd == "box": add_box(points, args[0], args[1], args[2], args[3], args[4], args[5]) elif cmd == "sphere": add_sphere(points, args[0], args[1], args[2], args[3], 5) elif cmd == "torus": add_torus(points, args[0], args[1], args[2], args[3], args[4], 5) matrix_mult(top, points) draw_polygons(points, screen, color) elif cmd == "line": add_edge(points, args[0], args[1], args[2], args[3], args[4], args[5]) matrix_mult(top, points) draw_lines(points, screen, color) elif cmd == "save": save_extension(screen, args[0]) elif cmd == "display": display(screen)
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 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 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 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 points = [] cmd = command[0] arg = command[1:] if cmd == "push": stack.append(copy.deepcopy(stack[-1])) elif cmd == "pop": stack.pop() elif cmd in ["move", "rotate", "scale"]: if cmd == "move": matrix = make_translate(arg[0], arg[1], arg[2]) elif cmd == "rotate": matrix = make_rot(arg[0], arg[1]*(math.pi/180)) else: matrix = make_scale(arg[0], arg[1], arg[2]) matrix_mult(stack[-1], matrix) stack[-1] = matrix elif cmd in ["box", "sphere", "torus"]: if cmd == "box": add_box(points, arg[0], arg[1], arg[2], arg[3], arg[4], arg[5]) elif cmd == "sphere": add_sphere(points, arg[0], arg[1], arg[2], arg[3], 5) else: add_torus(points, arg[0], arg[1], arg[2], arg[3], arg[4], 5) matrix_mult(stack[-1], points) draw_polygons(points, screen, color) elif cmd == "save": save_extension(screen, arg[0]) elif cmd == "display": display(screen)
def parse_file( fname, points, transform ): screen = new_screen() color = [ 0, 255, 0 ] f = open(fname, "r") line = f.readline().strip() while line: if line == "l": p = [] for x in f.readline().strip().split(' '): p.append(int(x)) add_edge(points, p[0], p[1], p[2], p[3], p[4], p[5]) elif line == "i": for x in range(4): for y in range(4): transform[x][y] = 0 transform[x][x] = 1 elif line == "s": p = [] for x in f.readline().strip().split(): p.append(float(x)) for n in range(3): transform[n][n] *= p[n] elif line == "t": p = [] for x in f.readline().strip().split(): p.append(int(x)) for n in range(3): transform[3][n] += p[n] elif line == "x": transform = rotate("x", f.readline().strip(), points, transform) elif line == "y": transform = rotate("y", f.readline().strip(), points, transform) elif line == "z": transform = rotate("z", f.readline().strip(), points, transform) elif line == "a": #print "transform: " #print_matrix(transform) points = mult(points, transform, True) elif line == "v": clear_screen(screen) draw_lines( points, screen, color ) display(screen) elif line == "g": save_ppm(screen, f.readline().strip().strip()) display(screen) line = f.readline().strip() #print_matrix( points) f.close()
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 parse_file( fname, points, transform ): screen = new_screen() color = [255, 255, 255] f = open(fname) commands = [c.strip('\n') for c in f.readlines()] for i in range(len(commands)): c = commands[i] if c[0] in ('l','s','t','x','y','z'): args = commands[i+1].split() for i in range(len(args)): if '.' in args[i]: args[i] = float(args[i]) else: args[i] = int(args[i]) if c[0] == 'l': add_edge(points,*args) else: if c[0] == 's': m = make_scale(*args) elif c[0] == 't': m = make_translate(*args) elif c[0] == 'x': m = make_rotX(*args) elif c[0] == 'y': m = make_rotY(*args) elif c[0] == 'z': m = make_rotZ(*args) transform = matrix_mult(m,transform) elif c[0] == 'g': fname = commands[i+1] draw_lines(points, screen, color) save_extension(screen, fname) elif c[0] == 'i': transform = ident(transform) elif c[0] == 'a': points = matrix_mult(transform, points) elif c[0] == 'v': screen = new_screen() draw_lines(points, screen, color) display(screen)
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)
def parse_file( fname, points, transform ): screen = new_screen() with open(fname) as script: for line in script: line = line[:-1] if not line.replace(" ","").isdigit(): comm = line.strip() if comm == 'i': transform = ident(points) elif comm == 'a': points = matrix_mult(transform, points) transform = ident(transform) elif comm == 'v': clear_screen(screen) draw_lines(points, screen, [0,225,0]) display(screen) sleep(0.5) elif comm == 'q': return else: args = [float(x) for x in line.split()] if comm == 'l': # params = [points].extend([x for x in args]) add_edge(points, *[x for x in args]) elif comm == 'i': transform = ident(points) elif comm == 's': transform = trans(make_scale, transform) elif comm == 't': transform = trans(make_translate, transform) elif comm == 'x': args = [deg2rad(x) for x in args] transform = trans(make_rotX, transform) elif comm == 'y': args = [deg2rad(x) for x in args] transform = trans(make_rotY, transform) elif comm == 'z': args = [deg2rad(x) for x in args] transform = trans(make_rotZ, transform) elif comm == 'g': draw_lines(points, screen, [0,225,0] ) save_ppm(screen, args[0])
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 ] #initializes origin stack with identity matrix pushed on screen = new_screen() for command in commands: if command[0] == 'push': push(stack) elif command[0] == 'pop': pop(stack) elif command[0] == 'move': stack[-1] = move(stack[-1], command[1], command[2], command[3]) elif command[0] == 'rotate': stack[-1] = rotate(stack[-1], command[1], command[2]) elif command[0] == 'scale': stack[-1] = scale(stack[-1], command[1], command[2], command[3]) elif command[0] == 'box': box(stack[-1], command[1], command[2], command[3], command[4], command[5], command[6], screen, color) elif command[0] == 'torus': torus(stack[-1], command[1], command[2], command[3], command[4], screen, color) elif command[0] == 'sphere': sphere(stack[-1], command[1], command[2], command[3], command[4], screen, color) elif command[0] == 'line': line(stack[-1], command[1], command[2], command[3], command[4], command[5], command[6], screen, color) elif command[0] == 'save': save_extension(screen, command[1]) elif command[0] == 'display': display(screen) else: pass
def main(): global GameGlobals currentArea = testArea() initDisplay() message("Welcome to RowanRPG!",libtcod.red) while not libtcod.console_is_window_closed(): GameGlobals.ticks += 1 key = libtcod.console_check_for_keypress(True) if(key.vk != libtcod.KEY_NONE): shouldQuit,currentArea = handle_keys(key,currentArea) if shouldQuit: break for e in currentArea.entities: currentArea.map[e.y][e.x] = currentArea.map[e.y][e.x]._replace(changed = True) currentArea = currentArea._replace(entities=map(lambda e: moveEntity(e,currentArea),currentArea.entities)) #render the screen display(currentArea)
def parse_file( fname, points, transform ): f = open(fname, 'r') cmd = f.readline().rstrip() while(cmd): if cmd in cmds_args: args = f.readline().rstrip() if cmd == 'g': #print args draw_lines(points, screen, [0,255,0]) #save_extension(screen,args) save_ppm(screen,args) else: #print args args = map(float,args.split(" ")) #print args i = ident(new_matrix()) #in case bad things happen if cmd == 'l': add_edge(points, args[0],args[1],args[2],args[3],args[4],args[5]) elif cmd == 's': i = make_scale(args[0],args[1],args[2]) elif cmd == 't': i = make_translate(args[0],args[1],args[2]) elif cmd == 'x': i = make_rotX(args[0]) elif cmd == 'y': i = make_rotY(args[0]) elif cmd == 'z': i = make_rotZ(args[0]) transform = matrix_mult(i, transform) elif cmd in cmds_noargs: if cmd == 'i': transform = ident(transform) elif cmd == 'a': points = matrix_mult(transform,points) elif cmd == 'v': draw_lines(points,screen,[0,255,0]) display(screen) cmd = f.readline().rstrip() f.close()
def play_game(self, Q_VALUES_1, Q_VALUES_2): tk = Tk() canvas = Canvas(tk, width=window_size + 200, height=window_size) canvas.grid(row=0, column=0) player1_turn = True q_val = 0 exists_winner = True def update(): display(canvas, self.state, q_val) tk.update() sleep(sleep_time) print("---\nGame Start") while not self.state.is_game_over(): previous_state = self.state if player1_turn: (self.state, self.move_info), q_val = player1.move( True, self.state, Q_VALUES_1) player1_turn = False else: (self.state, self.move_info), q_val = player2.move( False, self.state, Q_VALUES_2) player1_turn = True if ENABLE_GUI: update() if (clock() - self.start_time) > (sleep_time * 160): exists_winner = False break display(canvas, self.state, q_val) winner = "no winner" if exists_winner: winner = self.state.get_winner() canvas.create_text(window_size + 100, 20, text="Winner: " + winner) print("Winner: " + winner)
def parse_file( fname, points, transform ): f = open(fname, 'r') lines = f.readlines() f.close for i in range(len(lines)): line = lines[i].replace("\n","") if i+1 in range(len(lines)): n = lines[i+1].replace("\n","").split(" ") if line == 'l': for j in range(len(n)): n[j] = float(n[j]) print n[j] add_edge(points,n[0],n[1],n[2],n[3],n[4],n[5]) elif line == 'i': ident(transform) elif line == 's': for j in range(len(n)): n[j] = float(n[j]) matrix_mult(make_scale(n[0],n[1],n[2]),transform) elif line == 't': for j in range(len(n)): n[j] = float(n[j]) matrix_mult(make_translate(n[0],n[1],n[2]),transform) elif line == 'x': matrix_mult(make_rotX(n[0]),transform) elif line == 'y': matrix_mult(make_rotY(n[0]),transform) elif line == 'z': matrix_mult(make_rotZ(n[0]),transform) elif line == 'a': matrix_mult(transform,points) elif line == 'v': screen = new_screen() draw_lines(points,screen,color) display(screen) elif line == 'g': screen = new_screen() draw_lines(points,screen,color) save_ppm(screen,n[0])
def parse_file( fname, points, transform ): screen = new_screen() color = [255, 255, 0] f = open(fname, 'r') fs = [] for line in f.readlines(): fs.append(line[:-1]) i = 0 while i < len(fs): if (fs[i] == "l"): ps = fs[i+1].split(" ") add_edge(points, float(ps[0]), float(ps[1]), float(ps[2]), float(ps[3]), float(ps[4]),float(ps[5])) elif (fs[i] == "i"): transform = ident() elif (fs[i] == "s"): ps = fs[i+1].split() transform = matrix_mult(make_scale(float(ps[0]), float(ps[1]), float(ps[2])), transform) elif (fs[i] == "t"): ps = fs[i+1].split() transform = matrix_mult(make_translate(float(ps[0]), float(ps[1]), float(ps[2])), transform) elif (fs[i] == "x"): transform = matrix_mult(make_rotX(float(fs[i+1])), transform) elif (fs[i] == "y"): transform = matrix_mult(make_rotY(float(fs[i+1])), transform) elif (fs[i] == "z"): transform = matrix_mult(make_rotZ(float(fs[i+1])), transform) elif (fs[i] == "a"): points = matrix_mult(transform, points) elif (fs[i] == "v"): draw_lines(points, screen, color) display(screen) clear_screen(screen) elif (fs[i] == "g"): print str(i) + fs[i] draw_lines(points, screen, color) display(screen) i=i+1
def parse_file( fname, points, transform ): f = open('script_c', 'r') cmd = f.readline().rstrip() while (cmd): if cmd in commands_a: args = f.readline().rstrip() try: args = map(float, args.rsplit(" ")) except ValueError: fname = args m = ident(new_matrix()) if cmd == "g": draw_lines(points, screen, BLUE) save_ppm(screen, fname) save_extension(screen, fname) elif cmd == "l": add_edge(points, args[0], args[1], args[2], args[3], args[4], args[5]) elif cmd == "s": m = make_scale(args[0], args[1], args[2]) elif cmd == "t": m = make_translate(args[0], args[1], args[2]) elif cmd == "x": m = make_rotX(args[0]) elif cmd == "y": m = make_rotY(args[0]) elif cmd == "z": m = make_rotZ(args[0]) transform = matrix_mult(transform, m) elif cmd in commands_b: if cmd == "i": transform = ident(transform) elif cmd == "a": points = matrix_mult(transform, points) elif cmd == "v": screen = new_screen() draw_lines(points, screen, BLUE) display(screen) cmd = f.readline().rstrip()
def parse(filename, edges, transform, img, color): f = open(filename, "r") script = f.read().split("\n") f.close() i = 0 while i < len(script): if script[i] == "line": coords = script[i + 1].split(" ") for k in range(len(coords)): coords[k] = int(coords[k]) addEdge(edges, coords[0], coords[1], coords[2], coords[3], coords[4], coords[5]) i += 1 elif script[i] == "ident": transform = I(4) elif script[i] == "apply": edges = multMatrix(transform, edges) elif script[i] == "quit": return elif script[i] == "move": coords = script[i + 1].split(" ") for k in range(len(coords)): coords[k] = int(coords[k]) transform = multMatrix(translate(coords[0], coords[1], coords[2]), transform) i += 1 elif script[i] == "scale": coords = script[i + 1].split(" ") for k in range(len(coords)): coords[k] = float(coords[k]) transform = multMatrix(scale(coords[0], coords[1], coords[2]), transform) i += 1 elif script[i] == "rotate": coords = script[i + 1].split(" ") transform = multMatrix(rotate(coords[0], float(coords[1])), transform) i += 1 elif script[i] == "save": clear(img) drawLines(img, edges, color) if homeTest: save_ppm(img, script[i + 1]) else: save_extension(img, script[i + 1]) i += 1 elif script[i] == "circle": coords = script[i + 1].split(" ") for k in range(len(coords)): coords[k] = int(coords[k]) circle(edges, coords[0], coords[1], coords[2], coords[3]) i += 1 elif script[i] == "hermite": coords = script[i + 1].split(" ") for k in range(len(coords)): coords[k] = int(coords[k]) hermite(edges, coords[0], coords[1], coords[2], coords[3], coords[4], coords[5], coords[6], coords[7]) i += 1 elif script[i] == "bezier": coords = script[i + 1].split(" ") for k in range(len(coords)): coords[k] = int(coords[k]) bezier(edges, coords[0], coords[1], coords[2], coords[3], coords[4], coords[5], coords[6], coords[7]) i += 1 elif script[i] == "box": coords = script[i + 1].split(" ") for k in range(len(coords)): coords[k] = int(coords[k]) box(edges, coords[0], coords[1], coords[2], coords[3], coords[4], coords[5]) i += 1 elif script[i] == "sphere": coords = script[i + 1].split(" ") for k in range(len(coords)): coords[k] = int(coords[k]) sphere(edges, coords[0], coords[1], coords[2], coords[3]) i += 1 elif script[i] == "torus": coords = script[i + 1].split(" ") for k in range(len(coords)): coords[k] = int(coords[k]) torus(edges, coords[0], coords[1], coords[2], coords[3], coords[4]) i += 1 elif script[i] == "clear": edges[0] = [] edges[1] = [] edges[2] = [] edges[3] = [] elif script[i] == "display" and not homeTest: clear(img) drawLines(img, edges, color) display(img) i += 1
draw_line(XRES - 1, YRES - 1, 0, YRES / 2, s, c) #octants 8 and 4 c[BLUE] = 255 draw_line(0, YRES - 1, XRES - 1, 0, s, c) draw_line(0, YRES - 1, XRES - 1, YRES / 2, s, c) draw_line(XRES - 1, 0, 0, YRES / 2, s, c) #octants 2 and 6 c[RED] = 255 c[GREEN] = 0 c[BLUE] = 0 draw_line(0, 0, XRES / 2, YRES - 1, s, c) draw_line(XRES - 1, YRES - 1, XRES / 2, 0, s, c) #octants 7 and 3 c[BLUE] = 255 draw_line(0, YRES - 1, XRES / 2, 0, s, c) draw_line(XRES - 1, 0, XRES / 2, YRES - 1, s, c) #horizontal and vertical c[BLUE] = 0 c[GREEN] = 255 draw_line(0, YRES / 2, XRES - 1, YRES / 2, s, c) draw_line(XRES / 2, 0, XRES / 2, YRES - 1, s, c) display(s) save_ppm(s, 'binary.ppm') save_ppm_ascii(s, 'ascii.ppm') save_extension(s, 'img.png')
def parse_file(fname, points, transform, screen, color): points = new_matrix() f = open(fname, 'r') lines = f.readlines() for i in range(len(lines)): if (lines[i] == "line\n"): coors = lines[i + 1].split(" ") x0 = int(coors[0]) y0 = int(coors[1]) z0 = int(coors[2]) x1 = int(coors[3]) y1 = int(coors[4]) z1 = int(coors[5]) add_edge(points, x0, y0, z0, x1, y1, z1) print "========== line ==========" print_matrix(points) elif (lines[i] == "ident\n"): ident(transform) print "========== ident ==========" print_matrix(transform) elif (lines[i] == "scale\n"): factor = lines[i + 1].split(" ") x = int(factor[0]) y = int(factor[1]) z = int(factor[2]) scale = make_scale(x, y, z) matrix_mult(scale, transform) print "========== scale ==========" print_matrix(transform) elif (lines[i] == "move\n"): factor = lines[i + 1].split(" ") x = int(factor[0]) y = int(factor[1]) z = int(factor[2]) translate = make_translate(x, y, z) matrix_mult(translate, transform) print "========== move ==========" print_matrix(transform) elif (lines[i] == "rotate\n"): param = lines[i + 1].split(" ") direct = param[0] angle = int(param[1]) * math.pi / 180 if (direct == "x"): rotate = make_rotX(angle) elif (direct == "y"): rotate = make_rotY(angle) else: rotate = make_rotZ(angle) matrix_mult(rotate, transform) print "========== rotate ==========" print_matrix(transform) elif (lines[i] == "apply\n"): print "========== before apply ==========" print_matrix(points) matrix_mult(transform, points) for c in range(len(points)): for r in range(len(points[0])): points[c][r] = int(points[c][r]) print "========== apply ==========" print_matrix(points) elif (lines[i] == "display\n"): clear_screen(screen) draw_lines(points, screen, color) display(screen) elif (lines[i] == "save\n"): image = lines[i + 1].split() save_extension(screen, image[0]) else: pass
def parse_file( fname, points, transform, screen, color ): f = open(fname, "r", 1) buffer = f.read() buffer = buffer.split("\n") print buffer index = 0 while (index < len(buffer)): if (buffer[index] == "line"): print "drawing line" temp = parseArgs(buffer[index+1]) add_edge(points,temp[0],temp[1],temp[2],temp[3],temp[4],temp[5]) index+=2 elif (buffer[index] == "circle"): print "drawing circle" temp = parseArgs(buffer[index+1]) add_circle(points,temp[0],temp[1],0,temp[3],0.001) index+=2 elif (buffer[index] == "hermite"): print "drawing hermite" temp = parseArgs(buffer[index+1]) add_curve(points,temp[0],temp[1],temp[2],temp[3],temp[4],temp[5],temp[6],temp[7],0.001,"h") index+=2 elif (buffer[index] == "bezier"): temp = parseArgs(buffer[index+1]) add_curve(points,temp[0],temp[1],temp[2],temp[3],temp[4],temp[5],temp[6],temp[7],0.001,"b") index+=2 elif (buffer[index] == "ident"): ident(transform) index+=1 elif (buffer[index] == "scale"): print "scaling" temp = parseArgs(buffer[index+1]) transform = make_scale(temp[0],temp[1],temp[2]) index+=2 elif (buffer[index] == "translate"): print "translating" temp = parseArgs(buffer[index+1]) transform = make_translate(temp[0],temp[1],temp[2]) index+=2 elif (buffer[index] == "xrotate"): print "xrot" temp = parseArgs(buffer[index+1]) transform = make_rotX(temp[0]) index+=2 elif (buffer[index] == "yrotate"): print "yrot" temp = parseArgs(buffer[index+1]) transform = make_rotY(temp[0]) index+=2 elif (buffer[index] == "zrotate"): print "zrot" temp = parseArgs(buffer[index+1]) transform = make_rotZ(temp[0]) index+=2 elif (buffer[index] == "apply"): print "apply" matrix_mult(transform,points) index+=1 elif (buffer[index] == "display"): print "displaying" draw_lines(points,screen,color) display(screen) index+=1 elif (buffer[index] == "save"): draw_lines(points,screen,color) save_ppm(screen,temp[0]) index+=1 else: index+=1
def run(filename): """ This function runs an mdl script """ p = mdl.parseFile(filename) if p: (commands, symbols) = p else: print "Parsing failed." return view = [0, 0, 1] ambient = [50, 50, 50] light = [[0.5, 0.75, 1], [255, 255, 255]] color = [0, 0, 0] tmp = new_matrix() ident(tmp) stack = [[x[:] for x in tmp]] screen = new_screen() zbuffer = new_zbuffer() tmp = [] step_3d = 100 consts = '' polygons = [] edges = [] symbols['.white'] = [ 'constants', { 'red': [0.2, 0.5, 0.5], 'green': [0.2, 0.5, 0.5], 'blue': [0.2, 0.5, 0.5] } ] for command in commands: op = command['op'] if op == 'push': stack.append([x[:] for x in stack[-1]]) elif op == 'pop': stack.pop() elif op == 'sphere': #print 'SPHERE\t' + str(args) if (command['constants'] == None): reflect = '.white' else: reflect = command['constants'] args = command['args'] add_sphere(polygons, float(args[0]), float(args[1]), float(args[2]), float(args[3]), step_3d) matrix_mult(stack[-1], polygons) draw_polygons(polygons, screen, zbuffer, view, ambient, light, symbols, reflect) polygons = [] elif op == 'torus': #print 'TORUS\t' + str(args) if (command['constants'] == None): reflect = '.white' else: reflect = command['constants'] args = command['args'] add_torus(polygons, float(args[0]), float(args[1]), float(args[2]), float(args[3]), float(args[4]), step_3d) matrix_mult(stack[-1], polygons) draw_polygons(polygons, screen, zbuffer, view, ambient, light, symbols, reflect) polygons = [] elif op == 'box': #print 'BOX\t' + str(args) if (command['constants'] == None): reflect = '.white' else: reflect = command['constants'] args = command['args'] add_box(polygons, float(args[0]), float(args[1]), float(args[2]), float(args[3]), float(args[4]), float(args[5])) matrix_mult(stack[-1], polygons) draw_polygons(polygons, screen, zbuffer, view, ambient, light, symbols, reflect) polygons = [] elif op == 'line': args = command['args'] add_edge(edges, float(args[0]), float(args[1]), float(args[2]), float(args[3]), float(args[4]), float(args[5])) matrix_mult(stack[-1], edges) draw_lines(edges, screen, zbuffer, color) edges = [] elif op == 'scale': #print 'SCALE\t' + str(args) args = command['args'] t = make_scale(float(args[0]), float(args[1]), float(args[2])) matrix_mult(stack[-1], t) stack[-1] = [x[:] for x in t] elif op == 'move': #print 'MOVE\t' + str(args) args = command['args'] t = make_translate(float(args[0]), float(args[1]), float(args[2])) matrix_mult(stack[-1], t) stack[-1] = [x[:] for x in t] elif op == 'rotate': #print 'ROTATE\t' + str(args) args = command['args'] theta = float(args[1]) * (math.pi / 180) if args[0] == 'x': t = make_rotX(theta) elif args[0] == 'y': t = make_rotY(theta) else: t = make_rotZ(theta) matrix_mult(stack[-1], t) stack[-1] = [x[:] for x in t] elif op == 'clear': clear_screen(screen) clear_zbuffer(zbuffer) elif op == 'display' or op == 'save': args = command['args'] #clear_screen(screen) args = command['args'] if op == 'display': display(screen) else: save_extension(screen, args[0])
def parse_file(fname, edges, transform, screen, color): f = open(fname) lines = f.readlines() c = 0 while c < len(lines): line = lines[c].strip() #print ':' + line + ':' if line in ARG_COMMANDS: c += 1 args = lines[c].strip().split(' ') if line == 'line': #print 'LINE\t' + str(args) add_edge(edges, float(args[0]), float(args[1]), float(args[2]), float(args[3]), float(args[4]), float(args[5])) elif line == 'scale': #print 'SCALE\t' + str(args) t = make_scale(float(args[0]), float(args[1]), float(args[2])) matrix_mult(t, transform) elif line == 'move': #print 'MOVE\t' + str(args) t = make_translate(float(args[0]), float(args[1]), float(args[2])) matrix_mult(t, transform) elif line == 'rotate': #print 'ROTATE\t' + str(args) theta = float(args[1]) * (math.pi / 180) if args[0] == 'x': t = make_rotX(theta) elif args[0] == 'y': t = make_rotY(theta) else: t = make_rotZ(theta) matrix_mult(t, transform) elif line == 'ident': ident(transform) elif line == 'apply': matrix_mult(transform, edges) elif line == 'display' or line == 'save': clear_screen(screen) draw_lines(edges, screen, color) if line == 'display': display(screen) else: save_extension(screen, args[0]) elif line == 'circle': x, y, z, r = float(args[0]), float(args[1]), float(args[2]), float( args[3]) t = 0 increment = 0.0001 while t + increment <= 1: point = make_circle(x, y, z, r, t) add_point(edges, point[0], point[1], z) t += increment point = make_circle(x, y, z, r, t) add_point(edges, point[0], point[1], z) t += increment elif line == 'bezier': xcoef = make_bezier(float(args[0]), float(args[2]), float(args[4]), float(args[6])) #print(float(args[0]), float(args[2]), float(args[4]), float(args[6])) ycoef = make_bezier(float(args[1]), float(args[3]), float(args[5]), float(args[7])) #print(float(args[1]), float(args[3]), float(args[5]), float(args[7])) # print(xcoef) # print(ycoef) t = 0 increment = 0.0001 while t + increment <= 1: add_point(edges, apply_coef(xcoef, t), apply_coef(ycoef, t), 1) t += increment add_point(edges, apply_coef(xcoef, t), apply_coef(ycoef, t), 1) t += increment elif line == 'hermite': xcoef = make_hermite(float(args[0]), float(args[2]), float(args[4]), float(args[6])) ycoef = make_hermite(float(args[1]), float(args[3]), float(args[5]), float(args[7])) t = 0 increment = 0.0001 while t + increment <= 1: add_point(edges, apply_coef(xcoef, t), apply_coef(ycoef, t), 1) t += increment add_point(edges, apply_coef(xcoef, t), apply_coef(ycoef, t), 1) t += increment c += 1
def parse_file(fname, edges, transform, screen, color): f = open(fname) lines = f.readlines() c = 0 while c < len(lines): line = lines[c].strip() #print ':' + line + ':' if line in ARG_COMMANDS: c += 1 args = lines[c].strip().split(' ') if line == 'sphere': add_sphere(edges, float(args[0]), float(args[1]), float(args[2]), float(args[3]), 0.05) elif line == 'torus': add_torus(edges, float(args[0]), float(args[1]), float(args[2]), float(args[3]), float(args[4]), 0.05) elif line == 'box': add_box(edges, float(args[0]), float(args[1]), float(args[2]), float(args[3]), float(args[4]), float(args[5])) elif line == 'clear': screen = new_screen() edges = [] elif line == 'circle': add_circle(edges, float(args[0]), float(args[1]), float(args[2]), float(args[3]), 0.001) elif line == 'hermite': add_curve(edges, float(args[0]), float(args[1]), float(args[2]), float(args[3]), float(args[4]), float(args[5]), float(args[6]), float(args[7]), 0.001, 'hermite') elif line == 'bezier': add_curve(edges, float(args[0]), float(args[1]), float(args[2]), float(args[3]), float(args[4]), float(args[5]), float(args[6]), float(args[7]), 0.001, 'bezier') elif line == 'line': #print 'LINE\t' + str(args) add_edge(edges, float(args[0]), float(args[1]), float(args[2]), float(args[3]), float(args[4]), float(args[5])) elif line == 'scale': #print 'SCALE\t' + str(args) t = make_scale(float(args[0]), float(args[1]), float(args[2])) matrix_mult(t, transform) elif line == 'move': #print 'MOVE\t' + str(args) t = make_translate(float(args[0]), float(args[1]), float(args[2])) matrix_mult(t, transform) elif line == 'rotate': #print 'ROTATE\t' + str(args) theta = float(args[1]) * (math.pi / 180) if args[0] == 'x': t = make_rotX(theta) elif args[0] == 'y': t = make_rotY(theta) else: t = make_rotZ(theta) matrix_mult(t, transform) elif line == 'ident': ident(transform) elif line == 'apply': matrix_mult(transform, edges) elif line == 'display' or line == 'save': clear_screen(screen) draw_lines(edges, screen, color) if line == 'display': display(screen) else: save_extension(screen, args[0]) c += 1
def parse_file(fname, edges, transform, screen, color): f = open(fname) lines = f.readlines() clear_screen(screen) t = new_matrix() ident(t) systems = [t] step = 0.1 c = 0 while c < len(lines): line = lines[c].strip() #print ':' + line + ':' if line in ARG_COMMANDS: c += 1 args = lines[c].strip().split(' ') #print 'args\t' + str(args) if line == 'sphere': #print 'SPHERE\t' + str(args) add_sphere(edges, float(args[0]), float(args[1]), float(args[2]), float(args[3]), step) matrix_mult(systems[-1], edges) draw_polygons(edges, screen, color) edges = [] elif line == 'torus': #print 'TORUS\t' + str(args) add_torus(edges, float(args[0]), float(args[1]), float(args[2]), float(args[3]), float(args[4]), step) matrix_mult(systems[-1], edges) draw_polygons(edges, screen, color) edges = [] elif line == 'box': #print 'BOX\t' + str(args) add_box(edges, float(args[0]), float(args[1]), float(args[2]), float(args[3]), float(args[4]), float(args[5])) matrix_mult(systems[-1], edges) draw_polygons(edges, screen, color) edges = [] elif line == 'circle': #print 'CIRCLE\t' + str(args) add_circle(edges, float(args[0]), float(args[1]), float(args[2]), float(args[3]), step) elif line == 'hermite' or line == 'bezier': #print 'curve\t' + line + ": " + str(args) add_curve(edges, float(args[0]), float(args[1]), float(args[2]), float(args[3]), float(args[4]), float(args[5]), float(args[6]), float(args[7]), step, line) elif line == 'line': #print 'LINE\t' + str(args) add_edge(edges, float(args[0]), float(args[1]), float(args[2]), float(args[3]), float(args[4]), float(args[5])) elif line == 'scale': #print 'SCALE\t' + str(args) t = make_scale(float(args[0]), float(args[1]), float(args[2])) matrix_mult(systems[-1], t) systems[-1] = [x[:] for x in t] elif line == 'move': #print 'MOVE\t' + str(args) t = make_translate(float(args[0]), float(args[1]), float(args[2])) matrix_mult(systems[-1], t) systems[-1] = [x[:] for x in t] elif line == 'rotate': #print 'ROTATE\t' + str(args) theta = float(args[1]) * (math.pi / 180) if args[0] == 'x': t = make_rotX(theta) elif args[0] == 'y': t = make_rotY(theta) else: t = make_rotZ(theta) matrix_mult(systems[-1], t) systems[-1] = [x[:] for x in t] elif line == 'clear': edges = [] elif line == 'ident': ident(transform) elif line == 'apply': matrix_mult(transform, edges) elif line == 'push': systems.append([x[:] for x in systems[-1]]) elif line == 'pop': systems.pop() elif line == 'display' or line == 'save': if line == 'display': display(screen) else: save_extension(screen, args[0]) c += 1
def parse_file(fname, edges, polygons, csystems, screen, color): f = open(fname) lines = f.readlines() step = 100 step_3d = 20 c = 0 while c < len(lines): line = lines[c].strip() #print ':' + line + ':' if line in ARG_COMMANDS: c += 1 args = lines[c].strip().split(' ') if line == 'push': csystems.append(copy_matrix(csystems[-1])) elif line == 'pop': csystems.pop() elif line == 'sphere': #print 'SPHERE\t' + str(args) add_sphere(polygons, float(args[0]), float(args[1]), float(args[2]), float(args[3]), step_3d) matrix_mult(csystems[-1], polygons) draw_polygons(polygons, screen, color) polygons = [] elif line == 'torus': #print 'TORUS\t' + str(args) add_torus(polygons, float(args[0]), float(args[1]), float(args[2]), float(args[3]), float(args[4]), step_3d) matrix_mult(csystems[-1], polygons) draw_polygons(polygons, screen, color) polygons = [] elif line == 'box': #print 'BOX\t' + str(args) add_box(polygons, float(args[0]), float(args[1]), float(args[2]), float(args[3]), float(args[4]), float(args[5])) matrix_mult(csystems[-1], polygons) draw_polygons(polygons, screen, color) polygons = [] elif line == 'circle': #print 'CIRCLE\t' + str(args) add_circle(edges, float(args[0]), float(args[1]), float(args[2]), float(args[3]), step) matrix_mult(csystems[-1], edges) draw_lines(edges, screen, color) edges = [] elif line == 'hermite' or line == 'bezier': #print 'curve\t' + line + ": " + str(args) add_curve(edges, float(args[0]), float(args[1]), float(args[2]), float(args[3]), float(args[4]), float(args[5]), float(args[6]), float(args[7]), step, line) matrix_mult(csystems[-1], edges) draw_lines(edges, screen, color) edges = [] elif line == 'line': #print 'LINE\t' + str(args) add_edge(edges, float(args[0]), float(args[1]), float(args[2]), float(args[3]), float(args[4]), float(args[5])) matrix_mult(csystems[-1], edges) draw_lines(edges, screen, color) edges = [] elif line == 'scale': #print 'SCALE\t' + str(args) t = make_scale(float(args[0]), float(args[1]), float(args[2])) matrix_mult(csystems[-1], t) csystems[-1] = copy_matrix(t) elif line == 'move': #print 'MOVE\t' + str(args) t = make_translate(float(args[0]), float(args[1]), float(args[2])) matrix_mult(csystems[-1], t) csystems[-1] = copy_matrix(t) elif line == 'rotate': #print 'ROTATE\t' + str(args) theta = float(args[1]) * (math.pi / 180) if args[0] == 'x': t = make_rotX(theta) elif args[0] == 'y': t = make_rotY(theta) else: t = make_rotZ(theta) matrix_mult(csystems[-1], t) csystems[-1] = copy_matrix(t) elif line == 'display' or line == 'save': if line == 'display': display(screen) else: save_extension(screen, args[0]) c += 1
while x0 < 400: color = [0, green, blue] draw_line(x0, y0, x1, y1, screen, color) x0 += 5 x1 -= 5 if green > 100: green -= 0.5 if blue < 255: blue += 1 red = 255 x2 = 0 y2 = 0 x3 = 50 x4 = 500 y4 = 500 x5 = 450 while y2 < 500: color = [red, 0, 0] draw_line(x2, y2, x3, y2, screen, color) draw_line(x4, y4, x5, y4, screen, color) if red > 100: red -= 0.5 y2 += 2 y4 -= 2 display(screen) save_extension(screen, 'img.png')
def run(filename): """ This function runs an mdl script """ p = mdl.parseFile(filename) if p: (commands, symbols) = p else: print "Parsing failed." return view = [0, 0, 1]; ambient = [50, 50, 50] light = [[0.5, 0.75, 1], [255, 255, 255]] color = [0, 0, 0] symbols['.white'] = ['constants', {'red': [0.2, 0.5, 0.5], 'green': [0.2, 0.5, 0.5], 'blue': [0.2, 0.5, 0.5]}] reflect = '.white' (name, num_frames) = first_pass(commands) frames = second_pass(commands, num_frames) for i in range(int(num_frames)): tmp = new_matrix() ident( tmp ) stack = [ [x[:] for x in tmp] ] screen = new_screen() zbuffer = new_zbuffer() tmp = [] step_3d = 100 consts = '' coords = [] coords1 = [] for command in commands: print command c = command['op'] args = command['args'] knob_value = 1 if "knob" in command.keys() and command['knob'] != None: knob_value = frames[i][command['knob']] if c == 'box': if command['constants']: reflect = command['constants'] add_box(tmp, args[0]*knob_value, args[1]*knob_value, args[2]*knob_value, args[3]*knob_value, args[4]*knob_value, args[5]*knob_value) matrix_mult( stack[-1], tmp ) draw_polygons(tmp, screen, zbuffer, view, ambient, light, symbols, reflect) tmp = [] reflect = '.white' elif c == 'sphere': if command['constants']: reflect = command['constants'] add_sphere(tmp, args[0]*knob_value, args[1]*knob_value, args[2]*knob_value, args[3]*knob_value, step_3d) matrix_mult( stack[-1], tmp ) draw_polygons(tmp, screen, zbuffer, view, ambient, light, symbols, reflect) tmp = [] reflect = '.white' elif c == 'torus': if command['constants']: reflect = command['constants'] add_torus(tmp, args[0]*knob_value, args[1]*knob_value, args[2]*knob_value, args[3]*knob_value, args[4]*knob_value, step_3d) matrix_mult( stack[-1], tmp ) draw_polygons(tmp, screen, zbuffer, view, ambient, light, symbols, reflect) tmp = [] reflect = '.white' elif c == 'line': add_edge(tmp, args[0]*knob_value, args[1]*knob_value, args[2]*knob_value, args[3]*knob_value, args[4]*knob_value, args[5]*knob_value) matrix_mult( stack[-1], tmp ) draw_lines(tmp, screen, zbuffer, color) tmp = [] elif c == 'move': tmp = make_translate(args[0]*knob_value, args[1]*knob_value, args[2]*knob_value) matrix_mult(stack[-1], tmp) stack[-1] = [x[:] for x in tmp] tmp = [] elif c == 'scale': tmp = make_scale(args[0]*knob_value, args[1]*knob_value, args[2]*knob_value) matrix_mult(stack[-1], tmp) stack[-1] = [x[:] for x in tmp] tmp = [] elif c == 'rotate': theta = args[1] * (math.pi/180) *knob_value if args[0] == 'x': tmp = make_rotX(theta) elif args[0] == 'y': tmp = make_rotY(theta) else: tmp = make_rotZ(theta) matrix_mult( stack[-1], tmp ) stack[-1] = [ x[:] for x in tmp] tmp = [] elif c == 'push': stack.append([x[:] for x in stack[-1]] ) elif c == 'pop': stack.pop() elif c == 'display': display(screen) elif c == 'save': save_extension(screen, args[0]) elif c == 'mesh': if command['constants']: reflect = command['constants'] add_sphere(tmp, args[0]*knob_value, args[1]*knob_value, args[2]*knob_value, args[3]*knob_value, step_3d) matrix_mult( stack[-1], tmp ) draw_polygons(tmp, screen, zbuffer, view, ambient, light, symbols, reflect) tmp = [] save_extension(screen,"./anim/" + name + ("0000" + str(i))[-4:])
def run(filename): """ This function runs an mdl script """ p = mdl.parseFile(filename) if p: (commands, symbols) = p else: print("Parsing failed.") return view = [0, 0, 1] ambient = [50, 50, 50] light = [[0.5, 0.75, 1], [255, 255, 255]] color = [0, 0, 0] tmp = new_matrix() ident(tmp) stack = [[x[:] for x in tmp]] screen = new_screen() zbuffer = new_zbuffer() tmp = [] step_3d = 100 consts = '' coords = [] coords1 = [] symbols['.white'] = [ 'constants', { 'red': [0.2, 0.5, 0.5], 'green': [0.2, 0.5, 0.5], 'blue': [0.2, 0.5, 0.5] } ] reflect = '.white' edges = [] polygons = [] print(symbols) for command in commands: # print (command) if command["op"] == "move": t = make_translate(float(command["args"][0]), float(command["args"][1]), float(command["args"][2])) matrix_mult(stack[-1], t) stack[-1] = [x[:] for x in t] elif command["op"] == "sphere": add_sphere(polygons, float(command["args"][0]), float(command["args"][1]), float(command["args"][2]), float(command["args"][3]), step_3d) matrix_mult(stack[-1], polygons) if command["constants"] == None: draw_polygons(polygons, screen, zbuffer, view, ambient, light, symbols, reflect) else: draw_polygons(polygons, screen, zbuffer, view, ambient, light, symbols, command["constants"]) polygons = [] elif command["op"] == "rotate": theta = float(command["args"][1]) * (math.pi / 180) if command["args"][0] == 'x': t = make_rotX(theta) elif command["args"][0] == 'y': t = make_rotY(theta) else: t = make_rotZ(theta) matrix_mult(stack[-1], t) stack[-1] = [x[:] for x in t] elif command["op"] == "box": add_box(polygons, float(command["args"][0]), float(command["args"][1]), float(command["args"][2]), float(command["args"][3]), float(command["args"][4]), float(command["args"][5])) matrix_mult(stack[-1], polygons) if command["constants"] == None: draw_polygons(polygons, screen, zbuffer, view, ambient, light, symbols, reflect) else: draw_polygons(polygons, screen, zbuffer, view, ambient, light, symbols, command["constants"]) polygons = [] elif command["op"] == "pop": stack.pop() elif command["op"] == "push": stack.append([x[:] for x in stack[-1]]) elif command["op"] == "scale": t = make_scale(float(command["args"][0]), float(command["args"][1]), float(command["args"][2])) matrix_mult(stack[-1], t) stack[-1] = [x[:] for x in t] elif command["op"] == "torus": add_torus(polygons, float(command["args"][0]), float(command["args"][1]), float(command["args"][2]), float(command["args"][3]), float(command["args"][4]), step_3d) matrix_mult(stack[-1], polygons) if command["constants"] == None: draw_polygons(polygons, screen, zbuffer, view, ambient, light, symbols, reflect) else: draw_polygons(polygons, screen, zbuffer, view, ambient, light, symbols, command["constants"]) polygons = [] elif command["op"] == "display": display(screen) elif command["op"] == "save": save_extension(screen, command["args"][0] + ".png")
def parse_file(fname, edges, polygons, transform, screen, color): f = open(fname) lines = f.readlines() step = 100 step_3d = 20 start = new_matrix() ident(start) stack = [] stack.append(start) for c in range(0, len(lines)): line = lines[c].strip() #print ':' + line + ':' if line in ARG_COMMANDS: c += 1 args = lines[c].strip().split(' ') #print 'args\t' + str(args) if line == 'push': top = deepcopy(stack[-1]) stack.append(top) elif line == 'pop': stack.pop() elif line == 'sphere': #print 'SPHERE\t' + str(args) add_sphere(polygons, float(args[0]), float(args[1]), float(args[2]), float(args[3]), step_3d) matrix_mult(stack[-1], polygons) draw_polygons(polygons, screen, color) polygons = [] elif line == 'torus': #print 'TORUS\t' + str(args) add_torus(polygons, float(args[0]), float(args[1]), float(args[2]), float(args[3]), float(args[4]), step_3d) matrix_mult(stack[-1], polygons) draw_polygons(polygons, screen, color) polygons = [] elif line == 'box': #print 'BOX\t' + str(args) add_box(polygons, float(args[0]), float(args[1]), float(args[2]), float(args[3]), float(args[4]), float(args[5])) matrix_mult(stack[-1], polygons) draw_polygons(polygons, screen, color) polygons = [] elif line == 'circle': #print 'CIRCLE\t' + str(args) add_circle(edges, float(args[0]), float(args[1]), float(args[2]), float(args[3]), step) matrix_mult(stack[-1], edges) draw_lines(edges, screen, color) edges = [] elif line == 'hermite' or line == 'bezier': #print 'curve\t' + line + ": " + str(args) add_curve(edges, float(args[0]), float(args[1]), float(args[2]), float(args[3]), float(args[4]), float(args[5]), float(args[6]), float(args[7]), step, line) matrix_mult(stack[-1], edges) draw_lines(edges, screen, color) edges = [] elif line == 'line': #print 'LINE\t' + str(args) add_edge(edges, float(args[0]), float(args[1]), float(args[2]), float(args[3]), float(args[4]), float(args[5])) matrix_mult(stack[-1], edges) draw_lines(edges, screen, color) edges = [] elif line == 'scale': #print 'SCALE\t' + str(args) t = make_scale(float(args[0]), float(args[1]), float(args[2])) matrix_mult(t, transform) matrix_mult(stack.pop(), t) stack.append(t) elif line == 'move': #print 'MOVE\t' + str(args) t = make_translate(float(args[0]), float(args[1]), float(args[2])) matrix_mult(stack.pop(), t) stack.append(t) elif line == 'rotate': #print 'ROTATE\t' + str(args) theta = float(args[1]) * (math.pi / 180) if args[0] == 'x': t = make_rotX(theta) elif args[0] == 'y': t = make_rotY(theta) else: t = make_rotZ(theta) matrix_mult(stack.pop(), t) stack.append(t) elif line == 'display': display(screen) elif line == 'save': save_extension(screen, args[0])
def parse_file( fname, points, transform, screen, color ): CURR_NUM = 0 file = open(fname, 'r') lines = file.readlines() for i in range(len(lines)): line = lines[i].strip() print line if line == "line": next = lines[i+1].strip().split() add_edge( points, int(next[0]), int(next[1]), int(next[2]), int(next[3]), int(next[4]), int(next[5])) i += 1 elif line == "ident": ident( transform ) elif line == "scale": next = lines[i+1].strip().split() scale = make_scale( float(next[0]), float(next[1]), float(next[2]) ) matrix_mult(scale, transform) i += 1 elif line == "move": next = lines[i+1].strip().split() trans = make_translate( int(next[0]), int(next[1]), int(next[2]) ) matrix_mult( trans, transform ) i += 1 elif line == "rotate": next = lines[i+1].strip() next = next.split() if next[0] == 'x': rot = make_rotX( int(next[1]) ) elif next[0] == 'y': rot = make_rotY( int(next[1]) ) else: rot = make_rotZ( int(next[1]) ) matrix_mult( rot, transform ) i += 1 elif line == "apply": matrix_mult( transform, points ) for num in range(len(points)): for num2 in range(len(points[0])): points[num][num2] = int(points[num][num2]) elif line == "display": CURR_NUM += 1 clear_screen(screen) draw_lines( points, screen, color ) display(screen) print CURR_NUM elif line == "save": clear_screen( screen ) next = str(lines[i+1]) draw_lines( points, screen, color ) save_extension(screen, next) elif line == "quit": break # file = open(fname,'r') # i = file.readline().strip() # i2 = [] # while i != '': # print i # if i == "line": #written, not checked # i2 = file.readline().strip() # i2 = [int(x) for x in i2.split()] # print i2 # add_edge( points, i2[0], i2[1], i2[2], i2[3], i2[4], i2[5] ) # elif i == "ident": #written, not checked # ident( transform ) # elif i == "scale": #written, not checked # i2 = file.readline().strip() # i2 = [float(x) for x in i2.split()] # mat = make_scale(i2[0], i2[1], i2[2]) # matrix_mult( transform, points ) # elif i == "translate": #written, not checked # i2 = file.readline().strip() # i2 = [int(x) for x in i2.split()] # mat = make_scale(i2[0], i2[1], i2[2]) # matrix_mult( transform, points ) # elif i == "rotate": #not written, not checked # i2 = file.readline().strip() # tmp = i2[2] # if i2[0] == 'x': # make_rotX( int(tmp) ) # matrix_mult(make_rotX, points) # elif i2[1] == 'y': # make_rotY( int(tmp) ) # matrix_mult(make_rotY, points) # else: # make_rotZ( int(tmp) ) # matrix_mult(make_rotZ, points) # elif i == "apply": #not written, not checked # pass # elif i == "display": #written, not checked # clear_screen(screen) # draw_lines(points, screen, color) # display(screen) # clear_screen(screen) # elif i == "save": #written, not checked # clear_screen(screen) # draw_lines(points, screen, color) # i2 = file.readline().strip() # save_extension( screen, i2[0] ) # clear_screen(screen) # elif i == "quit": #written, not checked # break # i = file.readline().strip() # file.close()
def run(filename): """ This function runs an mdl script """ p = mdl.parseFile(filename) if p: (commands, symbols) = p else: print "Parsing failed." return view = [0, 0, 1]; ambient = [50, 50, 50] light = [[0.5, 0.75, 1], [255, 255, 255]] color = [0, 0, 0] tmp = new_matrix() ident( tmp ) stack = [ [x[:] for x in tmp] ] screen = new_screen() zbuffer = new_zbuffer() tmp = [] step_3d = 100 consts = '' coords = [] coords1 = [] symbols['.white'] = ['constants', {'red': [0.2, 0.5, 0.5], 'green': [0.2, 0.5, 0.5], 'blue': [0.2, 0.5, 0.5]}] reflect = '.white' polygons = [] edges = [] for command in commands: if command['op'] == 'push': stack.append([row[:] for row in stack[-1]]) elif command['op'] == 'pop': stack.pop() elif command['op'] == 'move': t = make_translate(command['args'][0],command['args'][1],command['args'][2]) matrix_mult(stack[-1], t) stack[-1] = [r[:] for r in t] elif command['op'] == 'scale': t = make_scale(command['args'][0],command['args'][1],command['args'][2]) matrix_mult(stack[-1], t) stack[-1] = [r[:] for r in t] elif command['op'] == 'rotate': t = new_matrix() if(command['args'][0] == 'x'): t = make_rotX(command['args'][1]*(math.pi / 180)) elif(command['args'][0] == 'y'): t = make_rotY(command['args'][1]*(math.pi / 180)) elif(command['args'][0] == 'z'): t = make_rotZ(command['args'][1]*(math.pi / 180)) else: print("Input axis for rotate is incorrect") matrix_mult(stack[-1], t) stack[-1] = [r[:] for r in t] elif command['op'] in 'sphere box torus': if command['op'] == 'sphere': add_sphere(polygons, float(command['args'][0]), float(command['args'][1]), float(command['args'][2]), float(command['args'][3]), step_3d) elif command['op'] == 'box': add_box(polygons, float(command['args'][0]), float(command['args'][1]), float(command['args'][2]), float(command['args'][3]), float(command['args'][4]), float(command['args'][5])) elif command['op'] == 'torus': add_torus(polygons, float(command['args'][0]), float(command['args'][1]), float(command['args'][2]), float(command['args'][3]), float(command['args'][4]), step_3d) matrix_mult( stack[-1], polygons ) if(command['constants']): draw_polygons(polygons, screen, zbuffer, view, ambient, light, symbols, command['constants']) else: draw_polygons(polygons, screen, zbuffer, view, ambient, light, symbols, reflect) polygons = [] elif command['op'] == 'line': add_edge(edges, float(command['args'][0]), float(command['args'][1]), float(command['args'][2]), float(command['args'][3]), float(command['args'][4]), float(command['args'][5])) matrix_mult( stack[-1], edges ) draw_lines(edges, screen, zbuffer, color) edges = [] elif command['op'] == 'constants': pass elif command['op'] == 'save': save_extension(screen, command['args'][0] + ".png") elif command['op'] == 'display': display(screen) else: print("Unknown operator", command['op'])
def run(filename): """ This function runs an mdl script """ p = mdl.parseFile(filename) if p: (commands, symbols) = p else: print "Parsing failed." return view = [0, 0, 1] ambient = [50, 50, 50] light = [[0.5, 0.75, 1], [255, 255, 255]] color = [0, 0, 0] symbols['.white'] = [ 'constants', { 'red': [0.2, 0.5, 0.5], 'green': [0.2, 0.5, 0.5], 'blue': [0.2, 0.5, 0.5] }, { 'red': [0.7, 0.2, 0], 'green': [0.2, 0, 0.5], 'blue': [0, 0.5, 0.5] } ] symbols['shade_type'] = 'flat' reflect = '.white' (name, num_frames) = first_pass(commands) frames = second_pass(commands, num_frames) tmp = new_matrix() ident(tmp) stack = [[x[:] for x in tmp]] screen = new_screen() zbuffer = new_zbuffer() tmp = [] step_3d = 100 consts = '' coords = [] coords1 = [] for command in commands: #print command c = command['op'] args = command['args'] knob_value = 1 shading = symbols['shade_type'] if c == 'box': if command['constants']: reflect = command['constants'] add_box(tmp, args[0], args[1], args[2], args[3], args[4], args[5]) matrix_mult(stack[-1], tmp) draw_polygons(tmp, screen, zbuffer, view, ambient, light, symbols, reflect, shading) tmp = [] reflect = '.white' elif c == 'pyramid': if command['constants']: reflect = command['constants'] add_pyramid(tmp, args[0], args[1], args[2], args[3], args[4], args[5]) matrix_mult(stack[-1], tmp) draw_polygons(tmp, screen, zbuffer, view, ambient, light, symbols, reflect, shading) tmp = [] reflect = '.white' elif c == 'cylinder': if command['constants']: reflect = command['constants'] add_cylinder(tmp, args[0], args[1], args[2], args[3], args[4], step_3d) matrix_mult(stack[-1], tmp) draw_polygons(tmp, screen, zbuffer, view, ambient, light, symbols, reflect) tmp = [] reflect = '.white' elif c == 'sphere': if command['constants']: reflect = command['constants'] add_sphere(tmp, args[0], args[1], args[2], args[3], step_3d) matrix_mult(stack[-1], tmp) print(shading) draw_polygons(tmp, screen, zbuffer, view, ambient, light, symbols, reflect, shading) tmp = [] reflect = '.white' elif c == 'torus': if command['constants']: reflect = command['constants'] add_torus(tmp, args[0], args[1], args[2], args[3], args[4], step_3d) matrix_mult(stack[-1], tmp) draw_polygons(tmp, screen, zbuffer, view, ambient, light, symbols, reflect, shading) tmp = [] reflect = '.white' elif c == 'line': add_edge(tmp, args[0], args[1], args[2], args[3], args[4], args[5]) matrix_mult(stack[-1], tmp) draw_lines(tmp, screen, zbuffer, color) tmp = [] elif c == 'move': tmp = make_translate(args[0], args[1], args[2]) matrix_mult(stack[-1], tmp) stack[-1] = [x[:] for x in tmp] tmp = [] elif c == 'scale': tmp = make_scale(args[0], args[1], args[2]) matrix_mult(stack[-1], tmp) stack[-1] = [x[:] for x in tmp] tmp = [] elif c == 'rotate': theta = args[1] * (math.pi / 180) if args[0] == 'x': tmp = make_rotX(theta) elif args[0] == 'y': tmp = make_rotY(theta) else: tmp = make_rotZ(theta) matrix_mult(stack[-1], tmp) stack[-1] = [x[:] for x in tmp] tmp = [] elif c == 'mesh': file_name = command['cs'] + '.obj' f = open(file_name, 'r') vectors = [] polygons = [] result = [] line = f.readline() while line: stuff = line.split() if len(stuff) > 0: if 'v' in stuff[0]: vectors.append([ float(stuff[1]), float(stuff[2]), float(stuff[3]) ]) if stuff[0] == 'f': faces = [] for i in stuff[1:]: faces.append(int(i) - 1) polygons.append(faces) #print(line.strip('\n')) line = f.readline() for poly in polygons: if len(poly) > 3: p0 = vectors[poly[0]] p1 = vectors[poly[1]] p2 = vectors[poly[2]] add_polygon(tmp, p0[0], p0[1], p0[2], p1[0], p1[1], p1[2], p2[0], p2[1], p2[2]) p0 = vectors[poly[0]] p1 = vectors[poly[2]] p2 = vectors[poly[3]] add_polygon(tmp, p0[0], p0[1], p0[2], p1[0], p1[1], p1[2], p2[0], p2[1], p2[2]) else: p0 = vectors[poly[0]] p1 = vectors[poly[1]] p2 = vectors[poly[2]] add_polygon(tmp, p0[0], p0[1], p0[2], p1[0], p1[1], p1[2], p2[0], p2[1], p2[2]) matrix_mult(stack[-1], tmp) if command['constants']: reflect = command['constants'] draw_polygons(tmp, screen, zbuffer, view, ambient, light, symbols, reflect, shading) elif c == 'shading': symbols['shade_type'] = command['shade_type'] elif c == 'push': stack.append([x[:] for x in stack[-1]]) elif c == 'pop': stack.pop() elif c == 'display': display(screen) elif c == 'save': save_extension(screen, args[0])
def run(filename): """ This function runs an mdl script """ p = mdl.parseFile(filename) if p: (commands, symbols) = p else: print "Parsing failed." return view = [0, 0, 1] ambient = [50, 50, 50] light = [[0.5, 0.75, 1], [255, 255, 255]] color = [0, 0, 0] tmp = new_matrix() ident(tmp) systems = [[x[:] for x in tmp]] screen = new_screen() zbuffer = new_zbuffer() tmp = [] step_3d = 100 consts = '' edges = [] polygons = [] symbols['.white'] = [ 'constants', { 'red': [0.2, 0.5, 0.5], 'green': [0.2, 0.5, 0.5], 'blue': [0.2, 0.5, 0.5] } ] reflect = '.white' #print symbols for command in commands: if command['op'] == 'sphere': add_sphere(polygons, float(command['args'][0]), float(command['args'][1]), float(command['args'][2]), float(command['args'][3]), step_3d) matrix_mult(systems[-1], polygons) if command['constants'] == None: reflect = '.white' else: reflect = command['constants'] draw_polygons(polygons, screen, zbuffer, view, ambient, light, symbols, reflect) polygons = [] elif command['op'] == 'torus': #print 'TORUS\t' + str(args) add_torus(polygons, float(command['args'][0]), float(command['args'][1]), float(command['args'][2]), float(command['args'][3]), float(command['args'][4]), step_3d) matrix_mult(systems[-1], polygons) if command['constants'] == None: reflect = '.white' else: reflect = command['constants'] draw_polygons(polygons, screen, zbuffer, view, ambient, light, symbols, reflect) polygons = [] elif command['op'] == 'box': #print 'BOX\t' + str(args) add_box(polygons, float(command['args'][0]), float(command['args'][1]), float(command['args'][2]), float(command['args'][3]), float(command['args'][4]), float(command['args'][5])) matrix_mult(systems[-1], polygons) if command['constants'] == None: reflect = '.white' else: reflect = command['constants'] draw_polygons(polygons, screen, zbuffer, view, ambient, light, symbols, reflect) polygons = [] elif command['op'] == 'circle': #print 'CIRCLE\t' + str(args) add_circle(edges, float(command['args'][0]), float(command['args'][1]), float(command['args'][2]), float(command['args'][3]), step) matrix_mult(systems[-1], edges) draw_lines(edges, screen, zbuffer, color) edges = [] elif command['op'] == 'hermite' or command['op'] == 'bezier': #print 'curve\t' + line + ": " + str(args) add_curve(edges, float(command['args'][0]), float(command['args'][1]), float(command['args'][2]), float(command['args'][3]), float(command['args'][4]), float(command['args'][5]), float(command['args'][6]), float(command['args'][7]), step, line) matrix_mult(systems[-1], edges) draw_lines(edges, screen, zbuffer, color) edges = [] elif command['op'] == 'line': #print 'LINE\t' + str(args) add_edge(edges, float(command['args'][0]), float(command['args'][1]), float(command['args'][2]), float(command['args'][3]), float(command['args'][4]), float(command['args'][5])) matrix_mult(systems[-1], edges) draw_lines(eges, screen, zbuffer, color) edges = [] elif command['op'] == 'scale': #print 'SCALE\t' + str(args) t = make_scale(float(command['args'][0]), float(command['args'][1]), float(command['args'][2])) matrix_mult(systems[-1], t) systems[-1] = [x[:] for x in t] elif command['op'] == 'move': #print 'MOVE\t' + str(args) t = make_translate(float(command['args'][0]), float(command['args'][1]), float(command['args'][2])) matrix_mult(systems[-1], t) systems[-1] = [x[:] for x in t] elif command['op'] == 'rotate': #print 'ROTATE\t' + str(args) theta = float(command['args'][1]) * (math.pi / 180) if command['args'][0] == 'x': t = make_rotX(theta) elif command['args'][0] == 'y': t = make_rotY(theta) else: t = make_rotZ(theta) matrix_mult(systems[-1], t) systems[-1] = [x[:] for x in t] elif command['op'] == 'push': systems.append([x[:] for x in systems[-1]]) elif command['op'] == 'pop': systems.pop() elif command['op'] == 'display' or command['op'] == 'save': if command['op'] == 'display': display(screen) else: save_extension(screen, command['args'][0] + ".png") print command
def run(filename): """ This function runs an mdl script """ view = [0, 0, 1] ambient = [50, 50, 50] light = [[0.5, 0.75, 1], [0, 255, 255]] areflect = [0.1, 0.1, 0.1] dreflect = [0.5, 0.5, 0.5] sreflect = [0.5, 0.5, 0.5] color = [0, 0, 0] tmp = new_matrix() ident(tmp) stack = [[x[:] for x in tmp]] screen = new_screen() zbuffer = new_zbuffer() tmp = [] step_3d = 20 consts = '' coords = [] coords1 = [] p = mdl.parseFile(filename) if p: (commands, symbols) = p else: print "Parsing failed." return first_pass(commands) second_pass(commands) print "Basename:", base print "Num Frames: ", num_frames print symbols for frame in range(int(num_frames)): print frame print symbols for knob in knobs[frame]: symbols[knob][1] = knobs[frame][knob] for command in commands: #print command c = command['op'] args = command['args'] if (not args == None): args = args[:] if (c in ["move", "scale", "rotate"]) and (not args == None) and ( "knob" in command) and (not command["knob"] == None): knob = command["knob"] #print command for i in range(len(args)): if not isinstance(args[i], basestring): args[i] = args[i] * symbols[knob][1] if c == 'box': if isinstance(args[0], str): consts = args[0] args = args[1:] if isinstance(args[-1], str): coords = args[-1] add_box(tmp, args[0], args[1], args[2], args[3], args[4], args[5]) matrix_mult(stack[-1], tmp) draw_polygons(tmp, screen, zbuffer, view, ambient, light, areflect, dreflect, sreflect) tmp = [] elif c == 'sphere': add_sphere(tmp, args[0], args[1], args[2], args[3], step_3d) matrix_mult(stack[-1], tmp) draw_polygons(tmp, screen, zbuffer, view, ambient, light, areflect, dreflect, sreflect) tmp = [] elif c == 'torus': add_torus(tmp, args[0], args[1], args[2], args[3], args[4], step_3d) matrix_mult(stack[-1], tmp) draw_polygons(tmp, screen, zbuffer, view, ambient, light, areflect, dreflect, sreflect) tmp = [] elif c == 'line': if isinstance(args[0], str): consts = args[0] args = args[1:] if isinstance(args[3], str): coords = args[3] args = args[:3] + args[4:] if isinstance(args[-1], str): coords1 = args[-1] add_edge(tmp, args[0], args[1], args[2], args[3], args[4], args[5]) matrix_mult(stack[-1], tmp) draw_lines(tmp, screen, zbuffer, color) tmp = [] elif c == 'move': tmp = make_translate(args[0], args[1], args[2]) matrix_mult(stack[-1], tmp) stack[-1] = [x[:] for x in tmp] tmp = [] elif c == 'scale': tmp = make_scale(args[0], args[1], args[2]) matrix_mult(stack[-1], tmp) stack[-1] = [x[:] for x in tmp] tmp = [] elif c == 'rotate': theta = args[1] * (math.pi / 180) if args[0] == 'x': tmp = make_rotX(theta) elif args[0] == 'y': tmp = make_rotY(theta) else: tmp = make_rotZ(theta) matrix_mult(stack[-1], tmp) stack[-1] = [x[:] for x in tmp] tmp = [] elif c == 'push': stack.append([x[:] for x in stack[-1]]) elif c == 'pop': stack.pop() elif c == 'display': display(screen) elif c == 'save': save_extension(screen, args[0]) if is_anim: save_extension(screen, ("./anim/" + base + ("%03d" % int(frame)) + ".png")) tmp = new_matrix() ident(tmp) stack = [[x[:] for x in tmp]] screen = new_screen() zbuffer = new_zbuffer() tmp = [] step_3d = 20 if is_anim: make_animation(base)
def run(filename): """ This function runs an mdl script """ view = [0, 0, 1] ambient = [50, 50, 50] light = [[0.5, 0.75, 1], [0, 255, 255]] areflect = [0.1, 0.1, 0.1] dreflect = [0.5, 0.5, 0.5] sreflect = [0.5, 0.5, 0.5] color = [0, 0, 0] tmp = new_matrix() ident(tmp) stack = [[x[:] for x in tmp]] screen = new_screen() zbuffer = new_zbuffer() tmp = [] step_3d = 20 consts = '' coords = [] coords1 = [] p = mdl.parseFile(filename) if p: (commands, symbols) = p else: print "Parsing failed." return for command in commands: print command c = command['op'] args = command['args'] if c == 'box': if isinstance(args[0], str): consts = args[0] args = args[1:] if isinstance(args[-1], str): coords = args[-1] add_box(tmp, args[0], args[1], args[2], args[3], args[4], args[5]) matrix_mult(stack[-1], tmp) draw_polygons(tmp, screen, zbuffer, view, ambient, light, areflect, dreflect, sreflect) tmp = [] elif c == 'sphere': add_sphere(tmp, args[0], args[1], args[2], args[3], step_3d) matrix_mult(stack[-1], tmp) draw_polygons(tmp, screen, zbuffer, view, ambient, light, areflect, dreflect, sreflect) tmp = [] elif c == 'torus': add_torus(tmp, args[0], args[1], args[2], args[3], args[4], step_3d) matrix_mult(stack[-1], tmp) draw_polygons(tmp, screen, zbuffer, view, ambient, light, areflect, dreflect, sreflect) tmp = [] elif c == 'cone': add_cone(tmp, args[0], args[1], args[2], args[3], args[4], step_3d) matrix_mult(stack[-1], tmp) draw_polygons(tmp, screen, zbuffer, view, ambient, light, areflect, dreflect, sreflect) tmp = [] elif c == 'coil': add_coil(tmp, args[0], args[1], args[2], args[3], args[4], args[5], args[6], step_3d) matrix_mult(stack[-1], tmp) draw_polygons(tmp, screen, zbuffer, view, ambient, light, areflect, dreflect, sreflect) tmp = [] elif c == 'starburst': add_starburst(tmp, args[0], args[1], args[2], args[3], args[4], args[5], step_3d) matrix_mult(stack[-1], tmp) draw_polygons(tmp, screen, zbuffer, view, ambient, light, areflect, dreflect, sreflect) tmp = [] elif c == 'line': if isinstance(args[0], str): consts = args[0] args = args[1:] if isinstance(args[3], str): coords = args[3] args = args[:3] + args[4:] if isinstance(args[-1], str): coords1 = args[-1] add_edge(tmp, args[0], args[1], args[2], args[3], args[4], args[5]) matrix_mult(stack[-1], tmp) draw_lines(tmp, screen, zbuffer, color) tmp = [] elif c == 'move': tmp = make_translate(args[0], args[1], args[2]) matrix_mult(stack[-1], tmp) stack[-1] = [x[:] for x in tmp] tmp = [] elif c == 'scale': tmp = make_scale(args[0], args[1], args[2]) matrix_mult(stack[-1], tmp) stack[-1] = [x[:] for x in tmp] tmp = [] elif c == 'rotate': theta = args[1] * (math.pi / 180) if args[0] == 'x': tmp = make_rotX(theta) elif args[0] == 'y': tmp = make_rotY(theta) else: tmp = make_rotZ(theta) matrix_mult(stack[-1], tmp) stack[-1] = [x[:] for x in tmp] tmp = [] elif c == 'push': stack.append([x[:] for x in stack[-1]]) elif c == 'pop': stack.pop() elif c == 'display': display(screen) elif c == 'save': save_extension(screen, args[0])
def parse_file( fname, points, transform, screen, color ): one_liners = {'ident': ident, 'apply': matrix_mult, 'display': display} two_liners = {'line': add_edge, 'scale': make_scale, 'move': make_translate, 'rotate': 'make_rot', 'save': save_extension} with open(fname) as file_: file_content = file_.readlines() for line_num, line in enumerate(file_content): line = line.strip() if line[0].isdigit() or file_content[line_num - 1].strip() == 'rotate' or file_content[line_num - 1].strip() == 'save': continue if line in one_liners: if line == 'ident': one_liners[line](transform) elif line == 'apply': one_liners[line](transform, points) else: clear_screen(screen) draw_lines(points, screen, color) one_liners[line](screen) elif line in two_liners: if line == 'line': next_line = file_content[line_num + 1].strip() args = next_line.split(' ') if valid_num_of_args(line_num, args, 6): two_liners[line](points, args[0], args[1], args[2], args[3], args[4], args[5], line_num=line_num) elif line == 'scale': next_line = file_content[line_num + 1].strip() args = next_line.split(' ') if valid_num_of_args(line_num, args, 3): scale_matrix = two_liners[line](args[0], args[1], args[2], line_num=line_num) matrix_mult(scale_matrix, transform) elif line == 'move': next_line = file_content[line_num + 1].strip() args = next_line.split(' ') if valid_num_of_args(line_num, args, 3): translate_matrix = two_liners[line](args[0], args[1], args[2], line_num=line_num) matrix_mult(translate_matrix, transform) elif line == 'rotate': next_line = file_content[line_num + 1].strip() args = next_line.split(' ') if valid_num_of_args(line_num, args, 2): if args[0] in 'xyzXYZ': function = eval(two_liners[line] + args[0].upper()) else: print 'Line ' + str(line_num + 2) + ' provided an invalid axis...' raise SystemExit(1) rotate_matrix = function(args[1], line_num=line_num) matrix_mult(rotate_matrix, transform) elif line == 'save': next_line = file_content[line_num + 1].strip() args = next_line.split(' ') if valid_num_of_args(line_num, args, 1): clear_screen(screen) draw_lines(points, screen, color) display(screen) if args[0].endswith('.png'): two_liners[line](screen, args[0]) else: print 'Invalid filename at line ' + str(line_num + 2) raise SystemExit(1) else: print 'Invalid command found at line ' + str(line_num) raise SystemExit(1)
def parse_file(fname, screen, color): transform = new_matrix() ident(transform) transform = [transform] f = open(fname) lines = f.readlines() step = 0.01 c = 0 while c < len(lines): line = lines[c].strip() #print ':' + line + ':' if line in ARG_COMMANDS: c += 1 args = lines[c].strip().split(' ') if line == 'push': transform.append(transform[len(transform) - 1][:]) if line == 'pop': transform = transform[:-1] if line == 'circle': #print 'CIRCLE\t' + str(args) temp = [] add_circle(temp, float(args[0]), float(args[1]), float(args[2]), float(args[3]), step) matrix_mult(transform[-1], temp) draw_lines(temp, screen, color) elif line == 'hermite' or line == 'bezier': #print 'curve\t' + line + ": " + str(args) temp = [] add_curve(edges, float(args[0]), float(args[1]), float(args[2]), float(args[3]), float(args[4]), float(args[5]), float(args[6]), float(args[7]), step, line) matrix_mult(transform[-1], temp) draw_lines(temp, screen, color) elif line == 'line': #print 'LINE\t' + str(args) temp = [] add_edge(temp, float(args[0]), float(args[1]), float(args[2]), float(args[3]), float(args[4]), float(args[5])) matrix_mult(transform[-1], temp) elif line == 'scale': #print 'SCALE\t' + str(args) t = make_scale(float(args[0]), float(args[1]), float(args[2])) matrix_mult(transform[-1], t) transform[-1] = t elif line == 'move': #print 'MOVE\t' + str(args) t = make_translate(float(args[0]), float(args[1]), float(args[2])) matrix_mult(transform[-1], t) transform[-1] = t elif line == 'rotate': #print 'ROTATE\t' + str(args) theta = float(args[1]) * (math.pi / 180) if args[0] == 'x': t = make_rotX(theta) elif args[0] == 'y': t = make_rotY(theta) else: t = make_rotZ(theta) matrix_mult(transform[-1], t) transform[-1] = t elif line == 'box': for i in range(len(args)): args[i] = int(args[i]) temp = [] add_box(temp, args[0], args[1], args[2], args[3], args[4], args[5]) print len(temp) matrix_mult(transform[-1], temp) draw_polygons(temp, screen, color) elif line == 'torus': for i in range(len(args)): args[i] = int(args[i]) temp = [] add_torus(temp, args[0], args[1], args[2], args[3], args[4], .1) matrix_mult(transform[-1], temp) draw_polygons(temp, screen, color) elif line == 'sphere': for i in range(len(args)): args[i] = int(args[i]) temp = [] add_sphere(temp, args[0], args[1], args[2], args[3], .04999999) matrix_mult(transform[-1], temp) draw_polygons(temp, screen, color) elif line == 'ident': ident(transform) elif line == 'apply': matrix_mult(transform, edges) elif line == 'display' or line == 'save': if line == 'display': display(screen) else: save_extension(screen, args[0]) elif line == 'clear': edges = [[]] c += 1
def parse_file(file, edge, polygons, transform, screen, color): global stack lines = genLines(file) ident(transform) x = 0 while x < len(lines): if lines[x] == "line": p = [int(y) for y in lines[x + 1].split(" ")] add_edge(edge, p[0], p[1], p[2], p[3], p[4], p[5]) matrix_mult(stack[-1], edge) draw_lines(edge, screen, DRAW_COLOR) del edge[:] x += 1 elif lines[x] == "circle": p = [int(y) for y in lines[x + 1].split(" ")] add_circle(edge, p[0], p[1], p[2], p[3], 10000) matrix_mult(stack[-1], edge) draw_lines(edge, screen, DRAW_COLOR) del edge[:] x += 1 elif lines[x] == "triangle": p = [int(y) for y in lines[x + 1].split(" ")] add_polygon(polygons, p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7], p[8]) matrix_mult(stack[-1], polygons) draw_polygons(polygons, screen, DRAW_COLOR) del polygons[:] x += 1 elif lines[x] == "hermite": p = [int(y) for y in lines[x + 1].split(" ")] add_hermite(edge, p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7]) matrix_mult(stack[-1], edge) draw_lines(edge, screen, DRAW_COLOR) del edge[:] x += 1 elif lines[x] == "bezier": p = [int(y) for y in lines[x + 1].split(" ")] add_bezier(edge, p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7]) matrix_mult(stack[-1], edge) draw_lines(edge, screen, DRAW_COLOR) del edge[:] x += 1 elif lines[x] == "torus": p = [int(y) for y in lines[x + 1].split(" ")] add_torus(polygons, p[0], p[1], p[2], p[3], p[4], steps_3d) matrix_mult(stack[-1], polygons) draw_polygons(polygons, screen, DRAW_COLOR) del polygons[:] x += 1 elif lines[x] == "sphere": p = [int(y) for y in lines[x + 1].split(" ")] add_sphere(polygons, p[0], p[1], p[2], p[3], steps_3d) matrix_mult(stack[-1], polygons) draw_polygons(polygons, screen, DRAW_COLOR) del polygons[:] x += 1 elif lines[x] == "box": p = [int(y) for y in lines[x + 1].split(" ")] add_box(polygons, p[0], p[1], p[2], p[3], p[4], p[5]) matrix_mult(stack[-1], polygons) draw_polygons(polygons, screen, DRAW_COLOR) del polygons[:] x += 1 elif lines[x] == "ident": ident(transform) elif lines[x] == "scale": f = [int(y) for y in lines[x + 1].split(" ")] s = [] scale(s, f[0], f[1], f[2]) transform_mult(stack[-1], s) stack[-1] = deepcopy(s) x += 1 elif lines[x] == "move": f = [int(y) for y in lines[x + 1].split(" ")] move = [] translate(move, f[0], f[1], f[2]) transform_mult(stack[-1], move) stack[-1] = deepcopy(move) x += 1 elif lines[x] == "rotate": f = lines[x + 1].split(" ") r = [] rotate(r, f[0], int(f[1])) transform_mult(stack[-1], r) stack[-1] = deepcopy(r) x += 1 elif lines[x] == "push": push(stack) elif lines[x] == "pop": pop(stack) elif lines[x] == "apply": matrix_mult(transform, edge) matrix_mult(transform, polygons) elif lines[x] == "display": display(screen) elif lines[x] == "clear": edge.clear() elif lines[x] == "save": save_extension(screen, lines[x + 1]) print("File name: " + lines[x + 1]) x += 1 elif lines[x] == "stop": return x += 1
def run(filename): """ This function runs an mdl script """ color = [0, 0, 0] tmp = new_matrix() ident(tmp) p = mdl.parseFile(filename) if p: (commands, symbols) = p else: print "Parsing failed." return (name, num_frames) = first_pass(commands) frames = second_pass(commands, num_frames) step = 0.1 for f in range(num_frames): tmp = new_matrix() ident(tmp) stack = [[x[:] for x in tmp]] screen = new_screen() zb = new_zbuffer() tmp = [] if num_frames > 1: frame = frames[f] for knob in frame: symbols[knob][1] = frame[knob] for command in commands: c = command[0] args = command[1:] knob_value = 1 if c == 'set': symbols[args[0]][1] = args[1] elif c == 'set_knobs': for knob in symbols: if symbols[knob][0] == 'knob': symbols[knob][1] = args[0] elif c == 'box': add_box(tmp, args[0], args[1], args[2], args[3], args[4], args[5]) matrix_mult(stack[-1], tmp) draw_polygons(tmp, screen, zb, color) tmp = [] elif c == 'sphere': add_sphere(tmp, args[0], args[1], args[2], args[3], step) matrix_mult(stack[-1], tmp) draw_polygons(tmp, screen, zb, color) tmp = [] elif c == 'torus': add_torus(tmp, args[0], args[1], args[2], args[3], args[4], step) matrix_mult(stack[-1], tmp) draw_polygons(tmp, screen, zb, color) tmp = [] elif c == 'move': if command[-1]: knob_value = symbols[command[-1]][1] tmp = make_translate(args[0] * knob_value, args[1] * knob_value, args[2] * knob_value) matrix_mult(stack[-1], tmp) stack[-1] = [x[:] for x in tmp] tmp = [] elif c == 'scale': if command[-1]: knob_value = symbols[command[-1]][1] tmp = make_scale(args[0] * knob_value, args[1] * knob_value, args[2] * knob_value) matrix_mult(stack[-1], tmp) stack[-1] = [x[:] for x in tmp] tmp = [] elif c == 'rotate': if command[-1]: knob_value = symbols[command[-1]][1] theta = args[1] * (math.pi / 180) * knob_value if args[0] == 'x': tmp = make_rotX(theta) elif args[0] == 'y': tmp = make_rotY(theta) else: tmp = make_rotZ(theta) matrix_mult(stack[-1], tmp) stack[-1] = [x[:] for x in tmp] tmp = [] elif c == 'push': stack.append([x[:] for x in stack[-1]]) elif c == 'pop': stack.pop() elif c == 'display': display(screen) elif c == 'save': save_extension(screen, args[0]) if num_frames > 1: fname = 'anim/%s%03d.png' % (name, f) print 'Saving frame: ' + fname save_extension(screen, fname) if num_frames > 1: make_animation(name)
def run(image): frame = cv2.imread(image) frame = preprocess_image(frame) display([[frame]])
def run(filename): """ This function runs an mdl script """ p = mdl.parseFile(filename) if p: (commands, symbols) = p else: print "Parsing failed." return view = [0, 0, 1]; ambient = [50, 50, 50] light = [[0.5, 0.75, 1], [255, 255, 255]] color = [0, 0, 0] symbols['.white'] = ['constants', {'red': [0.2, 0.5, 0.5], 'green': [0.2, 0.5, 0.5], 'blue': [0.2, 0.5, 0.5]}] reflect = '.white' (name, num_frames) = first_pass(commands) frames = second_pass(commands, num_frames) if num_frames > 1: if not path.exists('anim/' + name): mkdir('anim/' + name) for i in range(num_frames): tmp = new_matrix() ident( tmp ) stack = [ [x[:] for x in tmp] ] screen = new_screen() zbuffer = new_zbuffer() tmp = [] step_3d = 100 consts = '' coords = [] coords1 = [] if num_frames > 1: for knob in frames[i]: symbols[knob][1] = frames[i][knob] for command in commands: print command c = command['op'] args = command['args'] v = 1 if c == 'box': if command['constants']: reflect = command['constants'] add_box(tmp, args[0], args[1], args[2], args[3], args[4], args[5]) matrix_mult( stack[-1], tmp ) draw_polygons(tmp, screen, zbuffer, view, ambient, light, symbols, reflect) tmp = [] reflect = '.white' elif c == 'sphere': if command['constants']: reflect = command['constants'] add_sphere(tmp, args[0], args[1], args[2], args[3], step_3d) matrix_mult( stack[-1], tmp ) draw_polygons(tmp, screen, zbuffer, view, ambient, light, symbols, reflect) tmp = [] reflect = '.white' elif c == 'torus': if command['constants']: reflect = command['constants'] add_torus(tmp, args[0], args[1], args[2], args[3], args[4], step_3d) matrix_mult( stack[-1], tmp ) draw_polygons(tmp, screen, zbuffer, view, ambient, light, symbols, reflect) tmp = [] reflect = '.white' elif c == 'mesh': if command['constants']!=':': reflect = command['constants'] add_mesh(tmp, command['cs']) matrix_mult(stack[-1],tmp) draw_polygons(tmp, screen, zbuffer, view, ambient, light, symbols, reflect) tmp = [] reflect = '.white' elif c == 'line': add_edge(tmp, args[0], args[1], args[2], args[3], args[4], args[5]) matrix_mult( stack[-1], tmp ) draw_lines(tmp, screen, zbuffer, color) tmp = [] elif c == 'move': if command['knob']: v = symbols[command["knob"]][1] tmp = make_translate(args[0] * v, args[1] * v, args[2] * v) matrix_mult(stack[-1], tmp) stack[-1] = [x[:] for x in tmp] tmp = [] elif c == 'scale': if command['knob']: v = symbols[command["knob"]][1] tmp = make_scale(args[0] * v, args[1] * v, args[2] * v) matrix_mult(stack[-1], tmp) stack[-1] = [x[:] for x in tmp] tmp = [] elif c == 'rotate': if command['knob']: v = symbols[command["knob"]][1] theta = args[1] * (math.pi/180) * v if args[0] == 'x': tmp = make_rotX(theta) elif args[0] == 'y': tmp = make_rotY(theta) else: tmp = make_rotZ(theta) matrix_mult( stack[-1], tmp ) stack[-1] = [ x[:] for x in tmp] tmp = [] elif c == 'push': stack.append([x[:] for x in stack[-1]] ) elif c == 'pop': stack.pop() elif c == 'display': display(screen) elif c == 'save': save_extension(screen, args[0]) if num_frames > 1: filename = 'anim/' + name + '/' + name + ('%03d'%i) save_extension(screen, filename) if num_frames > 1: make_animation(name) print symbols
def parse_file(fname, edges, polygons, transform, screen, color): f = open(fname) lines = f.readlines() steps_2d = 100 steps_3d = 20 c = 0 while c < len(lines): line = lines[c].strip() #print ':' + line + ':' if line in ARG_COMMANDS: c += 1 args = lines[c].strip().split(' ') if line == 'sphere': #print 'SPHERE\t' + str(args) add_sphere(polygons, float(args[0]), float(args[1]), float(args[2]), float(args[3]), steps_3d) elif line == 'torus': #print 'TORUS\t' + str(args) add_torus(polygons, float(args[0]), float(args[1]), float(args[2]), float(args[3]), float(args[4]), steps_3d) elif line == 'box': #print 'BOX\t' + str(args) add_box(polygons, float(args[0]), float(args[1]), float(args[2]), float(args[3]), float(args[4]), float(args[5])) elif line == 'circle': #print 'CIRCLE\t' + str(args) add_circle(edges, float(args[0]), float(args[1]), float(args[2]), float(args[3]), steps_2d) elif line == 'hermite' or line == 'bezier': #print 'curve\t' + line + ": " + str(args) add_curve(edges, float(args[0]), float(args[1]), float(args[2]), float(args[3]), float(args[4]), float(args[5]), float(args[6]), float(args[7]), steps_2d, line) elif line == 'line': #print 'LINE\t' + str(args) add_edge(edges, float(args[0]), float(args[1]), float(args[2]), float(args[3]), float(args[4]), float(args[5])) elif line == 'scale': #print 'SCALE\t' + str(args) t = make_scale(float(args[0]), float(args[1]), float(args[2])) matrix_mult(t, transform) elif line == 'move': #print 'MOVE\t' + str(args) t = make_translate(float(args[0]), float(args[1]), float(args[2])) matrix_mult(t, transform) elif line == 'rotate': #print 'ROTATE\t' + str(args) theta = float(args[1]) * (math.pi / 180) if args[0] == 'x': t = make_rotX(theta) elif args[0] == 'y': t = make_rotY(theta) else: t = make_rotZ(theta) matrix_mult(t, transform) elif line == 'ident': ident(transform) elif line == 'apply': matrix_mult(transform, edges) matrix_mult(transform, polygons) elif line == 'clear': edges = [] polygons = [] elif line == 'display' or line == 'save': clear_screen(screen) draw_lines(edges, screen, color) draw_polygons(polygons, screen, color) if line == 'display': display(screen) else: save_extension(screen, args[0]) c += 1
def parse_file(fname, points=[], transform=identity_matrix(), screen=new_screen(), color=[255, 0, 0]): f = open(fname, 'r') script = f.read().split('\n') i = 0 while (i < len(script)): if (script[i] == 'l'): #line #6 parameters: x0, y0, z0, x1, y1, z1 i += 1 p = script[i].split(" ") for j in range(len(p)): p[j] = float(p[j]) if (len(p) != 6): print "add_edge: invalid number of arguments" else: add_edge(points, p[0], p[1], p[2], p[3], p[4], p[5]) elif (script[i] == 'i'): #identity #0 parameters transform = identity_matrix() elif (script[i] == 't'): #translate #3 parameters: x_translation, y_translation, z_translation i += 1 p = script[i].split(" ") for j in range(len(p)): p[j] = float(p[j]) if (len(p) != 3): print "translate: invalid number of arguments" else: transform = matrix_mult(translate(p[0], p[1], p[2]), transform) elif (script[i] == 's'): #scale #3 parameters: x_scale, y_scale, z_scale i += 1 p = script[i].split(" ") for j in range(len(p)): p[j] = float(p[j]) if (len(p) != 3): print "scale: invalid number of arguments" else: transform = matrix_mult(scale(p[0], p[1], p[2]), transform) elif (script[i] == 'x'): #xrot #1 parameter: radians i += 1 transform = matrix_mult(rotX(script[i]), transform) elif (script[i] == 'y'): #yrot #1 parameter: radians i += 1 transform = matrix_mult(rotY(script[i]), transform) elif (script[i] == 'z'): #zrot #1 parameter: radians i += 1 transform = matrix_mult(rotZ(script[i]), transform) elif (script[i] == 'a'): #apply #0 parameters points = matrix_mult(transform, points) elif (script[i] == 'c'): #circle #3 parameters: center_x, center_y, radius i += 1 p = script[i].split(" ") for j in range(len(p)): p[j] = float(p[j]) if (len(p) != 3): print "add_circle: invalid number of arguments" else: add_circle(points, p[0], p[1], 0, p[2], .01) elif (script[i] == 'h'): #hermite #8 parameters: x0, y0, dx0, dy0, x1, y1, dx1, dy1 #(x0, y0) and (x1, y1) - endpoints #(dx1, dy1) and (dx1, dy1) - rates of change at the endpoints i += 1 p = script[i].split(" ") for j in range(len(p)): p[j] = float(p[j]) if (len(p) != 8): print "add_curve: invalid number of arguments" else: add_curve(points, p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7], .01, "hermite") elif (script[i] == 'b'): #bezier #8 parameters: x0, y0, x1, y1, x2, y2, x3, y3 #(x0, y0) and (x3, y3) - endpoints #(x1, y1) and (x2, y2) - points of influence i += 1 p = script[i].split(" ") for j in range(len(p)): p[j] = float(p[j]) if (len(p) != 8): print "add_curve: invalid number of arguments" else: add_curve(points, p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7], .01, "bezier") elif (script[i] == 'v'): #view #0 parameters draw_lines(points, screen, color) pic_name = str(i) + ".ppm" display(screen, pic_name) clear_screen(screen) remove(pic_name) elif (script[i] == 'g'): #guh-save #1 parameter: filename draw_lines(points, screen, color) i += 1 save_extension( screen, script[i] ) #there is some issue here; file extension changed, not actually converting file display(screen, script[i]) clear_screen(screen) elif (script[i] == 'p'): #print #0 parameters print "\nPOINTS:", points, "\n" else: print "parse_file: iteration " + str( i) + ": argument invalid(" + script[i] + ")" i += 1 #go to next line return
def run(filename): """ This function runs an mdl script """ p = mdl.parseFile(filename) if p: (commands, symbols) = p else: print "Parsing failed." return view = [0, 0, 1]; ambient = [50, 50, 50] light = [[0.5, 0.75, 1], [255, 255, 255]] color = [0, 0, 0] symbols['.white'] = ['constants', {'red': [0.2, 0.5, 0.5], 'green': [0.2, 0.5, 0.5], 'blue': [0.2, 0.5, 0.5]}] reflect = '.white' (name, num_frames) = first_pass(commands) frames = second_pass(commands, num_frames) tmp = new_matrix() ident( tmp ) stack = [ [x[:] for x in tmp] ] screen = new_screen() zbuffer = new_zbuffer() tmp = [] step_3d = 100 consts = '' coords = [] coords1 = [] fileNum = 0 print(symbols) for frame in frames: for key in frame.keys(): symbols[key] = frame[key] for command in commands: c = command['op'] args = command['args'] knob_value = 1 if c == 'box': if command['constants']: reflect = command['constants'] add_box(tmp, args[0], args[1], args[2], args[3], args[4], args[5]) matrix_mult( stack[-1], tmp ) draw_polygons(tmp, screen, zbuffer, view, ambient, light, symbols, reflect) tmp = [] reflect = '.white' elif c == 'sphere': if command['constants']: reflect = command['constants'] add_sphere(tmp, args[0], args[1], args[2], args[3], step_3d) matrix_mult( stack[-1], tmp ) draw_polygons(tmp, screen, zbuffer, view, ambient, light, symbols, reflect) tmp = [] reflect = '.white' elif c == 'torus': if command['constants']: reflect = command['constants'] add_torus(tmp, args[0], args[1], args[2], args[3], args[4], step_3d) matrix_mult( stack[-1], tmp ) draw_polygons(tmp, screen, zbuffer, view, ambient, light, symbols, reflect) tmp = [] reflect = '.white' elif c == 'line': add_edge(tmp, args[0], args[1], args[2], args[3], args[4], args[5]) matrix_mult( stack[-1], tmp ) draw_lines(tmp, screen, zbuffer, color) tmp = [] elif c == 'move': knobName = command['knob'] if knobName: tmp = make_translate(args[0]*symbols[knobName], args[1]*symbols[knobName], args[2]*symbols[knobName]) else: tmp = make_translate(args[0], args[1], args[2]) matrix_mult(stack[-1], tmp) stack[-1] = [x[:] for x in tmp] tmp = [] elif c == 'scale': knobName = command['knob'] if knobName: tmp = make_scale(args[0]*symbols[knobName], args[1]*symbols[knobName], args[2]*symbols[knobName]) else: tmp = make_scale(args[0], args[1], args[2]) matrix_mult(stack[-1], tmp) stack[-1] = [x[:] for x in tmp] tmp = [] elif c == 'rotate': knobName = command['knob'] if knobName: theta = args[1] * (math.pi/180) * symbols[knobName] else: theta = args[1] * (math.pi/180) if args[0] == 'x': tmp = make_rotX(theta) elif args[0] == 'y': tmp = make_rotY(theta) else: tmp = make_rotZ(theta) matrix_mult( stack[-1], tmp ) stack[-1] = [ x[:] for x in tmp] tmp = [] elif c == 'push': stack.append([x[:] for x in stack[-1]] ) elif c == 'pop': stack.pop() elif c == 'display': display(screen) elif c == 'save': save_extension(screen, args[0]) # end operation loop save_extension(screen, "anim/" + name+ "_" +"%03d"%fileNum) fileNum += 1 print(fileNum) tmp = new_matrix() ident(tmp) stack = [ [x[:] for x in tmp] ] screen = new_screen() zbuffer = new_zbuffer() make_animation(name)
def third_pass(commands, symbols): global knoblist global basename count = 0 while count < num_frames: #start of outer loop #print(symbols) color = [255, 255, 255] tmp = new_matrix() ident(tmp) ident(tmp) stack = [[x[:] for x in tmp]] screen = new_screen() tmp = [] step = 0.1 for command in commands: c = command[0] args = command[1:] #print args if c == 'box': add_box(tmp, args[0], args[1], args[2], args[3], args[4], args[5]) matrix_mult(stack[-1], tmp) draw_polygons(tmp, screen, color) tmp = [] elif c == 'sphere': add_sphere(tmp, args[0], args[1], args[2], args[3], step) matrix_mult(stack[-1], tmp) draw_polygons(tmp, screen, color) tmp = [] elif c == 'torus': add_torus(tmp, args[0], args[1], args[2], args[3], args[4], step) matrix_mult(stack[-1], tmp) draw_polygons(tmp, screen, color) tmp = [] elif c == 'move': val = 1 if (args[3] != None): knob = args[3] symbols[knob][1] = knoblist[count][knob] val = knoblist[count][knob] tmp = make_translate(args[0] * val, args[1] * val, args[2] * val) matrix_mult(stack[-1], tmp) stack[-1] = [x[:] for x in tmp] tmp = [] elif c == 'scale': val = 1 if (args[3] != None): knob = args[3] symbols[knob][1] = knoblist[count][knob] val = knoblist[count][knob] tmp = make_scale(args[0] * val, args[1] * val, args[2] * val) matrix_mult(stack[-1], tmp) stack[-1] = [x[:] for x in tmp] tmp = [] elif c == 'rotate': val = 1 if (args[2] != None): knob = args[2] symbols[knob][1] = knoblist[count][knob] val = knoblist[count][knob] theta = args[1] * (math.pi / 180) if args[0] == 'x': tmp = make_rotX(theta * val) elif args[0] == 'y': tmp = make_rotY(theta * val) else: tmp = make_rotZ(theta * val) matrix_mult(stack[-1], tmp) stack[-1] = [x[:] for x in tmp] tmp = [] elif c == 'push': stack.append([x[:] for x in stack[-1]]) elif c == 'pop': stack.pop() elif c == 'display': display(screen) #elif c == 'save': if (count < 10): save_extension(screen, "anim/" + basename + "0" + str(count) + ".png") print("Frame saved to: " + basename + "0" + str(count)) else: save_extension(screen, "anim/" + basename + str(count) + ".png") print("Frame saved to: " + basename + str(count)) count += 1
add_edge(matrix, 20, 20, 1, 20, 50, 1) add_edge(matrix, 20, 50, 1, 50, 50, 1) add_edge(matrix, 50, 50, 1, 50, 20, 1) add_edge(matrix, 50, 20, 1, 20, 20, 1) add_edge(matrix, 200, 200, 1, 200, 250, 1) add_edge(matrix, 200, 250, 1, 250, 250, 1) add_edge(matrix, 250, 250, 1, 250, 200, 1) add_edge(matrix, 250, 200, 1, 200, 200, 1) add_edge(matrix, 100, 100, 1, 100, 250, 1) add_edge(matrix, 100, 250, 1, 250, 250, 1) add_edge(matrix, 250, 250, 1, 250, 100, 1) add_edge(matrix, 250, 100, 1, 100, 100, 1) edge[0].extend(matrix[0]) edge[1].extend(matrix[1]) edge[2].extend(matrix[2]) edge[3].extend(matrix[3]) for n in xrange(50): trans_matrix = matrix_mult( matrix_mult(make_translate(x,y,0), make_rotZ(pi/4)), make_translate(-x,-y,0)) edge = matrix_mult(trans_matrix, edge) draw_lines(edge, screen, color) display(screen)
def parse_file(fname, stack, edges, polygons, transform, screen, color): f = open(fname) lines = f.readlines() step = 100 step_3d = 20 c = 0 ''' cs = [] ident1 = new_matrix() print_matrix(ident1) ident(ident1) cs.append(ident1) ''' #print_matrix(cs[0]) while c < len(lines): line = lines[c].strip() #print ':' + line + ':' if line in ARG_COMMANDS: c += 1 args = lines[c].strip().split(' ') #print 'args\t' + str(args) if line == 'sphere': #print 'SPHERE\t' + str(args) add_sphere(polygons, float(args[0]), float(args[1]), float(args[2]), float(args[3]), step_3d) matrix_mult(stack[-1:][0], polygons) draw_polygons(polygons, screen, color) polygons = [] #NEW STUFF --------------- elif line == 'push': push_helper(stack) elif line == 'pop': stack.pop() #\NEW STUFF -------------- elif line == 'torus': #print 'TORUS\t' + str(args) add_torus(polygons, float(args[0]), float(args[1]), float(args[2]), float(args[3]), float(args[4]), step_3d) matrix_mult(stack[-1:][0], polygons) draw_polygons(polygons, screen, color) polygons = [] elif line == 'box': #print 'BOX\t' + str(args) add_box(polygons, float(args[0]), float(args[1]), float(args[2]), float(args[3]), float(args[4]), float(args[5])) matrix_mult(stack[-1:][0], polygons) draw_polygons(polygons, screen, color) polygons = [] elif line == 'circle': #print 'CIRCLE\t' + str(args) add_circle(edges, float(args[0]), float(args[1]), float(args[2]), float(args[3]), step) matrix_mult(stack[-1:][0], edges) draw_lines(edges, screen, color) edges = [] elif line == 'hermite' or line == 'bezier': #print 'curve\t' + line + ": " + str(args) add_curve(edges, float(args[0]), float(args[1]), float(args[2]), float(args[3]), float(args[4]), float(args[5]), float(args[6]), float(args[7]), step, line) matrix_mult(stack[-1:][0], edges) draw_lines(edges, screen, color) edges = [] elif line == 'line': #print 'LINE\t' + str(args) add_edge(edges, float(args[0]), float(args[1]), float(args[2]), float(args[3]), float(args[4]), float(args[5])) matrix_mult(stack[-1:][0], edges) draw_lines(edges, screen, color) edges = [] elif line == 'scale': #print 'SCALE\t' + str(args) t = make_scale(float(args[0]), float(args[1]), float(args[2])) #matrix_mult(t, transform) matrix_mult(stack[-1:][0], t) stack[-1] = t elif line == 'move': #print 'MOVE\t' + str(args) t = make_translate(float(args[0]), float(args[1]), float(args[2])) #matrix_mult(t, transform) matrix_mult(stack[-1:][0], t) stack[-1] = t elif line == 'rotate': #print 'ROTATE\t' + str(args) theta = float(args[1]) * (math.pi / 180) if args[0] == 'x': t = make_rotX(theta) elif args[0] == 'y': t = make_rotY(theta) else: t = make_rotZ(theta) #matrix_mult(t, transform) matrix_mult(stack[-1:][0], t) stack[-1] = t elif line == 'clear': edges = [] polygons = [] elif line == 'ident': ident(transform) elif line == 'apply': matrix_mult(transform, edges) matrix_mult(transform, polygons) elif line == 'display' or line == 'save': #clear_screen(screen) #draw_lines(edges, screen, color) #draw_polygons(polygons, screen, color) if line == 'display': display(screen) else: save_extension(screen, args[0]) c += 1