def crearNube():
gpuWhiteCirc = es.toGPUShape(bs.createCircle([0.95, 0.95, 0.95]))
#Se crea la base de la nube
circulito = sg.SceneGraphNode("circulito")
circulito.transform = tr.uniformScale(0.02)
circulito.childs += [gpuWhiteCirc]
base = sg.SceneGraphNode("base")
baseName = "base"
for i in range(-5,
4): #Se utiliza esto para crear la parte inicial de la nube
newNode = sg.SceneGraphNode(baseName + str(i))
newNode.transform = tr.translate(0.015 * i, 0.011 * (-1)**i, 0)
newNode.childs += [circulito]
base.childs += [newNode]
nube = sg.SceneGraphNode("nube")
baseName1 = "nube"
for i in range(0, 2): #Se crea la parte de abajo de la nube
newNode = sg.SceneGraphNode(baseName1 + str(i))
newNode.transform = tr.matmul([
tr.translate(-0.03 * (i - 1), -0.04 * i, 0),
tr.rotationZ(np.pi * i)
])
newNode.childs += [base]
nube.childs += [newNode]
nubeAlta = sg.SceneGraphNode("nubeAlta")
nubeAlta.transform = tr.translate(0, 0.8, 0)
nubeAlta.childs += [nube]
return nubeAlta
def __init__(self, tamaño):
self.tamaño = tamaño
gpu_circulo = es.toGPUShape(bs.createCircle(d / self.tamaño)) # rojo
gpu_triangulo = es.toGPUShape(bs.createColorTriangle(0, 0.8,
0)) #verde
coronta = sg.SceneGraphNode('coronta')
coronta.childs += [gpu_circulo]
hoja = sg.SceneGraphNode('hoja')
hoja.transform = tr.matmul(
[tr.uniformScale(d / self.tamaño),
tr.translate(0, 0.6, 0)])
hoja.childs += [gpu_triangulo]
self.pos_x = -1 + d * 3 / self.tamaño + d * 2 / self.tamaño * random.randint(
0, self.tamaño - 3)
self.pos_y = -1 + d * 3 / self.tamaño + d * 2 / self.tamaño * random.randint(
0, self.tamaño - 3)
manzana = sg.SceneGraphNode('manzana')
manzana.childs += [coronta, hoja]
self.model = manzana
def createCar(r, g, b, foc=False, turbo=False):
if not foc: #El proposito de este if es cambiar las luces delanteras del auto, de manera que si foc != False, los focos estan prendidos (amarillos)
rf = 0.8
gf = 0.8
bf = 0.8
else: #Aqui se aplica el color amarillo para el caso de que foc no sea False
rf = 0.9686
gf = 0.9412
bf = 0
#Se crean las figuras que se utilizaran para la creacion del auto
gpuBlackCirc = es.toGPUShape(bs.createCircle([0, 0, 0]))
gpuWhiteCirc = es.toGPUShape(bs.createCircle([0.8, 0.8, 0.8]))
gpuBlueQuad = es.toGPUShape(
bs.createColorQuad(r, g, b)
) #Se dejan los colores como variables para que Don Pedro pueda elegir el color de auto que mas le gusta
gpuFocQuad = es.toGPUShape(bs.createColorQuad(rf, gf, bf))
gpuRedQuad = es.toGPUShape(bs.createColorQuad(1, 0, 0))
gpuSBQuad = es.toGPUShape(bs.createColorQuad(0.5922, 0.9569, 1))
#Se crea la parte interna de la rueda de color blanco
little_wheel = sg.SceneGraphNode("little_wheel")
little_wheel.transform = tr.uniformScale(0.08)
little_wheel.childs += [gpuWhiteCirc]
# Se crea la parte negra de la rueda (la más externa)
big_wheel = sg.SceneGraphNode("big_wheel")
big_wheel.transform = tr.uniformScale(0.2)
big_wheel.childs += [gpuBlackCirc]
#Se crea la rueda completa compuesta de las dos partes anteriores
wheel = sg.SceneGraphNode("wheel")
wheel.childs += [big_wheel, little_wheel]
wheelRotation = sg.SceneGraphNode("wheelRotation")
wheelRotation.childs += [wheel]
# Se instalan las dos ruedas en el auto
frontWheel = sg.SceneGraphNode("frontWheel")
frontWheel.transform = tr.translate(0.5, -0.3, 0)
frontWheel.childs += [wheelRotation]
backWheel = sg.SceneGraphNode("backWheel")
backWheel.transform = tr.translate(-0.5, -0.3, 0)
backWheel.childs += [wheelRotation]
# Se crear el chasis del auto
chasis = sg.SceneGraphNode("chasis")
chasis.transform = tr.scale(1.8, 0.5, 1)
chasis.childs += [gpuBlueQuad]
#Se crea el techo del auto
techo = sg.SceneGraphNode("techo")
techo.transform = tr.matmul(
[tr.translate(0, 0.45, 0),
tr.scale(1, 0.5, 1)])
techo.childs += [gpuBlueQuad]
#Se crea el foco trasero
foco_tras = sg.SceneGraphNode("foco_tras")
foco_tras.transform = tr.matmul(
[tr.translate(-0.86, 0.21, 0),
tr.scale(0.08, 0.08, 1)])
foco_tras.childs += [gpuRedQuad]
#Se crea el foco delantero
foco_del = sg.SceneGraphNode("foco_del")
foco_del.transform = tr.matmul(
[tr.translate(0.86, 0.21, 0),
tr.scale(0.08, 0.08, 1)])
foco_del.childs += [gpuFocQuad]
#Se crean las ventanas del auto
vent_der = sg.SceneGraphNode("vent_der")
vent_der.transform = tr.matmul(
[tr.translate(0.23, 0.45, 0),
tr.scale(0.38, 0.37, 1)])
vent_der.childs += [gpuSBQuad]
vent_izq = sg.SceneGraphNode("vent_izq")
vent_izq.transform = tr.matmul(
[tr.translate(-0.23, 0.45, 0),
tr.scale(0.38, 0.37, 1)])
vent_izq.childs += [gpuSBQuad]
#Se creal auto compuesto de todas las partes anteriormente creadas
car = sg.SceneGraphNode("car")
car.childs += [
chasis, techo, frontWheel, backWheel, foco_tras, foco_del, vent_der,
vent_izq
]
#Se traslada y escala el auto
scaledCar = sg.SceneGraphNode("scaledCar")
scaledCar.transform = tr.matmul(
[tr.translate(0, -0.66, 0),
tr.uniformScale(0.15)])
scaledCar.childs += [car]
#Se crean las figras que se utilizaran para el turbo
gpuGrayOv = es.toGPUShape(bs.createSemiCircle([0.7, 0.7, 0.7]))
gpuBlackC = es.toGPUShape(bs.createCircle([0.2, 0.2, 0.2]))
gpuRYC = es.toGPUShape(
bs.create2ColorCircle([1, 0, 0], [1, 0.9961, 0.4392]))
#La base de la turbina
base = sg.SceneGraphNode("base")
base.transform = tr.matmul(
[tr.rotationZ(-np.pi / 2),
tr.scale(0.04, 0.17, 1)])
base.childs += [gpuGrayOv]
baseTr = sg.SceneGraphNode("baseTr")
baseTr.transform = tr.translate(-0.07, -0.515, 0)
baseTr.childs += [base]
#Se crea la parte trasera de la turbina en conjunto con el "fuego" que lo impulsa
fin = sg.SceneGraphNode("fin")
fin.transform = tr.matmul(
[tr.translate(-0.07, -0.515, 0),
tr.scale(0.02, 0.04, 1)])
fin.childs += [gpuBlackC]
fuego = sg.SceneGraphNode("fuego")
fuego.transform = tr.matmul(
[tr.translate(-0.07, -0.515, 0),
tr.scale(0.01, 0.03, 1)])
fuego.childs = [gpuRYC]
#Se crea la turbina
turboT = sg.SceneGraphNode("turbo")
turboT.childs += [baseTr, fin, fuego]
#Creamos una figura que va a ir cambiando los childs dependiendo de si el turbo esta activo o no
autoFinal = sg.SceneGraphNode("autoFinal")
autoFinal.childs += []
if turbo == False: #en el caso de que el turbo este desactivado se crea solo el auto escalado y trasladado
autoFinal.childs = [scaledCar]
elif turbo == True: #cuando la turbina esta activa el auto se compone de la turbina y el auto escalado
autoFinal.childs = [turboT, scaledCar]
else:
autoFinal.childs = []
return autoFinal
def crearNave():
gpuBCirc = es.toGPUShape(bs.createCircle([0,0.4627,0.4118]))
gpuBlackCirc = es.toGPUShape(bs.createCircle([0,0,0]))
gpuSBCirc = es.toGPUShape(bs.createSemiCircle([0,0,0]))
gpuSGreenCirc = es.toGPUShape(bs.createSemiCircle([0.4392,1,0.4078]))
gpuGreenCirc = es.toGPUShape(bs.createCircle([0.4392,1,0.4078]))
gpuBlackQuad = es.toGPUShape(bs.createColorQuad(0,0,0))
gpuGreenQuad = es.toGPUShape(bs.createColorQuad(0.4392,1,0.4078))
#Se crea la parte mas grande de la nave (asi como el chasis de auto)
base = sg.SceneGraphNode("base")
base.transform = tr.scale(0.5,0.08,0)
base.childs += [gpuBCirc]
#Creamos el "vidrio" de la nave, que es la parte donde podemos ver al marcianito, se crea negro para que sea mas facil ver la nave
#y al marciano debido a que con los colores del fondo la nave se pierde
vidrio = sg.SceneGraphNode("vidrio")
vidrio.transform = tr.matmul([tr.translate(0,0.02,0),tr.scale(0.2,0.35,0)])
vidrio.childs += [gpuSBCirc]
#Se crean las patas de la nave, compuestas por una bolita negra y un rectangulo del mismo color
pataIzq = sg.SceneGraphNode("pataIzq")
pataIzq.transform = tr.matmul([tr.rotationZ(np.pi/5) ,tr.scale(0.02,0.25,0)])
pataIzq.childs += [gpuBlackQuad]
pataDer = sg.SceneGraphNode("pataDer")
pataDer.transform = tr.matmul([tr.rotationZ(-(np.pi/5)) ,tr.scale(0.02,0.25,0)])
pataDer.childs += [gpuBlackQuad]
pataItras = sg.SceneGraphNode("pataItras")
pataItras.transform = tr.translate(0.3,-0.1,0)
pataItras.childs += [pataIzq]
pataDtras = sg.SceneGraphNode("pataDtras")
pataDtras.transform = tr.translate(-0.3,-0.1,0)
pataDtras.childs += [pataDer]
finPataI = sg.SceneGraphNode("finPataI")
finPataI.transform = tr.matmul([tr.translate(0.375,-0.2,0) ,tr.uniformScale(0.025)])
finPataI.childs += [gpuBlackCirc]
finPataD = sg.SceneGraphNode("finPataD")
finPataD.transform = tr.matmul([tr.translate(-0.375,-0.2,0) ,tr.uniformScale(0.025)])
finPataD.childs += [gpuBlackCirc]
pataD = sg.SceneGraphNode("pataD")
pataD.childs += [pataDtras, finPataD]
pataI = sg.SceneGraphNode("pataI")
pataI.childs += [pataItras, finPataI]
#Creamos al marcianito
#Se crea primero el cuerpo
cuerpoTripulacion = sg.SceneGraphNode("cuerpoTripulacion")
cuerpoTripulacion.transform = tr.matmul([tr.translate(0,0.02,0), tr.scale(0.03,0.06,0)])
cuerpoTripulacion.childs += [gpuSGreenCirc]
#Creamos la cabeza
cabezaTripulacion = sg.SceneGraphNode("cabezaTripulacion")
cabezaTripulacion.transform = tr.matmul([tr.translate(0,0.12,0) , tr.uniformScale(0.04)])
cabezaTripulacion.childs += [gpuGreenCirc]
#Aqui creamos las antenas completas del marcianito, con una idea muy parecida a las patas de la nave
antenaD = sg.SceneGraphNode("antenaD")
antenaD.transform = tr.matmul([tr.translate(0.017,0.165,0) ,tr.scale(0.01,0.025,0)])
antenaD.childs += [gpuGreenQuad]
antenaI = sg.SceneGraphNode("antenaI")
antenaI.transform = tr.matmul([tr.translate(-0.017,0.165,0),tr.scale(0.01,0.025,0)])
antenaI.childs += [gpuGreenQuad]
finAnD = sg.SceneGraphNode("finAnD")
finAnD.transform = tr.matmul([tr.translate(0.017,0.19,0) , tr.uniformScale(0.015)])
finAnD.childs = [gpuGreenCirc]
finAnI = sg.SceneGraphNode("finAnI")
finAnI.transform = tr.matmul([tr.translate(-0.017,0.19,0) , tr.uniformScale(0.015)])
finAnI.childs = [gpuGreenCirc]
#Se crea la nave en conjunto con la tripulacion
nave = sg.SceneGraphNode("nave")
nave.transform = tr.matmul([tr.translate(0,0.7,0) , tr.uniformScale(0.1)])
nave.childs += [pataI, pataD, base, vidrio, cuerpoTripulacion, cabezaTripulacion, antenaD, antenaI, finAnD, finAnI]
#Se crea esto para luego poder trasladar la nave en la parte final
navef = sg.SceneGraphNode("navef")
navef.childs += [nave]
return navef
def crearCasa(pos):
gpuBeigeQuad = es.toGPUShape(bs.createColorQuad(1, 0.8667, 0.749))
gpuRedTriangle = es.toGPUShape(bs.createColorTriangle(1, 0.1961, 0.4314))
gpuSBQuad = es.toGPUShape(bs.createColorQuad(0.6588, 0.9686, 1))
gpuOrangeQuad = es.toGPUShape(bs.createColorQuad(1, 0.5176, 0.3412))
gpuBlackCirc = es.toGPUShape(bs.createCircle([0, 0, 0]))
gpuBrownQuad = es.toGPUShape(bs.createColorQuad(0.6039, 0.2039, 0))
gpuPQuad = es.toGPUShape(bs.createColorQuad(0.8392, 0.749, 1))
#Se crea la base de la casa
base = sg.SceneGraphNode("base")
base.transform = tr.uniformScale(0.4)
base.childs += [gpuBeigeQuad]
# Se crea el techo de la casa
techo = sg.SceneGraphNode("techo")
techo.transform = tr.matmul(
[tr.translate(0, 0.3, 0),
tr.scale(0.6, 0.2, 1)])
techo.childs += [gpuRedTriangle]
#Se crean las ventanas con sus respectivos marcos
ventD = sg.SceneGraphNode("ventD")
ventD.transform = tr.matmul(
[tr.translate(0.1, 0.1, 0),
tr.uniformScale(0.1)])
ventD.childs += [gpuSBQuad]
marcoVD = sg.SceneGraphNode("marcoVD")
marcoVD.transform = tr.matmul(
[tr.translate(0.1, 0.1, 0),
tr.uniformScale(0.12)])
marcoVD.childs += [gpuBrownQuad]
ventI = sg.SceneGraphNode("ventI")
ventI.transform = tr.matmul(
[tr.translate(-0.1, 0.1, 0),
tr.uniformScale(0.1)])
ventI.childs += [gpuSBQuad]
marcoVI = sg.SceneGraphNode("marcoVI")
marcoVI.transform = tr.matmul(
[tr.translate(-0.1, 0.1, 0),
tr.uniformScale(0.12)])
marcoVI.childs += [gpuBrownQuad]
#Se crea la puerta
puerta = sg.SceneGraphNode("puerta")
puerta.transform = tr.matmul(
[tr.scale(0.1, 0.2, 1),
tr.translate(0, -0.5, 0)])
puerta.childs += [gpuOrangeQuad]
#Se crea el marco de la puerta
marcoP = sg.SceneGraphNode("marcoP")
marcoP.transform = tr.matmul(
[tr.scale(0.12, 0.21, 1),
tr.translate(0, -0.45, 0)])
marcoP.childs += [gpuBrownQuad]
#Se crea la manilla de la puerta
mani = sg.SceneGraphNode("mani")
mani.transform = tr.matmul(
[tr.translate(-0.03, -0.1, 0),
tr.uniformScale(0.009)])
mani.childs += [gpuBlackCirc]
#Se crea un camino de entrada a la casa
camino = sg.SceneGraphNode("camino")
camino.transform = tr.matmul(
[tr.translate(0, -0.23, 0),
tr.scale(0.12, 0.06, 1)])
camino.childs += [gpuPQuad]
#Se crea la casa con todas su componentes
casa = sg.SceneGraphNode("casa")
casa.childs += [
base, techo, marcoVD, ventD, marcoVI, ventI, marcoP, puerta, mani,
camino
]
#Trasladamos la casa segun la posicion que se le indique
traslatedCasa = sg.SceneGraphNode("traslatedCar")
traslatedCasa.transform = tr.translate(pos, 0, 0)
traslatedCasa.childs += [casa]
return traslatedCasa