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 draw(self, pipeline): if self.last_direction == "D": self.face_orientation = "D" new_gpu_snake = es.toGPUShape(bs.createTextureQuad("boo_r.png"), GL_CLAMP, GL_NEAREST) sg.findNode(self.model, "snake_head").childs = [new_gpu_snake] elif self.last_direction == "A": self.face_orientation = "A" new_gpu_snake = es.toGPUShape(bs.createTextureQuad("boo_l.png"), GL_CLAMP, GL_NEAREST) sg.findNode(self.model, "snake_head").childs = [new_gpu_snake] sg.drawSceneGraphNode(self.model, pipeline, "transform")
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 draw(self, pipeline, stage): # Drawing Structure model with a given pipeline # The textures depends on the stage given background = sg.findNode(self.model, "background") if stage == 0: background.childs = [self.texture_0] elif stage == 1: background.childs = [self.texture_2] elif stage == 2: background.childs = [self.texture_2] elif stage == 3: background.childs = [self.texture_3] elif stage == 4: background.childs = [self.texture_4] elif stage == 5: background.childs = [self.texture_5] elif stage == 6: background.childs = [self.texture_6] elif stage == 7: background.childs = [self.texture_7] elif stage == 8: background.childs = [self.texture_8] elif stage == 9: background.childs = [self.texture_9] elif stage == 10: background.childs = [self.texture_10] glUseProgram(pipeline.shaderProgram) sg.drawSceneGraphNode(self.model, pipeline, "transform")
def drawScreen(pipeline, time, background, player): global controller global logic # Local position of the animated flames flameLoop = 0.2 * np.sin(12 * time) # Drawing the animated background. backTime = time % 5 background.transform = tr.translate(0, -backTime * 0.4, 0) sg.drawSceneGraphNode(background, pipeline, "transform") # Drawing the explosions of defeated ships drawExplosions(time) # Drawing the enemies for enemy in logic.enemies: ship = enemy.ship ship.transform = tr.translate(enemy.xPos, enemy.yPos, 0) animatedFlame = sg.findNode(ship, "animatedFlame") animatedFlame.transform = tr.translate(0, flameLoop, 0) sg.drawSceneGraphNode(ship, pipeline, "transform") # Drawing the bullets for bullet in logic.bullets: shape = bullet.shape shape.transform = tr.translate(bullet.xPos, bullet.yPos, 0) sg.drawSceneGraphNode(shape, pipeline, "transform") # Drawing the player player.transform = tr.translate(controller.xPos, controller.yPos, 0) animatedFlame = sg.findNode(player, "animatedFlame") animatedFlame.transform = tr.translate(0, flameLoop, 0) sg.drawSceneGraphNode(player, pipeline, "transform") # Drawing the lifebar of the player, with the corresponding colors drawLifeBar(pipeline, logic.hp)
def add_body(self): posX = self.body_queue[ len(self.body_queue) - 1]["last_position"][0] if len( self.body_queue) > 0 else self.last_position[0] posY = self.body_queue[ len(self.body_queue) - 1]["last_position"][1] if len( self.body_queue) > 0 else self.last_position[1] snake_body = sg.SceneGraphNode(f'snake_body_{len(self.body_queue)}') snake_body.transform = tr.matmul([ tr.scale(self.dimensions[0] / self.tiles, self.dimensions[1] / self.tiles, 0), tr.translate(-self.tiles / 2 + posX + 0.5, -self.tiles / 2 + posY - 0.5, 0) ]) snake_body.childs += [self.gpu_body] self.body_queue.append({ "name": f'snake_body_{len(self.body_queue)}', "position": [posX, posY], "last_position": [posX, posY] }) sg.findNode(self.model, "snake").childs += [snake_body]
def draw(self, pipeline_texture): # Draws the monkey model with a given pipeline texture # The state depends on the state of the monkey monkey_body = sg.findNode(self.model, "body") if self.is_jumping or self.is_falling: monkey_body.childs = [self.gpu_texture_jumping] elif self.position_x > self.aiming_x: monkey_body.childs = [self.gpu_texture_left] elif self.position_x < self.aiming_x: monkey_body.childs = [self.gpu_texture_right] else: monkey_body.childs = [self.gpu_texture_monkey] glUseProgram(pipeline_texture.shaderProgram) sg.drawSceneGraphNode(self.model, pipeline_texture, 'transform')
def draw(self, pipeline_texture, t): # Drawing Structure model with a given pipeline # The texture depends on the given time variable scene = sg.findNode(self.model, "scene") if t < 0.2: scene.childs = [self.texture_1] elif 0.4 >= t >= 0.2: scene.childs = [self.texture_2] elif 0.6 >= t >= 0.4: scene.childs = [self.texture_3] elif 0.8 >= t >= 0.6: scene.childs = [self.texture_4] else: scene.childs = [self.texture_5] glUseProgram(pipeline_texture.shaderProgram) sg.drawSceneGraphNode(self.model, pipeline_texture, 'transform')
def move(self, move_Q): moveX = 0 moveY = 0 movement = tr.identity() body_positions = [] for i in range(len(self.body_queue)): direction = move_Q[len(move_Q) - 1 - i] if direction == "W": movement = tr.translate(0, 1, 0) moveY = 1 elif direction == "A": movement = tr.translate(-1, 0, 0) moveX = -1 elif direction == "S": movement = tr.translate(0, -1, 0) moveY = -1 elif direction == "D": movement = tr.translate(1, 0, 0) moveX = 1 sg.findNode(self.model, self.body_queue[i]["name"]).transform = tr.matmul([ sg.findTransform(self.model, self.body_queue[i]["name"]), movement ]) self.body_queue[i]["last_position"][0] = self.body_queue[i][ "position"][0] self.body_queue[i]["last_position"][1] = self.body_queue[i][ "position"][1] self.body_queue[i]["position"][ 0] = self.body_queue[i]["position"][0] + moveX self.body_queue[i]["position"][ 1] = self.body_queue[i]["position"][1] + moveY moveX = 0 moveY = 0 body_positions.append(self.body_queue[i]["position"]) self.occupied_positions = self.occupied_positions[0] + body_positions
"quadraticAttenuation"), 0.01) glUniformMatrix4fv( glGetUniformLocation(phongPipeline.shaderProgram, "projection"), 1, GL_TRUE, projection) glUniformMatrix4fv( glGetUniformLocation(phongPipeline.shaderProgram, "view"), 1, GL_TRUE, view) glUniformMatrix4fv( glGetUniformLocation(phongPipeline.shaderProgram, "model"), 1, GL_TRUE, model) # Movement of the wings for birdNode in birdNodes: # Right wing upperRightRotationNode = sg.findNode(birdNode, "upperRightRotation") upperRightRotationNode.transform = tr.rotationX(-rotation) foreRightRotationNode = sg.findNode(birdNode, "foreRightRotation") foreRightRotationNode.transform = tr.matmul([ tr.translate(0, -0.58, 0), tr.rotationX(-4 * rotation), tr.translate(0, 0.58, 0) ]) # Left wing upperLeftRotationNode = sg.findNode(birdNode, "upperLeftRotation") upperLeftRotationNode.transform = tr.rotationX(rotation) foreLeftRotationNode = sg.findNode(birdNode, "foreLeftRotation") foreLeftRotationNode.transform = tr.matmul([ tr.translate(0, 0.58, 0), tr.rotationX(4 * rotation), tr.translate(0, -0.58, 0)
# Lose condition upon reaching base of scene if controller.monkey.y < scene_movement + 0.3 and controller.lost is False: controller.lost = True controller.end_game_time = theta # Lose animation start and end if controller.lost: monkey_left = False monkey_right = False controller.monkey.collision = False controller.monkey.start_jump() controller.monkey.is_falling = False controller.leftKeyOn = False controller.rightKeyOn = False sg.findNode(main_scene_translate, "Monkey Texture").childs = \ [monkey_texture_lost] if theta - controller.end_game_time > 0.35: sys.exit("You fell out.") # Win condition if controller.won is False and controller.monkey.has_banana: controller.won = True controller.end_game_time = theta elif controller.won: sg.findNode(main_scene_translate, "Monkey Texture").childs = \ [monkey_texture_won] monkey_left = False monkey_right = False controller.leftKeyOn = False controller.rightKeyOn = False
# Clearing the screen in both, color and depth glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT) # Filling or not the shapes depending on the controller state if (controller.fillPolygon): glPolygonMode(GL_FRONT_AND_BACK, GL_FILL) else: glPolygonMode(GL_FRONT_AND_BACK, GL_LINE) if controller.showAxis: glUniformMatrix4fv(glGetUniformLocation(mvcPipeline.shaderProgram, "model"), 1, GL_TRUE, tr.identity()) mvcPipeline.drawShape(gpuAxis, GL_LINES) # Moving the red car and rotating its wheels redCarNode.transform = tr.translate(3 * np.sin( glfw.get_time() ),0,0.5) redWheelRotationNode = sg.findNode(redCarNode, "wheelRotation") redWheelRotationNode.transform = tr.rotationY(-10 * glfw.get_time()) # Uncomment to print the red car position on every iteration #print(sg.findPosition(redCarNode, "car")) # Drawing the Car sg.drawSceneGraphNode(redCarNode, mvcPipeline, "model") sg.drawSceneGraphNode(blueCarNode, mvcPipeline, "model") # Once the render is done, buffers are swapped, showing only the complete scene. glfw.swap_buffers(window) glfw.terminate()
# Telling OpenGL to use our shader program glUseProgram(shaderProgram) # Setting up the clear screen color glClearColor(0.85, 0.85, 0.85, 1.0) # Creating shapes on GPU memory car = createCar() # Our shapes here are always fully painted glPolygonMode(GL_FRONT_AND_BACK, GL_FILL) while not glfw.window_should_close(window): # Using GLFW to check for input events glfw.poll_events() # Clearing the screen in both, color and depth glClear(GL_COLOR_BUFFER_BIT) # Modifying only a specific node in the scene graph wheelRotationNode = sg.findNode(car, "wheelRotation") theta = -10 * glfw.get_time() wheelRotationNode.transform = tr.rotationZ(theta) # Drawing the Car sg.drawSceneGraphNode(car, shaderProgram, tr.identity()) # Once the render is done, buffers are swapped, showing only the complete scene. glfw.swap_buffers(window) glfw.terminate()
def draw_game_over(self, pipeline, dt): sg.findNode(self.g_over, "game_over_banner_TR").transform = tr.matmul([ sg.findTransform(self.g_over, "game_over_banner_TR"), tr.rotationZ(dt) ]) sg.drawSceneGraphNode(self.g_over, pipeline, "transform")
x = controller.x y = controller.y z = -controller.z view = tr.lookAt( np.array([0 + x,-0.0015 + y,7 + z]), np.array([x, y,0]), np.array([0,0,1]) ) # Clearing the screen in both, color and depth glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT) enzo(embisi) nodoAnterior = sg.findNode(malla, "T" + cursoAnterior.codigo) tapaAnt = nodoAnterior.childs[1] nodoAnterior.childs = [cuboR, tapaAnt] nodoAnterior = sg.findNode(malla, cursoAnterior.codigo) nodoAnterior.transform = tr.scale(1,1,1) for requisitoAnt in cursoAnterior.requisitos: nodoReqAnt = sg.findNode(malla, "T" + requisitoAnt) tapaReqAnt = nodoReqAnt.childs[1] nodoReqAnt.childs = [cuboR, tapaReqAnt] nodoReqAnt = sg.findNode(malla, requisitoAnt) nodoReqAnt.transform = tr.scale(1,1,1) for requisitoDeAnt in cursoAnterior.requisitosDe:
elif glfw.get_key(window, glfw.KEY_DOWN) == glfw.PRESS: if zoom > 0.4: zoom -= 0.05 # Zoom transformations scaledSurfaceA.transform = tr.uniformScale(zoom) scaledSurfaceB.transform = tr.uniformScale(zoom) scaledSurfaceC.transform = tr.uniformScale(zoom) scaledBorder.transform = tr.uniformScale(zoom) # Fish transformations for i in range(len(fishesA)): fishesA[i].transform = tr.matmul([tr.uniformScale(zoom), tr.translate(pointsA[nas[i]][1] - 20, pointsA[nas[i]][0] - 10, pointsA[nas[i]][2] - 10), tr.rotationZ(randomRotationA[i])]) tailRotationA = sg.findNode(fishesA[i], 'tailRotation') tailRotationA.transform = tr.rotationZ(rotation) for i in range(len(fishesB)): fishesB[i].transform = tr.matmul([tr.uniformScale(zoom), tr.translate(pointsB[nbs[i]][1] - 20, pointsB[nbs[i]][0] - 10, pointsB[nbs[i]][2] - 10), tr.rotationZ(randomRotationB[i])]) tailRotationB = sg.findNode(fishesB[i], 'tailRotation') tailRotationB.transform = tr.rotationZ(rotation) for i in range(len(fishesC)): fishesC[i].transform = tr.matmul([tr.uniformScale(zoom), tr.translate(pointsC[ncs[i]][1] - 20, pointsC[ncs[i]][0] - 10, pointsC[ncs[i]][2] - 10), tr.rotationZ(randomRotationC[i])]) tailRotationC = sg.findNode(fishesC[i], 'tailRotation') tailRotationC.transform = tr.rotationZ(rotation)
def enfermar(self): gpu_triangulo_rojo = es.toGPUShape(bs.createColorTriangle(1, 0, 0)) self.estado = 'Enferma' triangulo = sg.findNode(self.model, 'triangulo') triangulo.childs = [gpu_triangulo_rojo]
pipeline2 = es.SimpleTextureTransformShaderProgram() glUseProgram(pipeline2.shaderProgram) sg.drawSceneGraphNode(sky, pipeline2, "transform") pipeline = es.SimpleTransformShaderProgram() glUseProgram(pipeline.shaderProgram) riel=sg.findNode(rollercoaster,'riel') #creando el movimiento del rollercoaster riel.transform=np.matmul(tr.uniformScale(1.7), tr.translate(-0.29-0.0001*int(t), -0.025, 0)) carro=sg.findNode(rollercoaster,"rollercoaster") #evitando que se indetermine el angulo while curva[n][0] - curva[n - 1][0] == 0: n+=1 t+=1 #calculando el angulo de rotacion del carrito angulo=np.arctan((curva[n][1]-curva[n-1][1])/(curva[n][0]-curva[n-1][0])) #viendo si el carrito esta en el vacio for punto in cortes: if (0<punto[0] - curva[n][0] <= 0.002) and vacio==0: vacio=1 contador=0