def __init__(self, frame_width, frame_height, tiles=50): self.tiles = min(50, max(10, tiles)) self.frame_dim = [frame_width, frame_height] # Aspect ratio ar = frame_height / frame_width #aspect_ratio_tr = tr.scale(ar, 1, 0) self.dimensions = [ar * 0.95 * 2 * 4 / 5, 0.95 * 2 * 4 / 5] gpu_tiles = [ es.toGPUShape(bs.createColorQuad(1, 0.91, 0.84)), es.toGPUShape(bs.createColorQuad(0.99, 0.84, 0.61)) ] tiles = [] count = 0 for x in range(self.tiles): tiles.append([]) for y in range(self.tiles): tiles[x].append(sg.SceneGraphNode(f'tile{x}_{y}')) tiles[x][y].transform = tr.matmul([ tr.scale(self.dimensions[0] / self.tiles, self.dimensions[1] / self.tiles, 0), tr.translate(-self.tiles / 2 + x + 0.5, self.tiles / 2 - y - 0.5, 0) ]) tiles[x][y].childs += [gpu_tiles[(x + y) % 2]] board_TR = sg.SceneGraphNode('board_TR') for i in range(len(tiles)): board_TR.childs += tiles[i] self.model = board_TR
def crearfondoNoche(): gpuGrayQuad = es.toGPUShape(bs.createColorQuad(0.1, 0.1, 0.1)) gpuSkyQuad = es.toGPUShape(bs.create2ColorQuad(1,1,1, 0.1451, 0.1569, 0.3137)) gpuGreenQuad = es.toGPUShape(bs.createColorQuad(0.3059,0.651,0.3294)) gpuGrayCirc = es.toGPUShape(bs.create2ColorCircle([0.6941,0.7216,0.7218],[0.8784,0.8902,0.8902])) #Creamos el cielo con un degradado de blanco a azul cielo cielo = sg.SceneGraphNode("cielo") cielo.transform = tr.matmul([tr.translate(0,0.5,0),tr.scale(6,1.75,1)]) cielo.childs += [gpuSkyQuad] #Creamos el camino para el auto asfalto = sg.SceneGraphNode("asfalto") asfalto.transform = tr.matmul([tr.translate(0,-0.75,0),tr.scale(6,0.5,1)]) asfalto.childs += [gpuGrayQuad] #Se crea el pasto que se vera entre los arboles pasto = sg.SceneGraphNode("pasto") pasto.transform = tr.matmul([tr.translate(0,-0.2,0) , tr.scale(6,0.7,1)]) pasto.childs += [gpuGreenQuad] #Creamos una luna en la esquina de la pantalla luna = sg.SceneGraphNode("luna") luna.transform = tr.matmul([tr.translate(1,1,0), tr.uniformScale(0.3)]) luna.childs += [gpuGrayCirc] fondo = sg.SceneGraphNode("fondo") fondo.childs += [cielo, asfalto, pasto, luna] return fondo
def crearfondoDia(): gpuGrayQuad = es.toGPUShape(bs.createColorQuad(0.2, 0.2, 0.2)) gpuSkyQuad = es.toGPUShape(bs.create2ColorQuad(1,1,1, 0.7373, 0.9961, 1)) gpuGreenQuad = es.toGPUShape(bs.createColorQuad(0.6706,1,0.7137)) gpuYellowCirc = es.toGPUShape(bs.create2ColorCircle([1,0.9961,0.4392],[1,1,1])) #Creamos el cielo con un degradado de blanco a celeste cielo = sg.SceneGraphNode("cielo") cielo.transform = tr.matmul([tr.translate(0,0.5,0),tr.scale(6,1.75,1)]) cielo.childs += [gpuSkyQuad] #Creamos el camino para el auto asfalto = sg.SceneGraphNode("asfalto") asfalto.transform = tr.matmul([tr.translate(0,-0.75,0),tr.scale(6,0.5,1)]) asfalto.childs += [gpuGrayQuad] #Se crea el pasto que se vera entre los arboles pasto = sg.SceneGraphNode("pasto") pasto.transform = tr.matmul([tr.translate(0,-0.2,0) , tr.scale(6,0.7,1)]) pasto.childs += [gpuGreenQuad] #Creamos un sol en la esquina de la pantalla sol = sg.SceneGraphNode("sol") sol.transform = tr.matmul([tr.translate(1,1,0), tr.uniformScale(0.3)]) sol.childs += [gpuYellowCirc] fondo = sg.SceneGraphNode("fondo") fondo.childs += [cielo, asfalto, pasto, sol] return fondo
def __init__(self): # Figuras básicas gpu_body_quad = es.toGPUShape(bs.createColorQuad(1, 0.8, 0.8)) # rosado gpu_leg_quad = es.toGPUShape(bs.createColorQuad(1, 0.5, 1)) # rosado fuerte gpu_eye_quad = es.toGPUShape(bs.createColorQuad(1, 1, 1)) # blanco # ... triangulos body = sg.SceneGraphNode('body') body.transform = tr.uniformScale(1) body.childs += [gpu_body_quad] # Creamos las piernas leg = sg.SceneGraphNode('leg') # pierna generica leg.transform = tr.scale(0.25, 0.25, 1) leg.childs += [gpu_leg_quad] # Izquierda leg_izq = sg.SceneGraphNode('legLeft') leg_izq.transform = tr.translate(-0.5, -0.5, 0) # tr.matmul([]).. leg_izq.childs += [leg] leg_der = sg.SceneGraphNode('legRight') leg_der.transform = tr.translate(0.5, -.5, 0) leg_der.childs += [leg] # Ojitos eye = sg.SceneGraphNode('eye') eye.transform = tr.scale(0.25, 0.25, 1) eye.childs += [gpu_eye_quad] eye_izq = sg.SceneGraphNode('eyeLeft') eye_izq.transform = tr.translate(-0.3, 0.5, 0) eye_izq.childs += [eye] eye_der = sg.SceneGraphNode('eyeRight') eye_der.transform = tr.translate(0.3, 0.5, 0) eye_der.childs += [eye] # Ensamblamos el mono mono = sg.SceneGraphNode('chansey') mono.transform = tr.matmul( [tr.scale(0.4, 0.4, 0), tr.translate(0, -1.25, 0)]) mono.childs += [body, leg_izq, leg_der, eye_izq, eye_der] transform_mono = sg.SceneGraphNode('chanseyTR') transform_mono.childs += [mono] self.model = transform_mono self.pos = 0 self.lives = 3 self.killer_eggs = []
def __init__(self): # Figuras básicas gpu_black_back = es.toGPUShape(bs.createColorQuad(0, 0, 0)) gpu_blue_mid = es.toGPUShape(bs.createColorQuad(0, 1, 0.9)) gpu_white_sq = es.toGPUShape(bs.createColorQuad(1, 1, 1)) #creamos un medidor de revoluciones back = sg.SceneGraphNode('back') # cuarto de circulo generico back.transform = tr.scale(0.25, 1, 1) back.childs += [gpu_black_back] blue = sg.SceneGraphNode('blue') blue.transform = tr.scale(0.23, 0.98, 0) blue.childs += [gpu_blue_mid] white = sg.SceneGraphNode('white') white.transform = tr.scale(0.23, 0.18, 1) white.childs += [gpu_white_sq] white1 = sg.SceneGraphNode('white1') white1.transform = tr.translate(0, 0.4, 0) white1.childs += [white] white2 = sg.SceneGraphNode('white2') white2.transform = tr.translate(0, 0.2, 0) white2.childs += [white] white3 = sg.SceneGraphNode('white3') white3.transform = tr.translate(0, 0, 0) white3.childs += [white] white4 = sg.SceneGraphNode('white4') white4.transform = tr.translate(0, -0.2, 0) white4.childs += [white] white5 = sg.SceneGraphNode('white5') white5.transform = tr.translate(0, -0.4, 0) white5.childs += [white] # Ensamblamos el mono alt = sg.SceneGraphNode('alt') alt.transform = tr.matmul( [tr.translate(-0.53, -0.7, 0), tr.scale(0.35, 0.5, 1)]) alt.childs += [back, blue, white1, white2, white3, white4, white5] translate_alt = sg.SceneGraphNode('altTR') translate_alt.childs += [alt] self.model = alt self.pos = 0
def __init__(self, width, height): # Frame dimensions self.width = width self.height = height self.alive = True self.g_over = None # Outer board dimensions self.dimensions = [ 0.5 * self.width * 9 / 16 * 16 / 9 * 2, 0.5 * self.height * 2 * 4 / 5 ] aspect_ratio_tr = tr.scale(self.height / self.width, 1, 0) gpu_bground = es.toGPUShape(bs.createColorQuad(0.05, 0.55, 0.23)) bground = sg.SceneGraphNode('background') bground.transform = tr.matmul([ aspect_ratio_tr, tr.scale(2 * self.width / self.height, 2 * 4 / 5, 0) ]) bground.childs += [gpu_bground] bground_tr = sg.SceneGraphNode('background_TR') bground_tr.childs += [bground] self.model = bground_tr
def create_enemy(bodyColor, wingColor): # Generate enemy model # bodyColor - tuple (r, g, b) # wingColor - tuple (r, g, b) # Body gpuBody = es.toGPUShape(bs.createColorQuad(*bodyColor)) # Wing gpuWing = es.toGPUShape(enemy_wing_shape(*wingColor)) enemyBody = sg.SceneGraphNode("body") enemyBody.childs = [gpuBody] enemyWing1 = sg.SceneGraphNode("wing1") enemyWing1.transform = tr.translate(0.5, 0, 0) enemyWing1.childs = [gpuWing] enemyWing2 = sg.SceneGraphNode("wing2") enemyWing2.transform = tr.matmul( [tr.translate(-0.5, 0, 0), tr.scale(-1, 1, 1)]) enemyWing2.childs = [gpuWing] enemy = sg.SceneGraphNode("enemyModel") enemy.transform = tr.uniformScale(0.08) enemy.childs = [enemyBody, enemyWing1, enemyWing2] return enemy
def crearArbol(): #Se crean las figuras que se utilizaran gpuGreenTriangle = es.toGPUShape(bs.create2ColorTriangle(0.0549, 0.4549, 0.41, 0, 0.8, 0)) gpuBrownQuad = es.toGPUShape(bs.createColorQuad(0.502, 0.251, 0)) #Aqui se crean las partes de la copa del pino copa1 = sg.SceneGraphNode("copa1") copa1.transform = tr.uniformScale(0.5) copa1.childs += [gpuGreenTriangle] copa2 = sg.SceneGraphNode("copa2") copa2.transform = tr.matmul([tr.uniformScale(0.4), tr.translate(0,0.3,0)]) copa2.childs += [gpuGreenTriangle] copa3 = sg.SceneGraphNode("copa3") copa3.transform = tr.matmul([tr.uniformScale(0.3), tr.translate(0,0.8,0)]) copa3.childs += [gpuGreenTriangle] #Aqui se crea el tronco del arbol tronco = sg.SceneGraphNode("tronco") tronco.transform = tr.matmul ([tr.scale(0.1,0.5,0), tr.translate(0, -0.4, 0)]) tronco.childs += [gpuBrownQuad] #Se juntan las partes para crear el arbol arbol = sg.SceneGraphNode("car") arbol.childs += [tronco, copa1, copa2, copa3] return arbol
def create_hp_block(): # Generate hp block on GPU gpuBlock = es.toGPUShape(bs.createColorQuad(0.9, 0.0, 0.1)) hpBlock = sg.SceneGraphNode("HP Block") hpBlock.transform = tr.scale(0.05, 0.1, 1.0) hpBlock.childs = [gpuBlock] return hpBlock
def create_shot(r, g, b): # r,g,b - Red, green and blue values of the shot color gpuShot = es.toGPUShape(bs.createColorQuad(r, g, b)) shot = sg.SceneGraphNode("shot") shot.transform = tr.uniformScale(0.02) shot.childs = [gpuShot] return shot
def createCannon(): gpuGrayQuad = es.toGPUShape(bs.createColorQuad(0.8, 0.8, 0.8)) gpuDarkQuad = es.toGPUShape(bs.createColorQuad(0.3, 0.3, 0.3)) # A cannon is made of a tunnel section and a head tunnel = sg.SceneGraphNode("tunnel") tunnel.transform = tr.scale(0.1, 0.4, 1) tunnel.childs += [gpuGrayQuad] head = sg.SceneGraphNode("head") head.transform = tr.matmul([tr.translate(0, -0.2, 0), tr.uniformScale(0.15)]) head.childs += [gpuDarkQuad] cannon = sg.SceneGraphNode("simpleCannon") cannon.childs += [tunnel] cannon.childs += [head] return cannon
def __init__(self): # Figuras básicas gpu_black_back = es.toGPUShape(bs.createColorQuad(0, 0, 0)) gpu_white_mid = es.toGPUShape(bs.createColorQuad(1, 1, 1)) gpu_black_line = es.toGPUShape(bs.createColorQuad(0, 0, 0)) #creamos un medidor de revoluciones back = sg.SceneGraphNode('back') # cuarto de circulo generico back.transform = tr.scale(1.25, 1, 1) back.childs += [gpu_black_back] white = sg.SceneGraphNode('white') white.transform = tr.scale(1.23, 0.98, 0) white.childs += [gpu_white_mid] line = sg.SceneGraphNode('line') line.transform = tr.scale(1., 0.02, 0) line.childs += [gpu_black_line] line1 = sg.SceneGraphNode('line1') line1.childs += [line] line2 = sg.SceneGraphNode('line2') line2.transform = tr.translate(0, 0.26, 0) line2.childs += [line] line3 = sg.SceneGraphNode('line3') line3.transform = tr.translate(0, -0.26, 0) line3.childs += [line] # Ensamblamos el mono cab = sg.SceneGraphNode('cab') cab.transform = tr.matmul( [tr.translate(0.2, -0.7, 0), tr.uniformScale(0.34)]) cab.childs += [back, white, line1, line2, line3] translate_cab = sg.SceneGraphNode('cabTR') translate_cab.childs += [cab] self.model = cab self.pos = 0
def createBullet(player = True): gpuVariantQuad = es.toGPUShape(bs.createColorQuad(int(player), 1, 0)) littleBullet = sg.SceneGraphNode("littleBullet") littleBullet.transform = tr.matmul([tr.rotationZ(math.pi / 4), tr.uniformScale(0.05)]) littleBullet.childs += [gpuVariantQuad] bullet = sg.SceneGraphNode("bullet") bullet.childs += [littleBullet] return bullet
def __init__(self): gpuBlackQuad = es.toGPUShape(bs.createColorQuad(0, 0, 0)) plataform = sg.SceneGraphNode('plataform') plataform.transform = tr2.scale(0.5, 0.04, 1) plataform.childs += [gpuBlackQuad] plataform_tr = sg.SceneGraphNode('plataformTR') plataform_tr.childs += [plataform] self.model = plataform_tr self.pos_x = 0 self.pos_y = -1
def __init__(self): gpu_egg = es.toGPUShape(bs.createColorQuad(0.7, .7, .7)) egg = sg.SceneGraphNode('egg') egg.transform = tr.scale(0.1, 0.2, 1) egg.childs += [gpu_egg] egg_tr = sg.SceneGraphNode('eggTR') egg_tr.childs += [egg] self.pos_y = 1 self.pos_x = random.choice([-1, 0, 1]) # LOGICA self.model = egg_tr
def createEnemyShot(): gpuRedQuad = es.toGPUShape(bs.createColorQuad(1, 0, 0)) # Creating a single enemy shot enemyShot = sg.SceneGraphNode("enemyShot") enemyShot.transform = tr.matmul([tr.translate(enemyShip.pos_x, enemyShip.pos_y, 0), tr.scale(0.1, 0.3, 0), tr.uniformScale(0.2)]) enemyShot.childs += [gpuRedQuad] enemyShots = sg.SceneGraphNode("enemyShots") enemyShots.childs += [enemyShot] enemyShots.pos_x = enemyShip.pos_x enemyShots.pos_y = enemyShip.pos_y return enemyShots
def createShot(): gpuWhiteQuad = es.toGPUShape(bs.createColorQuad(1, 1, 1)) # Creating a single shot shot = sg.SceneGraphNode("shot") shot.transform = tr.matmul([tr.translate(ship.pos_x, ship.pos_y, 0), tr.scale(0.1, 0.3, 0), tr.uniformScale(0.2)]) shot.childs += [gpuWhiteQuad] shots = sg.SceneGraphNode("shots") shots.childs += [shot] shots.pos_x = ship.pos_x shots.pos_y = ship.pos_y return shots
def __init__(self): # Figuras básicas gpu_red = es.toGPUShape(bs.createColorQuad(1, 0, 0)) gpu_grey = es.toGPUShape(bs.createColorQuad(0.7, 0.7, 0.7)) gpu_dark_blue = es.toGPUShape(bs.createColorQuad(0., 0.1, 0.4)) #creamos un medidor de revoluciones rojo = sg.SceneGraphNode('rojo') # cuarto de circulo generico rojo.transform = tr.matmul( [tr.translate(0.3, 0, 0), tr.uniformScale(0.15)]) rojo.childs += [gpu_red] dblue = sg.SceneGraphNode('dblue') dblue.transform = tr.matmul( [tr.translate(0.3, -0.3, 0), tr.uniformScale(0.15)]) dblue.childs += [gpu_dark_blue] grey = sg.SceneGraphNode('grey') grey.transform = tr.matmul( [tr.translate(0, -0.3, 0), tr.uniformScale(0.15)]) grey.childs += [gpu_grey] # Ensamblamos el mono bot = sg.SceneGraphNode('bot') bot.transform = tr.matmul( [tr.translate(0.65, -0.55, 0), tr.scale(0.7, 1, 1)]) bot.childs += [rojo, dblue, grey] translate_bot = sg.SceneGraphNode('botTR') translate_bot.childs += [bot] self.model = bot self.pos = 0
def __init__(self): gpu_nube = es.toGPUShape(bs.createColorQuad(0.8, 0.8, 0.8)) #creamos una base y altura aleatoria para las montañas base = random.uniform(0.1, 0.5) altura = random.uniform(0.1, 0.5) nube = sg.SceneGraphNode('nube') nube.transform = tr.scale(base, altura, 1) nube.childs += [gpu_nube] nube_tr = sg.SceneGraphNode('nubeTR') nube_tr.childs += [nube] self.pos_x = 2 # LOGICA self.pos_y = random.uniform(0.2, 1.) self.model = nube_tr
def __init__(self, r): gpu_barra = es.toGPUShape(bs.createColorQuad(0.5, 0.5, 0.5)) #creamos un cuadrado barra = sg.SceneGraphNode('barra') #generamos un nodo para el cuadrado barra.transform = tr.scale(0.7,0.1, 1) #lo escalamos al tamaño que queremos barra.childs += [gpu_barra] transform_barra1 = sg.SceneGraphNode('barraTR')# generamos un nodo para el objeto barra transform_barra1.childs += [barra] self.model = transform_barra1 self.pos_y = 1 #con esto se lee el lo que traia el archivo structure.csv y coloca barras en los unos if len(r)!=0: p=r.pop(0) if p[0]=="1": self.pos_x=-0.7 if p[2]=="1": self.pos_x=0 if p[4]=="1": self.pos_x=0.7 self.r=r
def __init__(self, tamaño): self.tamaño = tamaño # Figuras básicas gpu_esquina_quad = es.toGPUShape(bs.createColorQuad(0, 0, 0)) # negro gpu_grilla_quad = es.toGPUShape(bs.createColorQuad(0.9, 0.9, 0.9)) # gris gpu_gameover = es.toGPUShape(bs.createColorQuad(0, 0, 1)) # azul gameover = sg.SceneGraphNode('gameover') gameover.transform = tr.uniformScale(2) gameover.child = [gpu_gameover] esquina_vertical = sg.SceneGraphNode('esquinaVertical') esquina_vertical.transform = tr.scale(d * 4 / self.tamaño, 2, 1) esquina_vertical.childs += [gpu_esquina_quad] esquina_horizontal = sg.SceneGraphNode('esquinaHorizontal') esquina_horizontal.transform = tr.scale(2, d * 4 / self.tamaño, 1) esquina_horizontal.childs += [gpu_esquina_quad] esquina_der = sg.SceneGraphNode('esquinaDerecha') esquina_der.transform = tr.translate(1, 0, 0) esquina_der.childs += [esquina_vertical] esquina_izq = sg.SceneGraphNode('esquinaIzquierda') esquina_izq.transform = tr.translate(-1, 0, 0) esquina_izq.childs += [esquina_vertical] esquina_sup = sg.SceneGraphNode('esquinaIzquierda') esquina_sup.transform = tr.translate(0, 1, 0) esquina_sup.childs += [esquina_horizontal] esquina_inf = sg.SceneGraphNode('esquinaIzquierda') esquina_inf.transform = tr.translate(0, -1, 0) esquina_inf.childs += [esquina_horizontal] cuadrado = sg.SceneGraphNode('cuadrado') cuadrado.transform = tr.uniformScale(d * 2 / self.tamaño) cuadrado.childs += [gpu_grilla_quad] grilla = sg.SceneGraphNode('grilla') grilla.transform = tr.translate(-1 + d * 3 / self.tamaño, 1 - d * 3 / self.tamaño, 1) grilla.childs += [cuadrado] fondo = sg.SceneGraphNode('fondo') baseName = "cuadrado" for i in range(math.ceil(tamaño / 2) - 1): for j in range(tamaño): if j % 2 == 0: x = -1 + d * (3 / self.tamaño + 4 * i / self.tamaño) y = -1 + d * (3 / self.tamaño + 2 * j / self.tamaño) else: x = -1 + d * (5 / self.tamaño + 4 * i / self.tamaño) y = -1 + d * (3 / self.tamaño + 2 * j / self.tamaño) newNode = sg.SceneGraphNode(baseName + str(i)) newNode.transform = tr.translate(x, y, 1) newNode.childs += [cuadrado] fondo.childs += [newNode] fondo.childs += [esquina_der, esquina_izq, esquina_sup, esquina_inf] self.model = fondo
def createCar(r, g, b, foc=False, turbo=False): if not foc: #El proposito de este if es cambiar las luces delanteras del auto, de manera que si foc != False, los focos estan prendidos (amarillos) rf = 0.8 gf = 0.8 bf = 0.8 else: #Aqui se aplica el color amarillo para el caso de que foc no sea False rf = 0.9686 gf = 0.9412 bf = 0 #Se crean las figuras que se utilizaran para la creacion del auto gpuBlackCirc = es.toGPUShape(bs.createCircle([0, 0, 0])) gpuWhiteCirc = es.toGPUShape(bs.createCircle([0.8, 0.8, 0.8])) gpuBlueQuad = es.toGPUShape( bs.createColorQuad(r, g, b) ) #Se dejan los colores como variables para que Don Pedro pueda elegir el color de auto que mas le gusta gpuFocQuad = es.toGPUShape(bs.createColorQuad(rf, gf, bf)) gpuRedQuad = es.toGPUShape(bs.createColorQuad(1, 0, 0)) gpuSBQuad = es.toGPUShape(bs.createColorQuad(0.5922, 0.9569, 1)) #Se crea la parte interna de la rueda de color blanco little_wheel = sg.SceneGraphNode("little_wheel") little_wheel.transform = tr.uniformScale(0.08) little_wheel.childs += [gpuWhiteCirc] # Se crea la parte negra de la rueda (la más externa) big_wheel = sg.SceneGraphNode("big_wheel") big_wheel.transform = tr.uniformScale(0.2) big_wheel.childs += [gpuBlackCirc] #Se crea la rueda completa compuesta de las dos partes anteriores wheel = sg.SceneGraphNode("wheel") wheel.childs += [big_wheel, little_wheel] wheelRotation = sg.SceneGraphNode("wheelRotation") wheelRotation.childs += [wheel] # Se instalan las dos ruedas en el auto frontWheel = sg.SceneGraphNode("frontWheel") frontWheel.transform = tr.translate(0.5, -0.3, 0) frontWheel.childs += [wheelRotation] backWheel = sg.SceneGraphNode("backWheel") backWheel.transform = tr.translate(-0.5, -0.3, 0) backWheel.childs += [wheelRotation] # Se crear el chasis del auto chasis = sg.SceneGraphNode("chasis") chasis.transform = tr.scale(1.8, 0.5, 1) chasis.childs += [gpuBlueQuad] #Se crea el techo del auto techo = sg.SceneGraphNode("techo") techo.transform = tr.matmul( [tr.translate(0, 0.45, 0), tr.scale(1, 0.5, 1)]) techo.childs += [gpuBlueQuad] #Se crea el foco trasero foco_tras = sg.SceneGraphNode("foco_tras") foco_tras.transform = tr.matmul( [tr.translate(-0.86, 0.21, 0), tr.scale(0.08, 0.08, 1)]) foco_tras.childs += [gpuRedQuad] #Se crea el foco delantero foco_del = sg.SceneGraphNode("foco_del") foco_del.transform = tr.matmul( [tr.translate(0.86, 0.21, 0), tr.scale(0.08, 0.08, 1)]) foco_del.childs += [gpuFocQuad] #Se crean las ventanas del auto vent_der = sg.SceneGraphNode("vent_der") vent_der.transform = tr.matmul( [tr.translate(0.23, 0.45, 0), tr.scale(0.38, 0.37, 1)]) vent_der.childs += [gpuSBQuad] vent_izq = sg.SceneGraphNode("vent_izq") vent_izq.transform = tr.matmul( [tr.translate(-0.23, 0.45, 0), tr.scale(0.38, 0.37, 1)]) vent_izq.childs += [gpuSBQuad] #Se creal auto compuesto de todas las partes anteriormente creadas car = sg.SceneGraphNode("car") car.childs += [ chasis, techo, frontWheel, backWheel, foco_tras, foco_del, vent_der, vent_izq ] #Se traslada y escala el auto scaledCar = sg.SceneGraphNode("scaledCar") scaledCar.transform = tr.matmul( [tr.translate(0, -0.66, 0), tr.uniformScale(0.15)]) scaledCar.childs += [car] #Se crean las figras que se utilizaran para el turbo gpuGrayOv = es.toGPUShape(bs.createSemiCircle([0.7, 0.7, 0.7])) gpuBlackC = es.toGPUShape(bs.createCircle([0.2, 0.2, 0.2])) gpuRYC = es.toGPUShape( bs.create2ColorCircle([1, 0, 0], [1, 0.9961, 0.4392])) #La base de la turbina base = sg.SceneGraphNode("base") base.transform = tr.matmul( [tr.rotationZ(-np.pi / 2), tr.scale(0.04, 0.17, 1)]) base.childs += [gpuGrayOv] baseTr = sg.SceneGraphNode("baseTr") baseTr.transform = tr.translate(-0.07, -0.515, 0) baseTr.childs += [base] #Se crea la parte trasera de la turbina en conjunto con el "fuego" que lo impulsa fin = sg.SceneGraphNode("fin") fin.transform = tr.matmul( [tr.translate(-0.07, -0.515, 0), tr.scale(0.02, 0.04, 1)]) fin.childs += [gpuBlackC] fuego = sg.SceneGraphNode("fuego") fuego.transform = tr.matmul( [tr.translate(-0.07, -0.515, 0), tr.scale(0.01, 0.03, 1)]) fuego.childs = [gpuRYC] #Se crea la turbina turboT = sg.SceneGraphNode("turbo") turboT.childs += [baseTr, fin, fuego] #Creamos una figura que va a ir cambiando los childs dependiendo de si el turbo esta activo o no autoFinal = sg.SceneGraphNode("autoFinal") autoFinal.childs += [] if turbo == False: #en el caso de que el turbo este desactivado se crea solo el auto escalado y trasladado autoFinal.childs = [scaledCar] elif turbo == True: #cuando la turbina esta activa el auto se compone de la turbina y el auto escalado autoFinal.childs = [turboT, scaledCar] else: autoFinal.childs = [] return autoFinal
def createShip(): gpuWhiteQuad = es.toGPUShape(bs.createColorQuad(1, 1, 1)) gpuGreyTriangle = es.toGPUShape(bs.createColorTriangle(0.5, 0.5, 0.5)) gpuOrangeTriangle = es.toGPUShape(bs.createColorTriangle(1, 112 / 255, 40 / 255)) gpuYellowTriangle = es.toGPUShape(bs.createColorTriangle(1, 1, 0)) gpuRedTriangle = es.toGPUShape(bs.createColorTriangle(1, 0, 0)) # Creating a single orange flame orangeFlame = sg.SceneGraphNode("orangeFlame") orangeFlame.transform = tr.matmul([tr.rotationZ(np.pi), tr.uniformScale(0.1)]) orangeFlame.childs += [gpuOrangeTriangle] # Instanciating 6 orange flames, for the wings and back parts backLeftOrangeFlame = sg.SceneGraphNode("backLeftOrangeFlame") backLeftOrangeFlame.transform = tr.translate(-0.11,-0.55, 0.0 ) backLeftOrangeFlame.childs += [orangeFlame] backRightOrangeFlame = sg.SceneGraphNode("backRightOrangeFlame") backRightOrangeFlame.transform = tr.translate(0.11, -0.55, 0.0) backRightOrangeFlame.childs += [orangeFlame] leftWingLeftOrangeFlame = sg.SceneGraphNode("leftWingLeftOrangeFlame") leftWingLeftOrangeFlame.transform = tr.matmul([tr.translate(-0.45, -0.07, 0.0), tr.uniformScale(0.5)]) leftWingLeftOrangeFlame.childs += [orangeFlame] leftWingRightOrangeFlame = sg.SceneGraphNode("leftWingRightOrangeFlame") leftWingRightOrangeFlame.transform = tr.matmul([tr.translate(-0.3, -0.07, 0.0), tr.uniformScale(0.5)]) leftWingRightOrangeFlame.childs += [orangeFlame] rightWingLeftOrangeFlame = sg.SceneGraphNode("rightWingLeftOrangeFlame") rightWingLeftOrangeFlame.transform = tr.matmul([tr.translate(0.3, -0.07, 0.0), tr.uniformScale(0.5)]) rightWingLeftOrangeFlame.childs += [orangeFlame] rightWingRightOrangeFlame = sg.SceneGraphNode("rightWingRightOrangeFlame") rightWingRightOrangeFlame.transform = tr.matmul([tr.translate(0.45, -0.07, 0.0), tr.uniformScale(0.5)]) rightWingRightOrangeFlame.childs += [orangeFlame] # Creating a single yellow flame yellowFlame = sg.SceneGraphNode("yellowFlame") yellowFlame.transform = tr.matmul([tr.rotationZ(np.pi), tr.uniformScale(0.2)]) yellowFlame.childs += [gpuYellowTriangle] # Instanciating 6 yellow flames, for the wings and back parts backLeftYellowFlame = sg.SceneGraphNode("backLeftYellowFlame") backLeftYellowFlame.transform = tr.translate(-0.11, -0.6, 0.0) backLeftYellowFlame.childs += [yellowFlame] backRightYellowFlame = sg.SceneGraphNode("backRightYellowFlame") backRightYellowFlame.transform = tr.translate(0.11, -0.6, 0.0) backRightYellowFlame.childs += [yellowFlame] leftWingLeftYellowFlame = sg.SceneGraphNode("leftWingLeftYellowFlame") leftWingLeftYellowFlame.transform = tr.matmul([tr.translate(-0.45, -0.1, 0.0), tr.uniformScale(0.5)]) leftWingLeftYellowFlame.childs += [yellowFlame] leftWingRightYellowFlame = sg.SceneGraphNode("leftWingRightYellowFlame") leftWingRightYellowFlame.transform = tr.matmul([tr.translate(-0.3, -0.1, 0.0), tr.uniformScale(0.5)]) leftWingRightYellowFlame.childs += [yellowFlame] rightWingLeftYellowFlame = sg.SceneGraphNode("rightWingLeftYellowFlame") rightWingLeftYellowFlame.transform = tr.matmul([tr.translate(0.3, -0.1, 0.0), tr.uniformScale(0.5)]) rightWingLeftYellowFlame.childs += [yellowFlame] rightWingRightYellowFlame = sg.SceneGraphNode("rightWingRightYellowFlame") rightWingRightYellowFlame.transform = tr.matmul([tr.translate(0.45, -0.1, 0.0), tr.uniformScale(0.5)]) rightWingRightYellowFlame.childs += [yellowFlame] # Creating a single wing wing = sg.SceneGraphNode("wing") wing.transform = tr.matmul([tr.translate(0, 0.3, 0), tr.scale(1.1, 0.7, 1)]) wing.childs += [gpuGreyTriangle] # Creating the upper part upper = sg.SceneGraphNode("upper") upper.transform = tr.matmul([tr.translate(0, 0.7, 0), tr.uniformScale(0.5)]) upper.childs += [gpuRedTriangle] # Creating the chasis of the ship chasis = sg.SceneGraphNode("chasis") chasis.transform = tr.scale(0.5, 1, 1) chasis.childs += [gpuWhiteQuad] ship = sg.SceneGraphNode("ship") ship.transform = tr.matmul([tr.translate(0, -0.8, 0), tr.uniformScale(0.2)]) ship.childs += [backLeftYellowFlame] ship.childs += [backRightYellowFlame] ship.childs += [leftWingLeftYellowFlame] ship.childs += [leftWingRightYellowFlame] ship.childs += [rightWingLeftYellowFlame] ship.childs += [rightWingRightYellowFlame] ship.childs += [backLeftOrangeFlame] ship.childs += [backRightOrangeFlame] ship.childs += [leftWingLeftOrangeFlame] ship.childs += [leftWingRightOrangeFlame] ship.childs += [rightWingLeftOrangeFlame] ship.childs += [rightWingRightOrangeFlame] ship.childs += [wing] ship.childs += [upper] ship.childs += [chasis] translatedShip = sg.SceneGraphNode("translatedShip") translatedShip.childs += [ship] translatedShip.pos_x = controller.x translatedShip.pos_y = controller.y return translatedShip
def createEnemyShip(): gpuGreenQuad = es.toGPUShape(bs.createColorQuad(0, 1, 0)) gpuBlueTriangle = es.toGPUShape(bs.createColorTriangle(0, 0, 1)) gpuGreyTriangle = es.toGPUShape(bs.createColorTriangle(0.5, 0.5, 0.5)) gpuOrangeTriangle = es.toGPUShape(bs.createColorTriangle(1, 112 / 255, 40 / 255)) gpuYellowTriangle = es.toGPUShape(bs.createColorTriangle(1, 1, 0)) # Creating a single orange flame orangeFlame = sg.SceneGraphNode("orangeFlame") orangeFlame.transform = tr.matmul([tr.rotationZ(np.pi), tr.uniformScale(0.1)]) orangeFlame.childs += [gpuOrangeTriangle] # Instanciating 2 orange flames, for the back part backLeftOrangeFlame = sg.SceneGraphNode("backLeftOrangeFlame") backLeftOrangeFlame.transform = tr.translate(-0.11, -0.35, 0.0) backLeftOrangeFlame.childs += [orangeFlame] backRightOrangeFlame = sg.SceneGraphNode("backRightOrangeFlame") backRightOrangeFlame.transform = tr.translate(0.11, -0.35, 0.0) backRightOrangeFlame.childs += [orangeFlame] # Creating a single yellow flame yellowFlame = sg.SceneGraphNode("yellowFlame") yellowFlame.transform = tr.matmul([tr.rotationZ(np.pi), tr.uniformScale(0.2)]) yellowFlame.childs += [gpuYellowTriangle] # Instanciating 2 yellow flames, for the back part backLeftYellowFlame = sg.SceneGraphNode("backLeftYellowFlame") backLeftYellowFlame.transform = tr.translate(-0.11, -0.4, 0.0) backLeftYellowFlame.childs += [yellowFlame] backRightYellowFlame = sg.SceneGraphNode("backRightYellowFlame") backRightYellowFlame.transform = tr.translate(0.11, -0.4, 0.0) backRightYellowFlame.childs += [yellowFlame] # Creating the back part back = sg.SceneGraphNode("wing") back.transform = tr.uniformScale(0.7) back.childs += [gpuGreyTriangle] # Creating the upper part upper = sg.SceneGraphNode("upper") upper.transform = tr.matmul([tr.translate(0, 0.5, 0), tr.uniformScale(0.5)]) upper.childs += [gpuBlueTriangle] # Creating the chasis of the ship chasis = sg.SceneGraphNode("chasis") chasis.transform = tr.uniformScale(0.5) chasis.childs += [gpuGreenQuad] enemyShip = sg.SceneGraphNode("enemyShip") enemyShip.transform = tr.matmul([tr.translate(0, 2, 0), tr.rotationZ(np.pi), tr.uniformScale(0.2)]) enemyShip.childs += [backLeftYellowFlame] enemyShip.childs += [backRightYellowFlame] enemyShip.childs += [backLeftOrangeFlame] enemyShip.childs += [backRightOrangeFlame] enemyShip.childs += [back] enemyShip.childs += [upper] enemyShip.childs += [chasis] translatedEnemyShip = sg.SceneGraphNode("translatedEnemyShip") translatedEnemyShip.childs += [enemyShip] translatedEnemyShip.pos_x = 1 translatedEnemyShip.pos_y = 2 return translatedEnemyShip
def crearEntorno(): gpuGreenTriangle = es.toGPUShape( bs.create2ColorTriangle(0.3059, 0.7804, 0, 0.6706, 1, 0.7137)) gpuGrayQuad = es.toGPUShape(bs.createColorQuad(0.5, 0.5, 0.5)) gpuGreenQuad = es.toGPUShape(bs.createColorQuad(0.3529, 1, 0.5659)) #Se crea un pequeño pastito #pastito = sg.SceneGraphNode("pastito") #pastito.transform = tr.uniformScale(0.08) #pastito.childs += [gpuGreenTriangle] #pastitos = sg.SceneGraphNode("pastitos") #baseName="pastitos" #for i in range(-24,25): #se crea este for para hacer una fila de pastitos # A new node is only locating a scaledCar in the scene depending on index i #newNode = sg.SceneGraphNode(baseName + str(i)) #newNode.transform = tr.translate(0.04 * i, 0, 0) #newNode.childs += [pastito] # Now this car is added to the 'cars' scene graph #pastitos.childs += [newNode] #pastitos2 = sg.SceneGraphNode("pastitos2") #baseName="pastitos2" #for i in range(-15,12): #el objetivo de este for es multiplicar las filas de pastitos #newNode = sg.SceneGraphNode(baseName + str(i)) #newNode.transform = tr.translate(0.01*(-1)**i,-0.02*i , 0) #newNode.childs += [pastitos] #pastitos2.childs += [newNode] #Toda la parte comentada era mi idea de hacer un pasto mas "realista" con los materiales que hemos visto hasta el #momento pero era mucho trabajo para el computador por lo que la imagen estaba cortada cuando se reproducía #Esta es la opcion B del pasto pasto = sg.SceneGraphNode("pasto") pasto.transform = tr.matmul( [tr.translate(0, -0.035, 0), tr.scale(2, 0.45, 1)]) pasto.childs += [gpuGreenQuad] #Se crea el muro de la derecha murod = sg.SceneGraphNode("murod") murod.transform = tr.matmul( [tr.translate(1, 0.04, 0), tr.scale(0.08, 0.6, 1)]) murod.childs += [gpuGrayQuad] #Se crea el muro de la izquierda muroi = sg.SceneGraphNode("muroi") muroi.transform = tr.matmul( [tr.translate(-1, 0.04, 0), tr.scale(0.08, 0.6, 1)]) muroi.childs += [gpuGrayQuad] #Se crea el muro de la divisor murodiv = sg.SceneGraphNode("murodiv") murodiv.transform = tr.matmul( [tr.translate(0, 0.04, 0), tr.scale(0.08, 0.6, 1)]) murodiv.childs += [gpuGrayQuad] #Se crea el muro trasero murot = sg.SceneGraphNode("murot") murot.transform = tr.matmul( [tr.translate(0, 0.09, 0), tr.scale(2, 0.5, 1)]) murot.childs += [gpuGrayQuad] entorno = sg.SceneGraphNode("entorno") entorno.childs += [murot, pasto, murod, muroi, murodiv] return entorno
def crearNave(): gpuBCirc = es.toGPUShape(bs.createCircle([0,0.4627,0.4118])) gpuBlackCirc = es.toGPUShape(bs.createCircle([0,0,0])) gpuSBCirc = es.toGPUShape(bs.createSemiCircle([0,0,0])) gpuSGreenCirc = es.toGPUShape(bs.createSemiCircle([0.4392,1,0.4078])) gpuGreenCirc = es.toGPUShape(bs.createCircle([0.4392,1,0.4078])) gpuBlackQuad = es.toGPUShape(bs.createColorQuad(0,0,0)) gpuGreenQuad = es.toGPUShape(bs.createColorQuad(0.4392,1,0.4078)) #Se crea la parte mas grande de la nave (asi como el chasis de auto) base = sg.SceneGraphNode("base") base.transform = tr.scale(0.5,0.08,0) base.childs += [gpuBCirc] #Creamos el "vidrio" de la nave, que es la parte donde podemos ver al marcianito, se crea negro para que sea mas facil ver la nave #y al marciano debido a que con los colores del fondo la nave se pierde vidrio = sg.SceneGraphNode("vidrio") vidrio.transform = tr.matmul([tr.translate(0,0.02,0),tr.scale(0.2,0.35,0)]) vidrio.childs += [gpuSBCirc] #Se crean las patas de la nave, compuestas por una bolita negra y un rectangulo del mismo color pataIzq = sg.SceneGraphNode("pataIzq") pataIzq.transform = tr.matmul([tr.rotationZ(np.pi/5) ,tr.scale(0.02,0.25,0)]) pataIzq.childs += [gpuBlackQuad] pataDer = sg.SceneGraphNode("pataDer") pataDer.transform = tr.matmul([tr.rotationZ(-(np.pi/5)) ,tr.scale(0.02,0.25,0)]) pataDer.childs += [gpuBlackQuad] pataItras = sg.SceneGraphNode("pataItras") pataItras.transform = tr.translate(0.3,-0.1,0) pataItras.childs += [pataIzq] pataDtras = sg.SceneGraphNode("pataDtras") pataDtras.transform = tr.translate(-0.3,-0.1,0) pataDtras.childs += [pataDer] finPataI = sg.SceneGraphNode("finPataI") finPataI.transform = tr.matmul([tr.translate(0.375,-0.2,0) ,tr.uniformScale(0.025)]) finPataI.childs += [gpuBlackCirc] finPataD = sg.SceneGraphNode("finPataD") finPataD.transform = tr.matmul([tr.translate(-0.375,-0.2,0) ,tr.uniformScale(0.025)]) finPataD.childs += [gpuBlackCirc] pataD = sg.SceneGraphNode("pataD") pataD.childs += [pataDtras, finPataD] pataI = sg.SceneGraphNode("pataI") pataI.childs += [pataItras, finPataI] #Creamos al marcianito #Se crea primero el cuerpo cuerpoTripulacion = sg.SceneGraphNode("cuerpoTripulacion") cuerpoTripulacion.transform = tr.matmul([tr.translate(0,0.02,0), tr.scale(0.03,0.06,0)]) cuerpoTripulacion.childs += [gpuSGreenCirc] #Creamos la cabeza cabezaTripulacion = sg.SceneGraphNode("cabezaTripulacion") cabezaTripulacion.transform = tr.matmul([tr.translate(0,0.12,0) , tr.uniformScale(0.04)]) cabezaTripulacion.childs += [gpuGreenCirc] #Aqui creamos las antenas completas del marcianito, con una idea muy parecida a las patas de la nave antenaD = sg.SceneGraphNode("antenaD") antenaD.transform = tr.matmul([tr.translate(0.017,0.165,0) ,tr.scale(0.01,0.025,0)]) antenaD.childs += [gpuGreenQuad] antenaI = sg.SceneGraphNode("antenaI") antenaI.transform = tr.matmul([tr.translate(-0.017,0.165,0),tr.scale(0.01,0.025,0)]) antenaI.childs += [gpuGreenQuad] finAnD = sg.SceneGraphNode("finAnD") finAnD.transform = tr.matmul([tr.translate(0.017,0.19,0) , tr.uniformScale(0.015)]) finAnD.childs = [gpuGreenCirc] finAnI = sg.SceneGraphNode("finAnI") finAnI.transform = tr.matmul([tr.translate(-0.017,0.19,0) , tr.uniformScale(0.015)]) finAnI.childs = [gpuGreenCirc] #Se crea la nave en conjunto con la tripulacion nave = sg.SceneGraphNode("nave") nave.transform = tr.matmul([tr.translate(0,0.7,0) , tr.uniformScale(0.1)]) nave.childs += [pataI, pataD, base, vidrio, cuerpoTripulacion, cabezaTripulacion, antenaD, antenaI, finAnD, finAnI] #Se crea esto para luego poder trasladar la nave en la parte final navef = sg.SceneGraphNode("navef") navef.childs += [nave] return navef
def __init__(self): # Figuras básicas gpu_quarter_circle = es.toGPUShape(bs.createQuarterCircle()) gpu_indicator_line = es.toGPUShape(bs.createColorQuad(1.0, 1.0, 1.0)) gpu_center = es.toGPUShape(bs.createColorQuad(1, 1, 1)) #creamos un medidor de revoluciones qvel = sg.SceneGraphNode('qvel') # cuarto de circulo generico qvel.transform = tr.scale(0.25, 0.25, 1) qvel.childs += [gpu_quarter_circle] q1vel = sg.SceneGraphNode('q1vel') q1vel.childs += [qvel] q2vel = sg.SceneGraphNode('q2vel') q2vel.transform = tr.rotationZ(1.57) q2vel.childs += [qvel] q3vel = sg.SceneGraphNode('q3vel') q3vel.transform = tr.rotationZ(3.14) q3vel.childs += [qvel] q4vel = sg.SceneGraphNode('q4vel') q4vel.transform = tr.rotationZ(-1.57) q4vel.childs += [qvel] #un centro centro = sg.SceneGraphNode('centro') centro.transform = tr.uniformScale(0.02) centro.childs += [gpu_center] #hacemos los grados raya = sg.SceneGraphNode('raya') raya.childs += [gpu_indicator_line] raya1 = sg.SceneGraphNode('raya1') raya1.transform = tr.matmul( [tr.translate(0, 0.21, 0), tr.scale(0.005, 0.08, 1)]) raya1.childs += [raya] raya2 = sg.SceneGraphNode('raya2') raya2.transform = tr.matmul([ tr.translate(0.206, 0, 0), tr.rotationZ(1.58), tr.scale(0.005, 0.08, 1) ]) raya2.childs += [raya] raya3 = sg.SceneGraphNode('raya3') raya3.transform = tr.matmul([ tr.translate(-0.206, 0, 0), tr.rotationZ(1.58), tr.scale(0.005, 0.08, 1) ]) raya3.childs += [raya] raya4 = sg.SceneGraphNode('raya4') raya4.transform = tr.matmul([ tr.translate(-0.15, 0.15, 0), tr.rotationZ(0.5), tr.scale(0.005, 0.08, 1) ]) raya4.childs += [raya] raya5 = sg.SceneGraphNode('raya5') raya5.transform = tr.matmul([ tr.translate(0.15, 0.15, 0), tr.rotationZ(-0.5), tr.scale(0.005, 0.08, 1) ]) raya5.childs += [raya] raya6 = sg.SceneGraphNode('raya6') raya6.transform = tr.matmul([ tr.translate(0.15, -0.15, 0), tr.rotationZ(0.5), tr.scale(0.005, 0.08, 1) ]) raya6.childs += [raya] raya7 = sg.SceneGraphNode('raya7') raya7.transform = tr.matmul([ tr.translate(-0.15, -0.15, 0), tr.rotationZ(-0.5), tr.scale(0.005, 0.08, 1) ]) raya7.childs += [raya] # Ensamblamos el mono rev = sg.SceneGraphNode('rev') rev.transform = tr.matmul( [tr.translate(-0.25, -0.7, 0), tr.scale(0.7, 1, 1)]) rev.childs += [ q1vel, q2vel, q3vel, q4vel, centro, raya1, raya2, raya3, raya4, raya5, raya6, raya7 ] translate_rev = sg.SceneGraphNode('revTR') translate_rev.childs += [rev] self.model = rev self.pos = 0
def __init__(self): #creamos el avion # Figuras básicas gpu_body_quad = es.toGPUShape(bs.createColorQuad(0.65, 0.65, 0.65)) # gris gpu_tail_triangle = es.toGPUShape( bs.createColorTriangle(0.65, 0.65, 0.65)) # gris gpu_nose_triangle = es.toGPUShape( bs.createColorTriangle(0.65, 0.65, 0.65)) # gris gpu_wing_quad = es.toGPUShape(bs.createColorQuad(1, 0.5, 0.5)) # gris oscuro gpu_window_quad = es.toGPUShape(bs.createColorQuad(0, 1, 0.86)) # celeste #creamos el "cuerpo" body = sg.SceneGraphNode('body') body.transform = tr.scale(2.5, 0.7, 1) #alargamos el "cuerpo" del avion body.childs += [gpu_body_quad] # Creamos las ventanas window = sg.SceneGraphNode('window') # ventana generica window.transform = tr.scale(0.25, 0.25, 1) window.childs += [gpu_window_quad] # prueba dos ventanas window_1 = sg.SceneGraphNode('window_1') window_1.transform = tr.translate(1, 0.14, 0) # tr.matmul([]).. window_1.childs += [window] window_2 = sg.SceneGraphNode('window_2') window_2.transform = tr.translate(0.65, 0.14, 0) # tr.matmul([]).. window_2.childs += [window] window_3 = sg.SceneGraphNode('window_3') window_3.transform = tr.translate(0.3, 0.14, 0) # tr.matmul([]).. window_3.childs += [window] # cola tail = sg.SceneGraphNode('tail') #ventana generica tail.transform = tr.rotationZ( 0.46 ) #dejamos el borde trasero del triangulo ortogonal al cuerpo uwu tail.childs += [gpu_tail_triangle] tail_back = sg.SceneGraphNode('eyeLeft') tail_back.transform = tr.matmul( [tr.translate(-1.0092, 0.4, 0), tr.scale(1.1, 1.1, 0)]) tail_back.childs += [tail] # nariz nose = sg.SceneGraphNode('nose') #ventana generica nose.transform = tr.matmul([ tr.rotationZ(0.465), tr.translate(1.26, -0.55, 0), tr.scale(0.64, 0.64, 0) ]) nose.childs += [gpu_nose_triangle] #ala wing = sg.SceneGraphNode('wing') wing.transform = tr.matmul([ tr.rotationZ(-0.55), tr.translate(0.1, -0.5, 0), tr.scale(0.3, 1, 0) ]) wing.childs += [gpu_wing_quad] self.a = 0 #indica la aceleración del avión # Ensamblamos el mono mono = sg.SceneGraphNode('chansey') mono.transform = tr.matmul( [tr.scale(0.1, 0.2, 0), tr.translate(-8, -1.6, 0)]) mono.childs += [ body, window_1, window_2, window_3, tail_back, nose, wing ] transform_mono = sg.SceneGraphNode('chanseyTR') transform_mono.childs += [mono] self.model = transform_mono self.pos = 0 #posicion de la tecla, 1=> acelerando, -1=> desacelerando, 0=>cayendo
def create_scene(): gpu_cuchillo = os.toGPUShape(bs.createColorCuchillo(1, 1, 0)) gpu_green_triangle = os.toGPUShape(bs.createColorTriangle(0, 1, 0)) gpu_yellow_triangle = os.toGPUShape(bs.createColorTriangle(1, 1, 0)) gpu_green_quad = es.toGPUShape(bs.createColorQuad(1, 1, 0)) gpu_yellow_quad = es.toGPUShape(bs.createColorQuad(0, 1, 0)) gpu_yellow_d = es.toGPUShape(bs.createColorD(0, 1, 0)) # El cuchillo cuchillo = sg.SceneGraphNode('cuchillo') cuchillo.transform = tr.matmul([ tr.translate(-8 / 15, -1 / 22, 0), tr.scale(3, 3, 1), tr.rotationZ(180) ]) cuchillo.childs += [gpu_cuchillo] # La mesa mc1 = sg.SceneGraphNode('mc1') mc1.transform = tr.scale(4, 4, 1) mc1.childs += [gpu_yellow_quad] mt1 = sg.SceneGraphNode('mt1') mt1.transform = tr.translate(-1 / 15, -3 / 22, 0) mt1.childs += [gpu_yellow_quad] mt2 = sg.SceneGraphNode('mt2') mt2.transform = tr.translate(1 / 15, -3 / 22, 0) mt2.childs += [gpu_yellow_quad] MesaT = sg.SceneGraphNode('MesaT') MesaT.childs += [mt1, mt2] MesaT.transform = tr.scale(2, 2, 1) Mesa = sg.SceneGraphNode('Mesa') Mesa.childs += [MesaT, mc1] Mesa.transform = tr.matmul([ tr.translate(5 / 15, 8 / 22, 0), tr.scale(2, 1.5, 1), tr.rotationZ(180) ]) # El Árbol ac1 = sg.SceneGraphNode('ac1') ac1.transform = tr.scale(2, 2, 1) ac1.childs += [gpu_green_quad] at1 = sg.SceneGraphNode('at1') at1.transform = tr.translate(-1 / 15, 0, 0) at1.childs += [gpu_green_triangle] at2 = sg.SceneGraphNode('at2') at2.transform = tr.translate(1 / 15, 0, 0) at2.childs += [gpu_green_triangle] Rama1 = sg.SceneGraphNode('Rama1') Rama1.childs += [at1, at2] Rama1.transform = tr.translate(0, 4 / 22, 0) at3 = sg.SceneGraphNode('at3') at3.transform = tr.translate(-1 / 15, 0, 0) at3.childs += [gpu_green_triangle] at4 = sg.SceneGraphNode('at4') at4.transform = tr.translate(1 / 15, 0, 0) at4.childs += [gpu_green_triangle] Rama2 = sg.SceneGraphNode('Rama2') Rama2.childs += [at3, at4] Rama2.transform = tr.translate(0, 2 / 22, 0) ArbolT = sg.SceneGraphNode('ArbolT') ArbolT.childs += [Rama1, Rama2] ArbolT.transform = tr.scale(2, 2, 1) Arbol = sg.SceneGraphNode('Arbol') Arbol.childs += [ArbolT, ac1] Arbol.transform = tr.matmul([ tr.translate(6 / 15, -13 / 22, 0), tr.scale(4, 2, 1), tr.rotationZ(360) ]) # La Firma d = sg.SceneGraphNode('d') d.transform = tr.translate(7 / 22, 0, 0) d.childs += [gpu_yellow_d] i1 = sg.SceneGraphNode('i1') i1.transform = tr.matmul( [tr.translate(-1 / 15, 3.5 / 22, 0), tr.scale(1, 6, 1)]) i1.childs += [gpu_green_quad] i2 = sg.SceneGraphNode('i2') i2.transform = tr.matmul( [tr.translate(-1 / 15, 0.5 / 22, 0), tr.scale(2, 5, 1)]) i2.childs += [gpu_green_quad] i3 = sg.SceneGraphNode('i3') i3.transform = tr.matmul( [tr.translate(-1 / 15, -2.5 / 22, 0), tr.scale(1, 6, 1)]) i3.childs += [gpu_green_quad] i = sg.SceneGraphNode('i') i.childs += [i1, i2, i3] Firma = sg.SceneGraphNode('Firma') Firma.childs += [i, d] Firma.transform = tr.matmul([tr.translate(-10 / 15, 19 / 22, 0)]) # El Cepillo de Dientes ct1 = sg.SceneGraphNode('ct1') ct1.transform = tr.translate(0, 1 / 22, 0) ct1.childs += [gpu_green_triangle] ct2 = sg.SceneGraphNode('ct2') ct2.transform = tr.translate(0, 3 / 22, 0) ct2.childs += [gpu_green_triangle] ct3 = sg.SceneGraphNode('ct3') ct3.transform = tr.translate(0, 5 / 22, 0) ct3.childs += [gpu_green_triangle] CepilloT = sg.SceneGraphNode('CepilloT') CepilloT.childs += [ct1, ct2, ct3] CepilloT.transform = tr.matmul( [tr.translate(-3 / 15, 0, 0), tr.scale(2, 2, 1)]) cc1 = sg.SceneGraphNode('cc1') cc1.transform = tr.translate(0, 5 / 22, 0) cc1.childs += [gpu_green_quad] cc2 = sg.SceneGraphNode('cc2') cc2.transform = tr.translate(0, 3 / 22, 0) cc2.childs += [gpu_green_quad] cc3 = sg.SceneGraphNode('cc3') cc3.transform = tr.translate(0, 1 / 22, 0) cc3.childs += [gpu_green_quad] cc4 = sg.SceneGraphNode('cc4') cc4.transform = tr.translate(0, -1 / 22, 0) cc4.childs += [gpu_green_quad] cc5 = sg.SceneGraphNode('cc5') cc5.transform = tr.translate(0, -3 / 22, 0) cc5.childs += [gpu_green_quad] cc6 = sg.SceneGraphNode('cc6') cc6.transform = tr.translate(0, -5 / 22, 0) cc6.childs += [gpu_green_quad] CepilloC = sg.SceneGraphNode('CepilloC') CepilloC.childs += [ct1, ct2, ct3] CepilloC.transform = tr.matmul( [tr.translate(-1 / 15, 0, 0), tr.scale(2, 2, 1)]) Cepillo = sg.SceneGraphNode('Cepillo') Cepillo.childs += [CepilloT, CepilloC] Cepillo.transform = tr.matmul([ tr.translate(2 / 15, -20 / 22, 0), tr.scale(0.5, 1.5, 1), tr.rotationZ(90) ]) # el Mundo mundo = sg.SceneGraphNode('mundo') mundo.childs += [Mesa, Arbol, Cepillo, cuchillo, Firma] return mundo
def crearCasa(pos): gpuBeigeQuad = es.toGPUShape(bs.createColorQuad(1, 0.8667, 0.749)) gpuRedTriangle = es.toGPUShape(bs.createColorTriangle(1, 0.1961, 0.4314)) gpuSBQuad = es.toGPUShape(bs.createColorQuad(0.6588, 0.9686, 1)) gpuOrangeQuad = es.toGPUShape(bs.createColorQuad(1, 0.5176, 0.3412)) gpuBlackCirc = es.toGPUShape(bs.createCircle([0, 0, 0])) gpuBrownQuad = es.toGPUShape(bs.createColorQuad(0.6039, 0.2039, 0)) gpuPQuad = es.toGPUShape(bs.createColorQuad(0.8392, 0.749, 1)) #Se crea la base de la casa base = sg.SceneGraphNode("base") base.transform = tr.uniformScale(0.4) base.childs += [gpuBeigeQuad] # Se crea el techo de la casa techo = sg.SceneGraphNode("techo") techo.transform = tr.matmul( [tr.translate(0, 0.3, 0), tr.scale(0.6, 0.2, 1)]) techo.childs += [gpuRedTriangle] #Se crean las ventanas con sus respectivos marcos ventD = sg.SceneGraphNode("ventD") ventD.transform = tr.matmul( [tr.translate(0.1, 0.1, 0), tr.uniformScale(0.1)]) ventD.childs += [gpuSBQuad] marcoVD = sg.SceneGraphNode("marcoVD") marcoVD.transform = tr.matmul( [tr.translate(0.1, 0.1, 0), tr.uniformScale(0.12)]) marcoVD.childs += [gpuBrownQuad] ventI = sg.SceneGraphNode("ventI") ventI.transform = tr.matmul( [tr.translate(-0.1, 0.1, 0), tr.uniformScale(0.1)]) ventI.childs += [gpuSBQuad] marcoVI = sg.SceneGraphNode("marcoVI") marcoVI.transform = tr.matmul( [tr.translate(-0.1, 0.1, 0), tr.uniformScale(0.12)]) marcoVI.childs += [gpuBrownQuad] #Se crea la puerta puerta = sg.SceneGraphNode("puerta") puerta.transform = tr.matmul( [tr.scale(0.1, 0.2, 1), tr.translate(0, -0.5, 0)]) puerta.childs += [gpuOrangeQuad] #Se crea el marco de la puerta marcoP = sg.SceneGraphNode("marcoP") marcoP.transform = tr.matmul( [tr.scale(0.12, 0.21, 1), tr.translate(0, -0.45, 0)]) marcoP.childs += [gpuBrownQuad] #Se crea la manilla de la puerta mani = sg.SceneGraphNode("mani") mani.transform = tr.matmul( [tr.translate(-0.03, -0.1, 0), tr.uniformScale(0.009)]) mani.childs += [gpuBlackCirc] #Se crea un camino de entrada a la casa camino = sg.SceneGraphNode("camino") camino.transform = tr.matmul( [tr.translate(0, -0.23, 0), tr.scale(0.12, 0.06, 1)]) camino.childs += [gpuPQuad] #Se crea la casa con todas su componentes casa = sg.SceneGraphNode("casa") casa.childs += [ base, techo, marcoVD, ventD, marcoVI, ventI, marcoP, puerta, mani, camino ] #Trasladamos la casa segun la posicion que se le indique traslatedCasa = sg.SceneGraphNode("traslatedCar") traslatedCasa.transform = tr.translate(pos, 0, 0) traslatedCasa.childs += [casa] return traslatedCasa