def getTransform(showTransform, theta): if showTransform == TR_STANDARD: return tr.identity() elif showTransform == TR_ROTATE_ZP: return tr.rotationZ(theta) elif showTransform == TR_ROTATE_ZM: return tr.rotationZ(-theta) elif showTransform == TR_TRANSLATE: return tr.translate(0.3 * np.cos(theta), 0.3 * np.cos(theta), 0) elif showTransform == TR_UNIFORM_SCALE: return tr.uniformScale(0.7 + 0.5 * np.cos(theta)) elif showTransform == TR_NONUNIF_SCALE: return tr.scale(1.0 - 0.5 * np.cos(1.5 * theta), 1.0 + 0.5 * np.cos(2 * theta), 1.0) elif showTransform == TR_REFLEX_Y: return tr.scale(1, -1, 1) elif showTransform == TR_SHEARING_XY: return tr.shearing(0.3 * np.cos(theta), 0, 0, 0, 0, 0) else: # This should NEVER happend raise Exception()
def createStoreModel(pipeline): # Se crea la tiendo con un grafo de escena a base de shapes redQuadShape = bs.createColorQuad(255 / 255, 105 / 255, 105 / 255) lBlueQuadShape = bs.createColorQuad(133 / 255, 255 / 255, 253 / 255) darkGreenQuadShape = bs.createColorQuad(0, 125 / 255, 0) blackQuadShape = bs.createColorQuad(0, 0, 0) gpuRedQuad = createGPUShape(redQuadShape, pipeline) gpuLBlueQuad = createGPUShape(lBlueQuadShape, pipeline) gpuDarkGreenQuad = createGPUShape(darkGreenQuadShape, pipeline) gpuBlackQuad = createGPUShape(blackQuadShape, pipeline) frontNode = csg.CustomSceneGraphNode("front") frontNode.transform = tr.scale(0.3, 0.6, 1) frontNode.childs = [gpuRedQuad] windowNode = csg.CustomSceneGraphNode("window") windowNode.transform = tr.scale(0.1, 0.2, 1) windowNode.childs = [gpuLBlueQuad] windowDoorNode = csg.CustomSceneGraphNode("door") windowDoorNode.transform = tr.matmul( [tr.translate(0.024, 0.1, 0), tr.scale(0.15, 0.1, 1)]) windowDoorNode.childs = [gpuLBlueQuad] windowNode1 = csg.CustomSceneGraphNode("window2") windowNode1.transform = tr.translate(0, -0.15, 0) windowNode1.childs = [windowNode] windowGroupNode = csg.CustomSceneGraphNode("windowGroup") windowGroupNode.transform = tr.translate(0.05, 0, 0) windowGroupNode.childs = [windowNode1, windowDoorNode] signGreenNode = csg.CustomSceneGraphNode("greenSign") signGreenNode.transform = tr.scale(0.1, 0.7, 1) signGreenNode.childs = [gpuDarkGreenQuad] signBlackNode = csg.CustomSceneGraphNode("blackSign") signBlackNode.transform = tr.scale(0.11, 0.71, 1) signBlackNode.childs = [gpuBlackQuad] signNode = csg.CustomSceneGraphNode("sign") signNode.transform = tr.translate(-0.2, 0, 0) signNode.childs = [signBlackNode, signGreenNode] storeNode = csg.CustomSceneGraphNode("store") storeNode.childs = [frontNode, windowGroupNode, signNode] regularNode = csg.CustomSceneGraphNode("regularStore") regularNode.childs = [storeNode] finalNode = csg.CustomSceneGraphNode("finalStore") finalNode.transform = tr.translate(0, 2, 0) finalNode.childs = [regularNode] return finalNode
def createBackground(pipeline, i): # Se crea el fondo con un grafo de escena de shapes greenQuad = bs.createColorQuad(0.0, 0.6, 0.0) greyQuad = bs.createColorQuad(0.6, 0.6, 0.6) whiteQuad = bs.createColorQuad(255 / 255, 242 / 255, 0) gpuGrass = createGPUShape(greenQuad, pipeline) gpuStreet = createGPUShape(greyQuad, pipeline) gpuLine = createGPUShape(whiteQuad, pipeline) grassNode = sg.SceneGraphNode("grass") grassNode.transform = tr.scale(4, 2, 1) grassNode.childs = [gpuGrass] streetNode = sg.SceneGraphNode("street") streetNode.transform = tr.scale(1, 2, 1) streetNode.childs = [gpuStreet] lineNode = sg.SceneGraphNode("line") lineNode.transform = tr.scale(0.1, 0.25, 1) lineNode.childs = [gpuLine] trLineNode1 = sg.SceneGraphNode("trline1") trLineNode1.transform = tr.identity() trLineNode1.childs = [lineNode] trLineNode2 = sg.SceneGraphNode("trline2") trLineNode2.transform = tr.translate(0, 0.4, 0) trLineNode2.childs = [lineNode] trLineNode3 = sg.SceneGraphNode("trline3") trLineNode3.transform = tr.translate(0, -0.4, 0) trLineNode3.childs = [lineNode] trLineNode4 = sg.SceneGraphNode("trline4") trLineNode4.transform = tr.translate(0, -0.8, 0) trLineNode4.childs = [lineNode] trLineNode5 = sg.SceneGraphNode("trline5") trLineNode5.transform = tr.translate(0, 0.8, 0) trLineNode5.childs = [lineNode] lineGroupNode = sg.SceneGraphNode("lineGroup") lineGroupNode.transform = tr.translate(0, 0, 0) lineGroupNode.childs = [ trLineNode1, trLineNode2, trLineNode3, trLineNode4, trLineNode5 ] finalNode = sg.SceneGraphNode("final" + str(i)) finalNode.childs = [grassNode, streetNode, lineGroupNode] return finalNode
def update(self, delta, tex_pipeline, tex_green_pipeline, googles, time, move): # Se actualiza la posicion del jugador # Si detecta la tecla [D] presionada y no se ha salido de la pantalla se mueve hacia la derecha if self.controller.is_d_pressed and self.pos[0] < (1 - self.size / 2): self.pos[0] += self.vel[0] * delta # Si detecta la tecla [A] presionada y no se ha salido de la pantalla se mueve hacia la izquierda if self.controller.is_a_pressed and self.pos[0] > -(1 - self.size / 2): self.pos[0] -= self.vel[0] * delta # Si detecta la tecla [W] presionada y esta en la mitad inferior de la pantalla se mueve hacia arriba if self.controller.is_w_pressed and self.pos[1] < 0: self.pos[1] += self.vel[1] * delta self.controller.distance += self.vel[1] * delta # Si detecta la tecla [S] presionada y no se ha salido de la pantalla se mueve hacia abajo if self.controller.is_s_pressed and self.pos[1] > (-1 + self.size / 2): self.pos[1] -= self.vel[1] * delta self.controller.distance -= self.vel[1] * delta # Se le aplica la transformacion de traslado segun la posicion actual self.model.transform = tr.matmul([ tr.translate(self.pos[0], self.pos[1], 0), tr.scale(self.size, self.size, 1) ]) # Se dibuja con uno u otro shader dependiendo de su estado de infeccion y si se usan los lentes if self.infected and googles: self.model.curr_pipeline = tex_green_pipeline elif not googles: self.model.curr_pipeline = tex_pipeline # Actualiza el tono de verde que tendra siendo infectado self.green(time)
def update(self, delta, tex_pipeline, tex_green_pipeline, googles, time, move): # Se actualiza su posicion y_dir = self.direction vel = self.vel * delta x_dir = (1 - self.direction) * 0.2 if self.coin: x_dir *= -1 if not move: self.pos[0] += vel * x_dir self.pos[1] += vel * y_dir self.model.transform = tr.matmul([ tr.translate(self.pos[0], self.pos[1], 0), tr.scale(self.size, self.size, 1) ]) # Se dibuja con uno u otro shader dependiendo de su estado de infeccion y si se usan los lentes if self.infected and googles: self.model.curr_pipeline = tex_green_pipeline elif not googles: self.model.curr_pipeline = tex_pipeline # Se controla el tono de verde que tendra si esta infectado self.green(time)
def createCar(pipeline, r, g, b): # Creating shapes on GPU memory blackCube = bs.createColorCube(0, 0, 0) gpuBlackCube = es.GPUShape().initBuffers() pipeline.setupVAO(gpuBlackCube) gpuBlackCube.fillBuffers(blackCube.vertices, blackCube.indices, GL_STATIC_DRAW) chasisCube = bs.createColorCube(r, g, b) gpuChasisCube = es.GPUShape().initBuffers() pipeline.setupVAO(gpuChasisCube) gpuChasisCube.fillBuffers(chasisCube.vertices, chasisCube.indices, GL_STATIC_DRAW) # Cheating a single wheel wheel = sg.SceneGraphNode("wheel") wheel.transform = tr.scale(0.2, 0.8, 0.2) wheel.childs += [gpuBlackCube] wheelRotation = sg.SceneGraphNode("wheelRotation") wheelRotation.childs += [wheel] # Instanciating 2 wheels, for the front and back parts frontWheel = sg.SceneGraphNode("frontWheel") frontWheel.transform = tr.translate(0.3, 0, -0.3) frontWheel.childs += [wheelRotation] backWheel = sg.SceneGraphNode("backWheel") backWheel.transform = tr.translate(-0.3, 0, -0.3) backWheel.childs += [wheelRotation] # Creating the chasis of the car chasis = sg.SceneGraphNode("chasis") chasis.transform = tr.scale(1, 0.7, 0.5) chasis.childs += [gpuChasisCube] # All pieces together car = sg.SceneGraphNode("car") car.childs += [chasis] car.childs += [frontWheel] car.childs += [backWheel] return car
def createCar(pipeline): # Creating shapes on GPU memory blackQuad = bs.createColorQuad(0, 0, 0) gpuBlackQuad = es.GPUShape().initBuffers() pipeline.setupVAO(gpuBlackQuad) gpuBlackQuad.fillBuffers(blackQuad.vertices, blackQuad.indices, GL_STATIC_DRAW) redQuad = bs.createColorQuad(1, 0, 0) gpuRedQuad = es.GPUShape().initBuffers() pipeline.setupVAO(gpuRedQuad) gpuRedQuad.fillBuffers(redQuad.vertices, redQuad.indices, GL_STATIC_DRAW) # Cheating a single wheel wheel = sg.SceneGraphNode("wheel") wheel.transform = tr.uniformScale(0.2) wheel.childs += [gpuBlackQuad] wheelRotation = sg.SceneGraphNode("wheelRotation") wheelRotation.childs += [wheel] # Instanciating 2 wheels, for the front and back parts frontWheel = sg.SceneGraphNode("frontWheel") frontWheel.transform = tr.translate(0.3, -0.3, 0) frontWheel.childs += [wheelRotation] backWheel = sg.SceneGraphNode("backWheel") backWheel.transform = tr.translate(-0.3, -0.3, 0) backWheel.childs += [wheelRotation] # Creating the chasis of the car chasis = sg.SceneGraphNode("chasis") chasis.transform = tr.scale(1, 0.5, 1) chasis.childs += [gpuRedQuad] car = sg.SceneGraphNode("car") car.childs += [chasis] car.childs += [frontWheel] car.childs += [backWheel] traslatedCar = sg.SceneGraphNode("traslatedCar") traslatedCar.transform = tr.translate(0, 0.3, 0) traslatedCar.childs += [car] return traslatedCar
def update(self, delta, tex_pipeline, tex_green_pipeline, googles, time, move): # Se actualiza la posicion del zombie y_dir = self.direction vel = self.vel * delta x_dir = (1 - self.direction) * 0.2 if self.coin: x_dir *= -1 if not move: self.pos[0] += vel * x_dir self.pos[1] += vel * y_dir self.model.transform = tr.matmul([ tr.translate(self.pos[0], self.pos[1], 0), tr.scale(self.size, self.size, 1) ]) # Se dibuja con el pipeline de textura normal, no se ve verde self.model.curr_pipeline = tex_pipeline
def createDecorations(pipeline, tex_pipeline, x_range, y_range, n, i_z): # Se crean las decoraciones con un grafo de escena que admite shapes y texturas triangleShape = createTriangle() quadShape = createQuad() whiteQuad = bs.createColorQuad(1, 1, 1) greyQuad = bs.createColorQuad(0.8, 0.8, 0.8) umbrellaShape = createUmbrellaCircle() gpuLeaves = createTextureGPUShape(triangleShape, tex_pipeline, getAssetPath("hojas_arboles.jpg")) gpuTrunk = createTextureGPUShape(quadShape, tex_pipeline, getAssetPath("tronco.jpeg")) gpuWhiteQuad = createGPUShape(whiteQuad, pipeline) gpuGreyQuad = createGPUShape(greyQuad, pipeline) gpuUmbrella = createGPUShape(umbrellaShape, pipeline) leavesNode = csg.CustomSceneGraphNode("hojas") leavesNode.transform = tr.translate(0, 0.5, 0) leavesNode.childs = [gpuLeaves] trunkNode = csg.CustomSceneGraphNode("tronco") trunkNode.transform = tr.matmul( [tr.translate(0, -0.25, 0), tr.scale(0.3, 0.5, 1)]) trunkNode.childs = [gpuTrunk] scaledTreeNode = csg.CustomSceneGraphNode("arbol_escalado") scaledTreeNode.transform = tr.uniformScale(0.3) scaledTreeNode.childs = [trunkNode, leavesNode] treeGroupNode = csg.CustomSceneGraphNode("grupo_arboles") # Se crean arboles en posiciones generadas al azar for i in range(n): x = 100 - x_range * 100 x_rand = rd.randint(0, x) * 0.01 r_x = x_rand + x_range coin = rd.randint(0, 1) if coin: r_x *= -1 r_y = rd.randint(y_range[0] * 100, y_range[1] * 100) * 0.01 treeNode = csg.CustomSceneGraphNode("arbol_" + str(i)) treeNode.transform = tr.translate(r_x, r_y, 0) treeNode.childs = [scaledTreeNode] treeGroupNode.childs += [treeNode] treeGroupNode.childs.sort(reverse=True, key=height) cartBodyNode = csg.CustomSceneGraphNode("ej") cartBodyNode.transform = tr.scale(0.3, 0.5, 1) cartBodyNode.childs = [gpuWhiteQuad] cartInsideNode = csg.CustomSceneGraphNode("inside") cartInsideNode.transform = tr.scale(0.2, 0.3, 1) cartInsideNode.childs = [gpuGreyQuad] umbrellaNode = csg.CustomSceneGraphNode("umbrella") umbrellaNode.transform = tr.rotationZ(math.pi / 8) umbrellaNode.childs = [gpuUmbrella] umbrellaScaled = csg.CustomSceneGraphNode("umbrellaS") umbrellaScaled.transform = tr.scale(0.3, 0.3, 1) umbrellaScaled.childs = [umbrellaNode] umbrellaTranslated = csg.CustomSceneGraphNode("umbrellaT") umbrellaTranslated.transform = tr.translate(-0.1, 0.1, 0) umbrellaTranslated.childs = [umbrellaScaled] cartNode = csg.CustomSceneGraphNode("cart") cartNode.transform = tr.translate(0.8, -0.5, 0) cartNode.childs = [cartBodyNode, cartInsideNode, umbrellaTranslated] regularNode = csg.CustomSceneGraphNode("regular") regularNode.transform = tr.identity() regularNode.childs = [cartNode] regularNode.curr_pipeline = pipeline texNode = csg.CustomSceneGraphNode("tex") texNode.childs = [treeGroupNode] texNode.curr_pipeline = tex_pipeline decNode = csg.CustomSceneGraphNode("decorations" + str(i_z)) decNode.childs = [regularNode, texNode] return decNode
if ((glfw.get_key(window, glfw.KEY_RIGHT) == glfw.PRESS) or\ (glfw.get_key(window, glfw.KEY_UP) == glfw.PRESS)) and\ scale < 1.0: scale += 2 * dt # Clearing the screen glClear(GL_COLOR_BUFFER_BIT) # Drawing shapes glUseProgram(pipeline.shaderProgram) glUniformMatrix4fv( glGetUniformLocation(pipeline.shaderProgram, "transform"), 1, GL_TRUE, tr.matmul( [tr.translate(-0.5, 0, 0), tr.scale(scale, 2 * scale, 1)])) pipeline.drawCall(gpuShapeWithoutMipmap) glUniformMatrix4fv( glGetUniformLocation(pipeline.shaderProgram, "transform"), 1, GL_TRUE, tr.matmul([tr.translate(0.5, 0, 0), tr.scale(scale, 2 * scale, 1)])) pipeline.drawCall(gpuShapeWithMipmap) # Once the drawing is rendered, buffers are swap so an uncomplete drawing is never seen. glfw.swap_buffers(window) # freeing GPU memory gpuShapeWithoutMipmap.clear() #gpuShapeWithMipmap.clear()
glUniformMatrix4fv(glGetUniformLocation(mvpPipeline.shaderProgram, "model"), 1, GL_TRUE, tr.identity()) mvpPipeline.drawCall(gpuAxis, GL_LINES) glUniformMatrix4fv(glGetUniformLocation(mvpPipeline.shaderProgram, "model"), 1, GL_TRUE, model) mvpPipeline.drawCall(gpuRainbowCube) theta = glfw.get_time() tx = 0.7 * np.sin(0.5 * theta) ty = 0.2 * np.sin(5 * theta) # derivative of tx give us the direction dtx = 0.7 * 0.5 * np.cos(0.5 * theta) if dtx > 0: reflex = tr.identity() else: reflex = tr.scale(-1, 1, 1) glUseProgram(texture2dPipeline.shaderProgram) glUniformMatrix4fv(glGetUniformLocation(texture2dPipeline.shaderProgram, "transform"), 1, GL_TRUE, tr.matmul([ tr.translate(tx, ty, 0), tr.scale(0.5, 0.5, 1.0), reflex])) texture2dPipeline.drawCall(gpuBoo) # Once the drawing is rendered, buffers are swap so an uncomplete drawing is never seen. glfw.swap_buffers(window) # freeing GPU memory gpuBoo.clear() gpuAxis.clear() gpuRainbowCube.clear()
gpuBoo.fillBuffers(shapeBoo.vertices, shapeBoo.indices, GL_STATIC_DRAW) gpuBoo.texture = es.textureSimpleSetup(getAssetPath("boo.png"), GL_CLAMP_TO_EDGE, GL_CLAMP_TO_EDGE, GL_NEAREST, GL_NEAREST) shapeQuestionBoxes = bs.createTextureQuad(10, 1) gpuQuestionBoxes = GPUShape().initBuffers() pipeline.setupVAO(gpuQuestionBoxes) gpuQuestionBoxes.fillBuffers(shapeQuestionBoxes.vertices, shapeQuestionBoxes.indices, GL_STATIC_DRAW) gpuQuestionBoxes.texture = es.textureSimpleSetup( getAssetPath("cg_box.png"), GL_REPEAT, GL_REPEAT, GL_NEAREST, GL_NEAREST) questionBoxesTransform = np.matmul(tr.translate(0, -0.8, 0), tr.scale(2, 0.2, 1)) while not glfw.window_should_close(window): # Using GLFW to check for input events glfw.poll_events() if (controller.fillPolygon): glPolygonMode(GL_FRONT_AND_BACK, GL_FILL) else: glPolygonMode(GL_FRONT_AND_BACK, GL_LINE) # Clearing the screen in both, color and depth glClear(GL_COLOR_BUFFER_BIT) theta = glfw.get_time() tx = 0.7 * np.sin(0.5 * theta)
def createSnowman(pipeline): # Convenience function to ease initialization def createGPUShape(shape): gpuShape = es.GPUShape().initBuffers() pipeline.setupVAO(gpuShape) gpuShape.fillBuffers(shape.vertices, shape.indices, GL_STATIC_DRAW) return gpuShape # basic GPUShapes gpuWhiteCircle = createGPUShape(createColorCircle(30, 1, 1, 1, 1)) gpuBlackCircle = createGPUShape(createColorCircle(10, 1, 0, 0, 0)) gpuBrownQuad = createGPUShape(bs.createColorQuad(0.6, 0.3, 0)) gpuOrangeTriangle = createGPUShape(createColorTriangle(1, 0.6, 0)) # Leaf nodes whiteCircleNode = sg.SceneGraphNode("whiteCircleNode") whiteCircleNode.childs = [gpuWhiteCircle] blackCircleNode = sg.SceneGraphNode("blackCircleNode") blackCircleNode.childs = [gpuBlackCircle] brownQuadNode = sg.SceneGraphNode("brownQuadNode") brownQuadNode.childs = [gpuBrownQuad] orangeTriangleNode = sg.SceneGraphNode("orangeTriangleNode") orangeTriangleNode.childs = [gpuOrangeTriangle] # Body snowballBody = sg.SceneGraphNode("snowballBody") snowballBody.transform = tr.scale(10, 10, 0) snowballBody.childs = [whiteCircleNode] arm = sg.SceneGraphNode("arm") arm.transform = tr.matmul([ tr.translate(0, 5, 0), #tr.rotationZ(0), tr.scale(2, 10, 1) ]) arm.childs = [brownQuadNode] leftArm = sg.SceneGraphNode("leftArm") leftArm.transform = tr.matmul([ tr.translate(-7, 7, 0), tr.rotationZ(60 * np.pi / 180), #tr.scale(1, 1, 1) ]) leftArm.childs = [arm] rightArm = sg.SceneGraphNode("rightArm") rightArm.transform = tr.matmul([ tr.translate(7, 7, 0), tr.rotationZ(-60 * np.pi / 180), #tr.scale(1, 1, 1) ]) rightArm.childs = [arm] body = sg.SceneGraphNode("body") body.transform = tr.translate(0,10,0) body.childs = [snowballBody, leftArm, rightArm] # Head snowballHead = sg.SceneGraphNode("snowballHead") snowballHead.transform = tr.scale(8, 8, 0) snowballHead.childs = [whiteCircleNode] leftEye = sg.SceneGraphNode("leftEye") leftEye.transform = tr.matmul([ tr.translate(0, 5, 0), #tr.rotationZ(0), tr.scale(2, 2, 1) ]) leftEye.childs = [blackCircleNode] rightEye = sg.SceneGraphNode("rightEye") rightEye.transform = tr.matmul([ tr.translate(5, 5, 0), #tr.rotationZ(0), tr.scale(2, 2, 1) ]) rightEye.childs = [blackCircleNode] baseTriangle = sg.SceneGraphNode("baseTriangle") baseTriangle.transform = tr.matmul([ tr.translate(0, 3.5, 0), #tr.rotationZ(0), tr.scale(2, 7, 1) ]) baseTriangle.childs = [orangeTriangleNode] nose = sg.SceneGraphNode("nose") nose.transform = tr.matmul([ tr.translate(2, 0, 0), tr.rotationZ(-70 * np.pi / 180), #tr.scale(1, 1, 1) ]) nose.childs = [baseTriangle] head = sg.SceneGraphNode("head") head.transform = tr.translate(0, 27, 0) head.childs = [snowballHead, leftEye, rightEye, nose] # Snowman, the one and only snowman = sg.SceneGraphNode("snowman") snowman.childs = [body, head] return snowman
# Creating shapes on GPU memory snowman = createSnowman(pipeline) # 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() if (controller.fillPolygon): glPolygonMode(GL_FRONT_AND_BACK, GL_FILL) else: glPolygonMode(GL_FRONT_AND_BACK, GL_LINE) # Clearing the screen in both, color and depth glClear(GL_COLOR_BUFFER_BIT) # Drawing the Car sg.drawSceneGraphNode(snowman, pipeline, "transform", np.matmul(tr.translate(0, -0.5, 0), tr.scale(0.03, 0.03, 1))) # Once the render is done, buffers are swapped, showing only the complete scene. glfw.swap_buffers(window) # freeing GPU memory snowman.clear() glfw.terminate()
if collisions.infected and not entity.infected: entity.infected = True entity.inf_time = glfw.get_time() # Si hay una colision entre la tienda y el jugador, se termina el juego if store.collisionPlayer(player) and not controller.end: controller.end = True # Se crea una espiral mediante modificaciones de vertices segun el tiempo y transformaciones en CPU spiral = createSpiral(50, t1) for m in range(0, len(spiral.vertices), 6): current_vert = [ spiral.vertices[m], spiral.vertices[m + 1], spiral.vertices[m + 2], 1 ] new_vert = tr.matmul([tr.scale(0.02, 0.02, 1), current_vert]) spiral.vertices[m] = new_vert[0] spiral.vertices[m + 1] = new_vert[1] spiral.vertices[m + 2] = new_vert[2] GPUspiral = es.GPUShape().initBuffers() pipeline.setupVAO(GPUspiral) GPUspiral.fillBuffers(spiral.vertices, spiral.indices, GL_STREAM_DRAW) # Si el jugador esta infectado, aparece una espiral rotando encima de su modelo y se distoricona la vision if player.infected: for entity in entityList: entity.pos[0] += math.cos(t1) * delta * 0.2 * entity.pos[1] full_scene.transform = tr.shearing( math.cos(t1) * 0.2, 0, 0, 0, 0, 0) decoration_scene.transform = tr.shearing( math.cos(t1) * 0.2, 0, 0, 0, 0, 0)
tr.translate(0.5, 0.5, 0), tr.rotationZ(2 * theta), tr.uniformScale(0.5) ]) # Updating the transform attribute glUniformMatrix4fv(glGetUniformLocation(pipeline.shaderProgram, "transform"), 1, GL_TRUE, triangleTransform) # Drawing function pipeline.drawCall(gpuTriangle) # Another instance of the triangle triangleTransform2 = tr.matmul([ tr.translate(-0.5, 0.5, 0), tr.scale( 0.5 + 0.2 * np.cos(1.5 * theta), 0.5 + 0.2 * np.sin(2 * theta), 0) ]) glUniformMatrix4fv(glGetUniformLocation(pipeline.shaderProgram, "transform"), 1, GL_TRUE, triangleTransform2) pipeline.drawCall(gpuTriangle) # Quad quadTransform = tr.matmul([ tr.translate(-0.5, -0.5, 0), tr.rotationZ(-theta), tr.uniformScale(0.7) ]) glUniformMatrix4fv(glGetUniformLocation(pipeline.shaderProgram, "transform"), 1, GL_TRUE, quadTransform) pipeline.drawCall(gpuQuad) # Another instance of the Quad