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 draw(self, pipeline1, pipeline2, snake: 'Snake'): self.choca_esquina(snake) if snake.die: glUseProgram(pipeline2.shaderProgram) sg.drawSceneGraphNode(self.model, pipeline2, 'transform') else: glUseProgram(pipeline1.shaderProgram) sg.drawSceneGraphNode(self.model, pipeline1, 'transform')
def drawBackground(self, time): #Draw the moving background # time - current clock time in seconds # Telling OpenGL to use our shader program for textures glUseProgram(self.pipelineTexture.shaderProgram) self.background.transform = tr.translate(0, (-time / 4) % 2, 0) sg.drawSceneGraphNode(self.background, self.pipelineTexture, "transform")
def drawEndScreen(self, time, endScreen): # End screen handling # endScreen - end creen SceneGraphNode # time - current clock time in seconds if self.endTray is None: self.endTray = gu.LinearTrayectory(time, 2, 0.0, 2.0, 0.0, 0.0) # Telling OpenGL to use our shader program for textures glUseProgram(self.pipelineTexture.shaderProgram) goX, goY = self.endTray.get_pos(time) endScreen.transform = tr.translate(goX, goY, 0.0) sg.drawSceneGraphNode(endScreen, self.pipelineTexture, "transform")
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 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 drawTree(tree, pipeline): # Object is barely visible at only ambient and brighter for the diffuse component. glUniform3f(glGetUniformLocation(pipeline.shaderProgram, "Ka"), 0.3, 0.3, 0.3) glUniform3f(glGetUniformLocation(pipeline.shaderProgram, "Kd"), 0.5, 0.5, 0.5) glUniform3f(glGetUniformLocation(pipeline.shaderProgram, "Ks"), 0.1, 0.1, 0.1) # In my humble opinion, natural wood and leaves aren't shiny at all glUniform1ui(glGetUniformLocation(pipeline.shaderProgram, "shininess"), 1) # Drawing the shapes sg.drawSceneGraphNode(tree, pipeline, "model")
def drawMap(map, pipeline): # Object is barely visible at only ambient and brighter for the diffuse component. glUniform3f(glGetUniformLocation(pipeline.shaderProgram, "Ka"), 0.3, 0.3, 0.3) glUniform3f(glGetUniformLocation(pipeline.shaderProgram, "Kd"), 0.5, 0.5, 0.5) glUniform3f(glGetUniformLocation(pipeline.shaderProgram, "Ks"), 0.1, 0.1, 0.1) # The map shouldn't be that shiny glUniform1ui(glGetUniformLocation(pipeline.shaderProgram, "shininess"), 1) # Drawing the shapes sg.drawSceneGraphNode(map, pipeline, "model")
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 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 drawLifeBar(pipeline, hp): bar0 = ve.createLifeBar(hp > 0) bar0.transform = tr.translate(-0.92, -0.95, 0) bar1 = ve.createLifeBar(hp > 1) bar1.transform = tr.translate(-0.81, -0.95, 0) bar2 = ve.createLifeBar(hp > 2) bar2.transform = tr.translate(-0.70, -0.95, 0) sg.drawSceneGraphNode(bar0, pipeline, "transform") sg.drawSceneGraphNode(bar1, pipeline, "transform") sg.drawSceneGraphNode(bar2, pipeline, "transform")
else: sg.findNode(main_scene_translate, "Monkey Texture").childs = \ [monkey_texture_left2] elif controller.leftKeyOn is False and monkey_left is True: monkey_left = False sg.findNode(main_scene_translate, "Monkey Texture").childs = \ [monkey_texture] if controller.rightKeyOn: if monkey_right is False: monkey_right = True else: if math.ceil(math.sin(theta * 30)) == 1: sg.findNode(main_scene_translate, "Monkey Texture").childs = \ [monkey_texture_right1] else: sg.findNode(main_scene_translate, "Monkey Texture").childs = \ [monkey_texture_right2] elif controller.rightKeyOn is False and monkey_right is True: monkey_right = False sg.findNode(main_scene_translate, "Monkey Texture").childs = \ [monkey_texture] # Drawing sg.drawSceneGraphNode(main_scene, pipeline, "transform") # Once the render is done, buffers are swapped, showing only the complete scene. glfw.swap_buffers(window) glfw.terminate()
nodoReqDe = sg.findNode(malla, requisitoDe) nodoReqDe.transform = tr.scale(1,1,1.5) # 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(embisi.shaderProgram, "model"), 1, GL_TRUE, tr.identity()) # embisi.drawShape(gpuAxis, GL_LINES) enzo(mvcPipeline) # Drawing the Car sg.drawSceneGraphNode(fondo, mvcPipeline, "model") sg.drawSceneGraphNode(malla, mvcPipeline, "model") glFlush() cursoAnterior = cursoActual # Once the render is done, buffers are swapped, showing only the complete scene. glfw.swap_buffers(window) glfw.terminate()
glUniformMatrix4fv( glGetUniformLocation(mvpPipeline.shaderProgram, "projection"), 1, GL_TRUE, projection) glUniformMatrix4fv( glGetUniformLocation(mvpPipeline.shaderProgram, "view"), 1, GL_TRUE, view) glUniformMatrix4fv( glGetUniformLocation(mvpPipeline.shaderProgram, "model"), 1, GL_TRUE, tr.identity()) mvpPipeline.drawShape(gpuAq, GL_LINES) if controller.showAxis: mvpPipeline.drawShape(gpuAxis, GL_LINES) # Draw fish for f in fish: f.update(time) sg.drawSceneGraphNode(fish_scene, mvpPipeline, "model") # Draw aquarium glUseProgram(phongPipeline.shaderProgram) # White light in all components: ambient, diffuse and specular. glUniform3f(glGetUniformLocation(phongPipeline.shaderProgram, "La"), 1.0, 1.0, 1.0) glUniform3f(glGetUniformLocation(phongPipeline.shaderProgram, "Ld"), 1.0, 1.0, 1.0) glUniform3f(glGetUniformLocation(phongPipeline.shaderProgram, "Ls"), 1.0, 1.0, 1.0) # Object is barely visible at only ambient. Diffuse behavior is slightly red. Sparkles are white glUniform3f(glGetUniformLocation(phongPipeline.shaderProgram, "Ka"), 0.3, 0.3, 0.3)
# Using GLFW to check for input events glfw.poll_events() # Clearing the screen in both, color and depth glClear(GL_COLOR_BUFFER_BIT) # Drawing the scene for the planets and the stars for redPlanet in redPlanets: redPlanet.transform = tr.translate(0, redPlanet.pos_y, 0) if redPlanet.pos_y > -3: redPlanet.pos_y -= dt else: redPlanet.pos_y = 2 redPlanet.pos_y -= dt sg.drawSceneGraphNode(redPlanet, pipeline, "transform") for greenPlanet in greenPlanets: greenPlanet.transform = tr.translate(0, greenPlanet.pos_y, 0) if greenPlanet.pos_y > -3: greenPlanet.pos_y -= dt else: greenPlanet.pos_y = 2 greenPlanet.pos_y -= dt sg.drawSceneGraphNode(greenPlanet, pipeline, "transform") for bluePlanet in bluePlanets: bluePlanet.transform = tr.translate(0, bluePlanet.pos_y, 0) if bluePlanet.pos_y > -3: bluePlanet.pos_y -= dt else:
glClear(GL_COLOR_BUFFER_BIT) # If the game is over, the loop is reduced to # showing a victory or defeat texture if logic.hp <= 0 or logic.score >= N: logic.bullets.clear() logic.enemies.clear() glUseProgram(texturePipeline.shaderProgram) glPolygonMode(GL_FRONT_AND_BACK, GL_FILL) image = victory if logic.score >= N else gameOver image.transform = tr.uniformScale(1 + 0.1 * np.sin(5 * time)) sg.drawSceneGraphNode(image, texturePipeline, "transform") # If just defeated, draws a single explosion if logic.hp == 0: logic.explosions.clear() Explosion(controller.xPos, -0.8 + controller.yPos, time) logic.hp -= 1 if len(logic.explosions) > 0: glUseProgram(pipeline.shaderProgram) explosionLogic(time) drawExplosions(time) glfw.swap_buffers(window) continue
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")
def draw(self, pipeline): sg.drawSceneGraphNode(self.model, pipeline, 'transform')
# Draw Tree glUseProgram(phongPipeline.shaderProgram) # White light in all components: ambient, diffuse and specular. glUniform3f(glGetUniformLocation(phongPipeline.shaderProgram, "La"), 1.0, 1.0, 1.0) glUniform3f(glGetUniformLocation(phongPipeline.shaderProgram, "Ld"), 1.0, 1.0, 1.0) glUniform3f(glGetUniformLocation(phongPipeline.shaderProgram, "Ls"), 1.0, 1.0, 1.0) # Object is barely visible at only ambient. Diffuse behavior is slightly red. Sparkles are white glUniform3f(glGetUniformLocation(phongPipeline.shaderProgram, "Ka"), 0.3, 0.3, 0.3) glUniform3f(glGetUniformLocation(phongPipeline.shaderProgram, "Kd"), 0.9, 0.5, 0.5) glUniform3f(glGetUniformLocation(phongPipeline.shaderProgram, "Ks"), 0.4, 0.4, 0.4) glUniform3f(glGetUniformLocation(phongPipeline.shaderProgram, "lightPosition"), -5, -5, 5) glUniform3f(glGetUniformLocation(phongPipeline.shaderProgram, "viewPosition"), viewPos[0], viewPos[1], viewPos[2]) glUniform1ui(glGetUniformLocation(phongPipeline.shaderProgram, "shininess"), 100) glUniform1f(glGetUniformLocation(phongPipeline.shaderProgram, "constantAttenuation"), 0.0001) glUniform1f(glGetUniformLocation(phongPipeline.shaderProgram, "linearAttenuation"), 0.03) glUniform1f(glGetUniformLocation(phongPipeline.shaderProgram, "quadraticAttenuation"), 0.01) glUniformMatrix4fv(glGetUniformLocation(phongPipeline.shaderProgram, "projection"), 1, GL_TRUE, projection) glUniformMatrix4fv(glGetUniformLocation(phongPipeline.shaderProgram, "view"), 1, GL_TRUE, view) sg.drawSceneGraphNode(tree_node, phongPipeline, "model") # Once the render is done, buffers are swapped, showing only the complete scene. glfw.swap_buffers(window) glfw.terminate()
# 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(self, pipeline): model = self.get_model() sg.drawSceneGraphNode(model, pipeline, 'transform')
dty = np.sin(5 * t0) if dty > 0: rotation += dt if dty > 0.99: # This is for preventing errors rotation = 0 else: rotation -= dt # Drawing fishes glUseProgram(pipeline.shaderProgram) glUniformMatrix4fv(glGetUniformLocation(pipeline.shaderProgram, 'projection'), 1, GL_TRUE, projection) glUniformMatrix4fv(glGetUniformLocation(pipeline.shaderProgram, 'view'), 1, GL_TRUE, view) glUniformMatrix4fv(glGetUniformLocation(pipeline.shaderProgram, 'model'), 1, GL_TRUE, model) for fishA in fishesA: sg.drawSceneGraphNode(fishA, pipeline, 'model') for fishB in fishesB: sg.drawSceneGraphNode(fishB, pipeline, 'model') for fishC in fishesC: sg.drawSceneGraphNode(fishC, pipeline, 'model') sg.drawSceneGraphNode(scaledBorder, pipeline, 'model') # Drawing voxels glUseProgram(voxelsPipeline.shaderProgram) glUniformMatrix4fv(glGetUniformLocation(voxelsPipeline.shaderProgram, 'projection'), 1, GL_TRUE, projection) glUniformMatrix4fv(glGetUniformLocation(voxelsPipeline.shaderProgram, 'view'), 1, GL_TRUE, view) glUniformMatrix4fv(glGetUniformLocation(voxelsPipeline.shaderProgram, 'model'), 1, GL_TRUE, model) if controller.a: sg.drawSceneGraphNode(scaledSurfaceA, voxelsPipeline, 'model') elif controller.b:
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 | 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) # Moving the red car and rotating its wheels # Uncomment to print the red car position on every iteration #print(sg.findPosition(redCarNode, "car")) # Drawing the Car sg.drawSceneGraphNode(cuboM, mvcPipeline, "model") sg.drawSceneGraphNode(cuboC, mvcPipeline, "model") sg.drawSceneGraphNode(cuboT, mvcPipeline, "model") sg.drawSceneGraphNode(cuboN, mvcPipeline, "model") # Once the render is done, buffers are swapped, showing only the complete scene. glfw.swap_buffers(window) glfw.terminate()
pos_f1 = vel_f % f pos_f2 = (-vel_f + f) % f if(shift_f): fondo1.transform = tr.translate(pos_f2,0,0) fondo2.transform = tr.translate(-pos_f1,0,0) else: fondo1.transform = tr.translate(-pos_f1,0,0) fondo2.transform = tr.translate(pos_f2,0,0) sg.drawSceneGraphNode(fondo1, pipeline, "transform") sg.drawSceneGraphNode(fondo2, pipeline, "transform") # Once the render is done, buffers are swapped, showing only the complete scene. glfw.swap_buffers(window) glfw.terminate()
def draw(self, pipeline): for i in range(len(self.serpiente)): glUseProgram(pipeline.shaderProgram) self.serpiente[i].transform = tr.translate(self.pos[i][0], self.pos[i][1], 0) sg.drawSceneGraphNode(self.serpiente[i], pipeline, "transform")
# Drawing the birds if t0 > 3: if i < N * c - 2: # Calculating the derivative for the rotation of the bird x1 = C[i][0] y1 = C[i][1] z1 = C[i][2] derivative1 = (C[i + 2][1] - y1) / (C[i + 2][0] - x1) angle1 = np.arctan(derivative1) # Transformation of the bird birdNode1.transform = tr.matmul([ tr.translate(x1, y1, z1), tr.rotationZ(angle1), tr.uniformScale(0.2) ]) sg.drawSceneGraphNode(birdNode1, phongPipeline, "model") i += 1 elif i == N * c - 2: i = 0 if t0 > 4: if j < N * c - 2: # Calculating the derivative for the rotation of the bird x2 = C[j][0] y2 = C[j][1] z2 = C[j][2] derivative2 = (C[j + 2][1] - y2) / (C[j + 2][0] - x2) angle2 = np.arctan(derivative2) # Transformation of the bird birdNode2.transform = tr.matmul([ tr.translate(x2, y2, z2),
def draw(self, pipeline): self.model.transform = tr.translate(self.pos_x, self.pos_y, 0) sg.drawSceneGraphNode(self.model, pipeline, "transform")
# Telling OpenGL to use our shader program glUseProgram(shaderProgram) # Setting up the clear screen color glClearColor(0.35, 0.35, 0.35, 1.0) # Our shapes here are always fully painted glPolygonMode(GL_FRONT_AND_BACK, GL_FILL) BARRA = barra() TAPA = tapa() 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) # Drawing the arbol sg.drawSceneGraphNode(BARRA, shaderProgram, tr.identity()) sg.drawSceneGraphNode(TAPA, shaderProgram, tr.translate(0, obj.val + 0.5, 0)) sg.drawSceneGraphNode(circulo(obj.grab), shaderProgram, tr.identity()) # Once the render is done, buffers are swapped, showing only the complete scene. glfw.swap_buffers(window) glfw.terminate()