def __init__(self, count, fondo): fondoa1 = bs.createTextureCube('azul.jpg') gpufondoa1 = es.toGPUShape(fondoa1, GL_REPEAT, GL_NEAREST) fondo.models.append(gpufondoa1) fondo.transform.append( tr.matmul([tr.uniformScale(24), tr.translate(-1, 0, 0.4 + count)])) fondoa2 = bs.createTextureCube('azul.jpg') gpufondoa2 = es.toGPUShape(fondoa2, GL_REPEAT, GL_NEAREST) fondo.models.append(gpufondoa2) fondo.transform.append( tr.matmul([tr.uniformScale(24), tr.translate(0, -1, 0.4 + count)])) fondoa3 = bs.createTextureCube('azul.jpg') gpufondoa3 = es.toGPUShape(fondoa3, GL_REPEAT, GL_NEAREST) fondo.models.append(gpufondoa3) fondo.transform.append( tr.matmul([tr.uniformScale(24), tr.translate(0, 1, 0.4 + count)])) fondoa4 = bs.createTextureCube('azul.jpg') gpufondoa4 = es.toGPUShape(fondoa4, GL_REPEAT, GL_NEAREST) fondo.models.append(gpufondoa4) fondo.transform.append( tr.matmul([tr.uniformScale(24), tr.translate(1, 0, 0.4 + count)]))
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 crearCubos(): NormalCube = es.toGPUShape(bs.createTextureCube("base.png"),GL_REPEAT, GL_NEAREST) RequisitoDeCube = es.toGPUShape(bs.createTextureCube("base1.png"),GL_REPEAT, GL_NEAREST) SelectedCube = es.toGPUShape(bs.createTextureCube("base4.png"),GL_REPEAT, GL_NEAREST) RequisitoCube = es.toGPUShape(bs.createTextureCube("base3.png"),GL_REPEAT, GL_NEAREST) #Aqui se comienzan a crear los cubos de base CuboMorado = sg.SceneGraphNode("CuboMorado") #Se crea la base para el cubo morado CuboMorado.transform = tr.matmul([tr.translate(0.8,0,0), tr.uniformScale(0.5)]) CuboMorado.childs += [NormalCube] CuboTurquesa = sg.SceneGraphNode("CuboTurquesa") CuboTurquesa.transform = tr.matmul([tr.translate(0.27,0,0),tr.uniformScale(0.5)]) CuboTurquesa.childs += [RequisitoDeCube] CuboCeleste = sg.SceneGraphNode("CuboCeleste") CuboCeleste.transform = tr.matmul([tr.translate(-0.27,0,0),tr.uniformScale(0.5)]) CuboCeleste.childs += [RequisitoCube] CuboNaranjo = sg.SceneGraphNode("CuboNaranjo") CuboNaranjo.transform = tr.matmul([tr.translate(-0.8,0,0),tr.uniformScale(0.5)]) CuboNaranjo.childs += [SelectedCube] return CuboMorado,CuboTurquesa,CuboCeleste,CuboNaranjo
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 createMotor(): gpuGrayTrapeze = es.toGPUShape(ve.createColorTrapeze(0.6, 0.6, 0.6)) gpuBlueTriangle = es.toGPUShape(ve.createColorTriangle(0.2, 0.5, 1)) gpuWhiteTriangle = es.toGPUShape(ve.createColorTriangle(1, 1, 1)) # A motor is made of a body and an animated flame blueFlame = sg.SceneGraphNode("blueFlame") blueFlame.transform = tr.matmul([tr.translate(0, 0.18, 1), tr.uniformScale(0.5)]) blueFlame.childs += [gpuBlueTriangle] whiteFlame = sg.SceneGraphNode("whiteFlame") whiteFlame.transform = tr.matmul([tr.translate(0, 0.05, 1), tr.uniformScale(0.3)]) whiteFlame.childs += [gpuWhiteTriangle] # This flame is animated in the main script animatedFlame = sg.SceneGraphNode("animatedFlame") animatedFlame.childs += [blueFlame] animatedFlame.childs += [whiteFlame] body = sg.SceneGraphNode("body") body.transform = tr.scale(1, 0.25, 1) body.childs += [gpuGrayTrapeze] # Joining both parts motor = sg.SceneGraphNode("simpleMotor") motor.childs += [animatedFlame] motor.childs += [body] return motor
def Fondo(fondoE): color = es.toGPUShape(bs.createTextureCube("fondo2.jpg"),GL_REPEAT, GL_NEAREST) obama = es.toGPUShape(bs.createTextureCube("marco.png"),GL_REPEAT, GL_NEAREST) ricardo = es.toGPUShape(bs.createTextureCube("ricardo.jpg"),GL_REPEAT, GL_NEAREST) fondo1 = sg.SceneGraphNode("fondo1") fondo1.transform = tr.matmul([tr.translate(0,0,1) ,tr.uniformScale (15)]) fondo1.childs = [color] fondo2 = sg.SceneGraphNode("fondo2") fondo2.transform = tr.matmul([tr.translate(0,0,1) ,tr.uniformScale (15)]) fondo2.childs = [ricardo] fondo3 = sg.SceneGraphNode("fondo3") fondo3.transform = tr.matmul([tr.translate(0,0,1) ,tr.uniformScale (15)]) fondo3.childs = [obama] fondo = sg.SceneGraphNode("fondo") if fondoE == "C" : fondo.childs = [fondo1] if fondoE == "O" : fondo.childs = [fondo3] if fondoE == "R" : fondo.childs = [fondo2] return fondo
def __init__(self): self.models = [] self.transform = [] #crea el "manto de un cubo fondo1 = bs.createTextureCube('fondo.jpg') gpufondo1 = es.toGPUShape(fondo1, GL_REPEAT, GL_NEAREST) self.models.append(gpufondo1) self.transform.append( tr.matmul([tr.uniformScale(24), tr.translate(-1, 0, 0.4)])) fondo2 = bs.createTextureCube('fondo.jpg') gpufondo2 = es.toGPUShape(fondo2, GL_REPEAT, GL_NEAREST) self.models.append(gpufondo1) self.transform.append( tr.matmul([tr.uniformScale(24), tr.translate(0, -1, 0.4)])) fondo3 = bs.createTextureCube('fondo.jpg') gpufondo3 = es.toGPUShape(fondo3, GL_REPEAT, GL_NEAREST) self.models.append(gpufondo1) self.transform.append( tr.matmul([tr.uniformScale(24), tr.translate(0, 1, 0.4)])) fondo4 = bs.createTextureCube('fondo.jpg') gpufondo4 = es.toGPUShape(fondo4, GL_REPEAT, GL_NEAREST) self.models.append(gpufondo1) self.transform.append( tr.matmul([tr.uniformScale(24), tr.translate(1, 0, 0.4)]))
def Movimiento (x,y): if x ==1: return tr.matmul([tr.translate(0,0,0),tr.translate(y*np.cos(t1*y) *np.sin(t1),y*np.cos(t1),0), tr.shearing(np.sin(t1)/50,np.cos(t1)/8,0,0,0,0)]) elif x ==2 : return tr.matmul([tr.translate(np.cos(t1*y), y*np.sin(t1*y)*np.sin(t1*y),0),tr.uniformScale(0.5), tr.shearing(np.sin(t1)/8,np.cos(t1)/8,0,0,0,0)]) elif x ==3 : return tr.matmul([tr.translate(y*np.sin(t1*y),np.cos(t1*y),0), tr.uniformScale(0.8), tr.shearing(np.sin(t1)/8,np.cos(t1)/8,0,0,0,0)]) elif x == 4: return tr.matmul([tr.translate(1000000000000,100000000000000,0)])
def move_right(self): model = self.get_model() self.x2 = (self.x2 + 0.05) model.transform = tr.matmul([ tr.uniformScale(self.get_zoom()), tr.translate(self.x2, self.y2, 0) ])
def setTransform(n, theta, translation, scale, x): t = translation shearing = tr.shearing(0.1 * np.sin(theta), 0.1 * np.cos(theta), 0, 0, 0, 0) scale = tr.uniformScale(scale) theta = theta / 4 if n == 1: tx = 0.7 * np.cos(theta / (2 * x)) ty = 0.4 * np.cos(theta / x) + 0.3 * np.cos(theta) elif n == 2: tx = 0.4 * np.sin(theta) + 0.7 * np.cos(theta / 2) ty = 0.2 * np.sin(theta) * np.cos(theta / x) + 0.1 * np.sin(theta) elif n == 3: tx = 0.5 * np.cos(theta) * np.sin(theta / (2 * x)) + 0.4 * np.cos(theta) ty = 0.2 * np.cos(theta) * np.sin(theta / x) + 0.3 * np.cos(theta) elif n == 4: tx = 0.4 * np.cos(theta / x) * np.cos(theta) ty = 0.2 * np.cos(theta / (x)) elif n == 5: tx = 0.4 * np.cos(theta / x) * np.sin(theta / x) ty = 0.2 * np.cos(theta / x) * np.sin(theta) * np.cos(theta) else: return tr.identity() tx = t[0] + tx ty = t[1] + ty pos = posInLimits(tx, ty) translation = tr.translate(pos[0], pos[1], 0) return tr.matmul([shearing, scale, translation])
def update(self, t): self.update_parent_x() self.update_parent_y() parent_x = self.get_parent_x() parent_y = self.get_parent_y() d = self.get_distance() w = self.get_velocity() new_x = d * sin(w * t) new_y = d * cos(w * t) self.set_x(new_x + parent_x) self.set_y(new_y + parent_y) satellites = self.get_satellites_objects() model = self.get_model() body = sg.findNode(model, 'body') body.transform = tr.translate(self.get_x(), self.get_y(), 0) orbit = sg.findNode(model, 'orbit') orbit.transform = tr.matmul([ tr.uniformScale(self.get_zoom()), tr.translate(self.get_parent_x(), self.get_parent_y(), 0) ]) for planeta in satellites: planeta.update(t) selection = sg.findNode(model, 'selection_circle') if self.selected: selection.transform = tr.uniformScale(self.radius + 0.009) else: selection.transform = tr.uniformScale(0)
def move_all(self): self.check_life() if not self.life_status: return self.move(self.movement_queue) movement = tr.identity() if self.next_direction == "W": movement = tr.translate(0, 1, 0) self.locationY += 1 elif self.next_direction == "A": movement = tr.translate(-1, 0, 0) self.locationX += -1 elif self.next_direction == "S": movement = tr.translate(0, -1, 0) self.locationY += -1 elif self.next_direction == "D": movement = tr.translate(1, 0, 0) self.locationX += 1 self.queue_movement(self.next_direction) self.last_direction = self.next_direction if self.check_apple(): self.eat_apple() self.last_position = [self.locationX, self.locationY] self.occupied_positions = [self.last_position ] + self.occupied_positions[1:] sg.findNode(self.model, "snake_head").transform = tr.matmul( [sg.findTransform(self.model, "snake_head"), movement])
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_player(): # Generate player model # Body gpuBody = es.toGPUShape(player_body_shape(0.8, 0, 0.07)) # WingUp gpuWingUp = es.toGPUShape(player_upper_wing_shape(0.427, 0.447, 0.458)) # WingDown gpuWingDown = es.toGPUShape(player_lower_wing_shape(0.427, 0.447, 0.458)) #Flame gpuFlame = es.toGPUShape(flame_shape()) playerBody = sg.SceneGraphNode("body") playerBody.childs = [gpuBody] playerUpWing = sg.SceneGraphNode("wing1") playerUpWing.childs = [gpuWingUp] playerDownWing = sg.SceneGraphNode("wing2") playerDownWing.childs = [gpuWingDown] playerEngine = sg.SceneGraphNode("engine") playerEngine.transform = tr.matmul( [tr.translate(0.0, -0.525, 0.0), tr.uniformScale(0.9)]) playerEngine.childs = [gpuFlame] player = sg.SceneGraphNode("playerModel") player.transform = tr.uniformScale(0.1) player.childs = [playerUpWing, playerDownWing, playerBody, playerEngine] return player
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 generate_forest_trees_obj(locations, fz, trees_models, leaves_models, scale=0.5): # Generates an obj model with all the trees merged # locations - Matrix of (N,2) of the trees x,y coordinates # fz - Terrain height function fz(x,y)->z # trees_models - List of OBJ trees models # leaves_models - List of OBJ leaves models # scales - Scale factor for the trees scale_tr = tr.uniformScale(scale) forest_trees = [] for i in range(len(locations)): x, y = locations[i] z = fz(x, y) - 0.03 # Lower to avoid floating trees M = tr.matmul([tr.translate(x, y, z), scale_tr]) model = i % len(trees_models) moved_tree = trees_models[model].transform(M) moved_leaves = leaves_models[model].transform(M) moved_tree.join(moved_leaves) forest_trees.append(moved_tree) merged_trees_model = forest_trees[0] for i in range(1, len(forest_trees)): merged_trees_model.join(forest_trees[i]) return merged_trees_model
def __init__(self, frame_width, frame_height, tiles=50): self.tiles = min(50, max(10, tiles)) self.frame_dim = [frame_width, frame_height] self.locationX = random.randint(0, self.tiles - 1) self.locationY = random.randint(1, self.tiles) # 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_apple = es.toGPUShape(my_shapes.apple()) apple = sg.SceneGraphNode('apple') apple.transform = tr.matmul([ tr.scale(self.dimensions[0] / self.tiles, self.dimensions[1] / self.tiles, 0), tr.translate(-self.tiles / 2 + self.locationX + 0.5, -self.tiles / 2 + self.locationY - 0.5, 0) ]) apple.childs += [gpu_apple] apple_tr = sg.SceneGraphNode('apple_TR') apple_tr.childs += [apple] self.model = apple_tr
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 createExplosion(): gpuWhiteTriangle = es.toGPUShape(createColorTriangle(1, 1, 1)) gpuOrangeTriangle = es.toGPUShape(createColorTriangle(1, 0.5, 0)) whitePart = sg.SceneGraphNode("whitePart") whitePart.transform = tr.uniformScale(0.7) orangePart = sg.SceneGraphNode("orangePart") theta = math.pi # Creating the white part tri0 = sg.SceneGraphNode("tri0") tri0.transform = tr.matmul( [tr.translate(0, -0.15, 0), tr.rotationZ(theta)]) tri0.childs += [gpuWhiteTriangle] tri1 = sg.SceneGraphNode("tri1") tri1.transform = tr.matmul( [tr.translate(0, 0.15, 0), tr.rotationZ(theta * 2)]) tri1.childs += [gpuWhiteTriangle] whitePart.childs += [tri0, tri1] # Creating the orange part angle0 = sg.SceneGraphNode("angle0") angle0.transform = tr.matmul( [tr.translate(0, -0.15, 0), tr.rotationZ(theta)]) angle0.childs += [gpuOrangeTriangle] angle1 = sg.SceneGraphNode("angle1") angle1.transform = tr.matmul( [tr.translate(0, 0.15, 0), tr.rotationZ(theta * 2)]) angle1.childs += [gpuOrangeTriangle] orangePart.childs += [angle0, angle1] # Joining both parts explosion = sg.SceneGraphNode("explosion") explosion.childs = [orangePart, whitePart] return explosion
def zoom_out(self): model = self.get_model() zoom = self.get_zoom() new_zoom = zoom - 0.1 self.set_zoom(new_zoom) model.transform = tr.matmul( [tr.uniformScale(new_zoom), tr.translate(self.x2, self.y2, 0)])
def circulo(grab): circulo = sg.SceneGraphNode("") theta = 0 while theta <= np.pi: diff = sg.SceneGraphNode("") diff.transform = tr.matmul([tr.scale(0.05, 1, 0), tr.rotationZ(theta)]) if grab: diff.childs += [createQuad(255, 0, 0, 255, 0, 0)] #ROJO else: diff.childs += [createQuad(0, 255, 0, 0, 255, 0)] #VERDE circulo.childs += [diff] theta += 2 * np.pi / 65 circulo.transform = tr.matmul( [tr.uniformScale(0.5), tr.translate(-0.35, 0, 0)]) return circulo
def tapa(): tapa = sg.SceneGraphNode("tapa") tapa.transform = tr.matmul([tr.scale(0.25, 2, 0), tr.translate(0.5, 0, 0)]) tapa.childs += [ createQuad(255 * 0.35, 255 * 0.35, 255 * 0.35, 255 * 0.35, 255 * 0.35, 255 * 0.35) ] return tapa
def Update(self, pipeline, delta, transform, isPaused): if self.isAnimated: anim_to_play = self.animations[ self.current_anim] #animation() actual owntransform = tr.matmul([ transform, tr.scale(self.scale[0], self.scale[1], self.scale[2]) ]) #escalamiento if len(anim_to_play.frames) == 1: #si la animacion contiene un solo frame, solo se dibuja este glUniformMatrix4fv( glGetUniformLocation(pipeline.shaderProgram, "transform"), 1, GL_TRUE, owntransform) pipeline.drawShape(anim_to_play.frames[0]) else: glUniformMatrix4fv( glGetUniformLocation(pipeline.shaderProgram, "transform"), 1, GL_TRUE, owntransform) pipeline.drawShape(anim_to_play.frames[self.frame_counter]) if not isPaused: self.time_counter += delta if self.time_counter > 1 / anim_to_play.fps: #controlador de la velocidad de la animacion #controlar si ya se animaron todos los frames if self.play_counter >= anim_to_play.anim_length - 1: self.canPlay = False self.isFinished = True #si quedan frames por animar o es un loop se actualizan los frames if self.canPlay or anim_to_play.isLooped: if anim_to_play.canRewind: #si se puede invertir la animacion, los frames se actualizan segun su direccion if self.isRewinding == False: self.frame_counter += 1 else: self.frame_counter -= 1 if self.frame_counter > len( anim_to_play.frames) - 1: self.isRewinding = True self.frame_counter -= 2 elif self.frame_counter < 0: self.isRewinding = False self.frame_counter += 2 else: self.frame_counter = (self.frame_counter + 1) % len( anim_to_play.frames) self.play_counter += 1 self.time_counter = 0
def create_explosion(): # Ship explosion model r, g, b = (0.95, 0.4, 0.0) # Defining locations and colors for each vertex of the shape vertices = [ # positions colors -0.5, -0.5, 0.0, r, g, b, 0.5, -0.5, 0.0, r, g, b, 0.0, 0.5, 0.0, r, g, b, 0.0, -0.75, 0.0, r, g, b, 0.5, 0.25, 0.0, r, g, b, -0.5, 0.25, 0.0, r, g, b ] # Defining connections among vertices # We have a triangle every 3 indices specified indices = [0, 1, 2, 3, 4, 5] gpuExplosion = es.toGPUShape(bs.Shape(vertices, indices)) explosion = sg.SceneGraphNode("explosionModel") explosion.transform = tr.matmul( [tr.translate(0.0, 0.02, 0.0), tr.uniformScale(0.15)]) explosion.childs = [gpuExplosion] return explosion
def __init__(self, texture): self.texture = texture monop = es.toGPUShape(bs.createTextureQuad(self.texture, 1, 1), GL_REPEAT, GL_LINEAR) self.model = monop self.pos_x = 0 self.pos_y = -0.7 self.pos=-0.7 monopTransform= tr.matmul([tr.translate(self.pos_x, self.pos_y, 0), tr.uniformScale(0.5)]) self.tra = monopTransform self.winner = False #aun no gana self.loser = False #aun no pierde
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 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 drawExplosions(time): global logic for explosion in logic.explosions: shape = explosion.shape spawnTime = explosion.spawnTime position = tr.translate(explosion.xPos, explosion.yPos, 0) scale = tr.uniformScale(0.2 * (spawnTime + 1 - time)) shape.transform = tr.matmul([position, scale]) sg.drawSceneGraphNode(shape, pipeline, "transform")
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