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