def set_main_lighting(self):
mainLight = DirectionalLight("main light")
mainLight.setColor(Vec4(0.3, 0.3, 0.3, 1))
self.mainLightNodePath = self.render.attachNewNode(mainLight)
mainLight.setShadowCaster(True)
self.mainLightNodePath.setHpr(45, -80, 0)
self.render.setLight(self.mainLightNodePath)
def setup_world_lightning(self):
"""
Sets up the ambient and specular lighting of the world
:return:
"""
ambientLight = AmbientLight("ambientLight")
ambientLight.setColor((2, 2, 2, 1))
directionalLight = DirectionalLight("directionalLight")
directionalLight.setShadowCaster(True)
directionalLight.setDirection(LVector3(-1, -1, -1))
directionalLight.setColor((.5, .5, .5, 1))
dir_light_node = self.render.attachNewNode(directionalLight)
# dir_light_node.setPos(10, 2, 7)
# dir_light_node.lookAt(2, 2, 0)
self.render.setLight(dir_light_node)
self.render.setLight(self.render.attachNewNode(ambientLight))
spot = Spotlight("Spot")
spot.setColorTemperature(9000)
spot.setColor(LVector3(1, 1, 1))
light = self.render.attachNewNode(spot)
light.node().setScene(self.render)
light.node().setShadowCaster(True)
# light.node().showFrustum()
light.node().getLens().setFov(40)
light.node().getLens().setNearFar(2, 100)
# light.setPos(10, 2, 7)
light.setPos(10, 20, 20)
light.lookAt(2, 2, 0)
self.render.setLight(light)
def world_setup(env, render, mydir):
env.disableMouse()
# Load the environment model.
env.scene = env.loader.loadModel(mydir + "/models/city.egg")
env.scene.reparentTo(env.render)
env.scene.setScale(1, 1, 1)
env.scene.setPos(0, 0, 0)
# Load the skybox
# env.skybox = env.loader.loadModel(mydir + "/models/skybox.egg")
# env.skybox.setScale(100,100,100)
# env.skybox.setPos(0,0,-500)
# env.skybox.reparentTo(env.render)
# Also add an ambient light and set sky color.
skycol = panda3d.core.VBase3(135 / 255.0, 206 / 255.0, 235 / 255.0)
env.set_background_color(skycol)
alight = AmbientLight("sky")
alight.set_color(panda3d.core.VBase4(skycol * 0.04, 1))
alight_path = render.attachNewNode(alight)
render.set_light(alight_path)
# 4 perpendicular lights (flood light)
dlight1 = DirectionalLight('directionalLight')
dlight1.setColor(panda3d.core.Vec4(0.3,0.3,0.3,0.3))
dlight1NP = render.attachNewNode(dlight1)
dlight1NP.setHpr(0,0,0)
dlight2 = DirectionalLight('directionalLight')
dlight2.setColor(panda3d.core.Vec4(0.3,0.3,0.3,0.3))
dlight2NP = render.attachNewNode(dlight2)
dlight2NP.setHpr(-90,0,0)
dlight3 = DirectionalLight('directionalLight')
dlight3.setColor(panda3d.core.Vec4(0.3,0.3,0.3,0.3))
dlight3NP = render.attachNewNode(dlight3)
dlight3NP.setHpr(-180,0,0)
dlight4 = DirectionalLight('directionalLight')
dlight4.setColor(panda3d.core.Vec4(0.3,0.3,0.3,0.3))
dlight4NP = render.attachNewNode(dlight4)
dlight4NP.setHpr(-270,0,0)
render.setLight(dlight1NP)
render.setLight(dlight2NP)
render.setLight(dlight3NP)
render.setLight(dlight4NP)
# 1 directional light (Sun)
dlight = DirectionalLight('directionalLight')
dlight.setColor(panda3d.core.Vec4(1, 1, 1, 1)) # directional light is dim green
dlight.getLens().setFilmSize(panda3d.core.Vec2(50, 50))
dlight.getLens().setNearFar(-100, 100)
dlight.setShadowCaster(True, 1028*2, 1028*2)
# dlight.show_frustum()
dlightNP = render.attachNewNode(dlight)
dlightNP.setHpr(0,-65,0)
#Turning shader and lights on
render.setShaderAuto()
render.setLight(dlightNP)
def __setDirectionalLight(self,props): light = DirectionalLight(props['name']) light.setShadowCaster(props['castShadows'],1024,1024) lens = PerspectiveLens() light.setLens(lens) lens.setFov(1200/props['pos'].z) return self.__createLight(light,props)
def setupLights(self):
"""Setup extrnal lights"""
# ambient light
alight = AmbientLight('alight')
alight.setColor((0.2, 0.2, 0.2, 1))
alnp = self.render.attachNewNode(alight)
self.render.setLight(alnp)
# directional light
dlight = DirectionalLight('dlight')
dlight.setColor((0.8, 0.8, 0.5, 1))
lens = PerspectiveLens()
lens.setNearFar(1, 5)
dlight.setLens(lens)
dlight.setShadowCaster(True, args.shadow_resolution,
args.shadow_resolution)
dlnp = self.render.attachNewNode(dlight)
dlnp.setPos(2, -2, 3)
dlnp.lookAt(0, 0, 0)
self.render.setLight(dlnp)
# spotlight
slight = Spotlight('slight')
slight.setColor((0.7, 0.7, 1.0, 1))
lens = PerspectiveLens()
lens.setNearFar(1, 5)
slight.setLens(lens)
slight.setShadowCaster(True, args.shadow_resolution,
args.shadow_resolution)
slnp = self.render.attachNewNode(slight)
slnp.setPos(1, 1, 2)
slnp.lookAt(0, 0, 0)
self.render.setLight(slnp)
def __init__(self):
self.hotelModel = loader.loadModel("menuBG/menuback")
self.hotelModel.reparentTo(render)
self.hotelModel.stash()
# setup some lights
plight = PointLight("mapgen_plight")
plight.setColor(VBase4(0.45, 0.35, 0.35, 1))
self.plnp = self.hotelModel.attachNewNode(plight)
self.plnp.setPos(-3, 3, 5)
base.render.setLight(self.plnp)
# setup a default ambient light
alight = AmbientLight("mapgen_alight")
alight.setColor(VBase4(0.20, 0.20, 0.28, 1))
self.alnp = self.hotelModel.attachNewNode(alight)
base.render.setLight(self.alnp)
sun = DirectionalLight('sun')
sun.setColor(VBase4(0.8, 0.8, 0.8, 1))
lens = PerspectiveLens()
lens.setFar(50)
lens.setFov(80, 80)
sun.setLens(lens)
ms = 1024 #graphicMgr.shadowMapSize
sun.setShadowCaster(True, ms, ms)
self.sunnp = self.hotelModel.attachNewNode(sun)
self.sunnp.setHpr(85, -50, 0)
self.sunnp.setPos(12, 0, 10)
base.render.setLight(self.sunnp)
def __setDirectionalLight(self, props):
light = DirectionalLight(props['name'])
light.setShadowCaster(props['castShadows'], 1024, 1024)
lens = PerspectiveLens()
light.setLens(lens)
lens.setFov(1200 / props['pos'].z)
return self.__createLight(light, props)
def setup_direct_light(self, angle_1, angle_2, angle_3, x, y, z):
directionalLight = DirectionalLight("directionalLight")
directionalLight.setDirection(LVector3(angle_1, angle_2, angle_3))
directionalLight.setColor((0.6, 0.6, 0.6, 1))
directionalLight.setShadowCaster(True, 2048, 2048)
light = self.base.render.attachNewNode(directionalLight)
self.direct_light.append(light)
self.base.render.setLight(light)
def buildSubType(self):
"""Build the light with the given subType"""
if self.subType == "pointType":
# make a point light
c = self.color
pointLight = PointLight(self.name)
pointLight.setColor(VBase4(c[0], c[1], c[2], c[3]))
pointLight.setShadowCaster(True, 512, 512)
plnp = self.renderObjectsLight.attachNewNode(pointLight)
plnp.setPos(self.position)
self.lightNP = plnp
self.setLightSwitch(True)
if self.subType == "directType":
# make a directional light
c = self.color
directLight = DirectionalLight(self.name)
directLight.setColor(VBase4(c[0], c[1], c[2], c[3]))
directLight.setShadowCaster(True, 512, 512)
dlnp = self.renderObjectsLight.attachNewNode(directLight)
#dlnp.setHpr(0, -60, 0) # no idea why its like that.. but it works
self.lightNP = dlnp
self.setLightSwitch(True)
if self.subType == "ambientType":
# make a ambient light
c = self.color
ambientLight = AmbientLight(self.name)
ambientLight.setColor(VBase4(c[0], c[1],c[2], c[3]))
alnp = self.renderObjectsLight.attachNewNode(ambientLight)
self.lightNP = alnp
self.setLightSwitch(True)
if self.subType == "spotType":
# make a spot light
# lookAtObj = _object.getTag("lookAt") get rid of this.
c = self.color
spotLight = Spotlight(self.name)
spotLight.setColor(VBase4(c[0], c[1], c[2], c[3]))
spotLight.setShadowCaster(True, 512, 512)
lens = PerspectiveLens()
spotLight.setLens(lens)
slnp = self.renderObjectsLight.attachNewNode(spotLight)
slnp.setPos(self.position)
slnp.setHpr(self.hpr)
# Find out if this is really the only option
# because setHpr doesnt seem to have any effect.
# lookAt would be okay but that means adding anothe type
#slnp.lookAt(self.main.GameObjects["player"].collisionBody)
self.lightNP = slnp
self.setLightSwitch(True)
class Game(ShowBase):
def __init__(self):
ShowBase.__init__(self)
self.setBackgroundColor(0.2, 0.2, 0.2)
self.accept("escape", self.taskMgr.stop)
#self.accept("mouse1", self.onClick)
#self.accept("mouse2", self.onClick2)
self.globalClock = ClockObject()
self.addLight()
self.liner = LineDrawer(self)
self.taskMgr.add(self.update, "update")
def update(self, task):
self.globalClock.tick()
t = self.globalClock.getFrameTime()
#print t
dt = self.globalClock.getDt()
return task.cont
def addLight(self):
self.render.clearLight()
self.lightCenter = self.render.attachNewNode(PandaNode("center"))
#self.lightCenter.setCompass()
# ambient light
self.ambientLight = AmbientLight('ambientLight')
self.ambientLight.setColor(Vec4(0.5, 0.5, 0.5, 1))
self.alight = self.lightCenter.attachNewNode(self.ambientLight)
self.render.setLight(self.alight)
# point light
self.pointlight = PointLight("pLight")
self.light = self.lightCenter.attachNewNode(self.pointlight)
self.pointlight.setColor(Vec4(0.8, 0.8, 0.8, 1))
self.light.setPos(0, 0, 2)
self.render.setLight(self.light)
# directional light
self.dirlight = DirectionalLight("dLight")
self.dlight = self.lightCenter.attachNewNode(self.dirlight)
self.dirlight.setColor(Vec4(0.8, 0.8, 0.8, 1))
self.dirlight.setShadowCaster(True)
self.dlight.setPos(0, 0, 5)
self.dlight.lookAt(5, 10, 0)
self.render.setLight(self.dlight)
self.render.setShaderAuto()
class Game(ShowBase):
def __init__(self):
ShowBase.__init__(self)
self.setBackgroundColor(0.2,0.2,0.2)
self.accept("escape", self.taskMgr.stop)
#self.accept("mouse1", self.onClick)
#self.accept("mouse2", self.onClick2)
self.globalClock = ClockObject()
self.addLight()
self.liner = LineDrawer(self)
self.taskMgr.add(self.update, "update")
def update(self, task):
self.globalClock.tick()
t = self.globalClock.getFrameTime()
#print t
dt = self.globalClock.getDt()
return task.cont
def addLight(self):
self.render.clearLight()
self.lightCenter = self.render.attachNewNode(PandaNode("center"))
#self.lightCenter.setCompass()
# ambient light
self.ambientLight = AmbientLight('ambientLight')
self.ambientLight.setColor(Vec4(0.5,0.5,0.5, 1))
self.alight = self.lightCenter.attachNewNode(self.ambientLight)
self.render.setLight(self.alight)
# point light
self.pointlight = PointLight("pLight")
self.light = self.lightCenter.attachNewNode(self.pointlight)
self.pointlight.setColor(Vec4(0.8,0.8,0.8,1))
self.light.setPos(0,0,2)
self.render.setLight(self.light)
# directional light
self.dirlight = DirectionalLight("dLight")
self.dlight = self.lightCenter.attachNewNode(self.dirlight)
self.dirlight.setColor(Vec4(0.8,0.8,0.8,1))
self.dirlight.setShadowCaster(True)
self.dlight.setPos(0,0,5)
self.dlight.lookAt(5,10,0)
self.render.setLight(self.dlight)
self.render.setShaderAuto()
def __init__(self, arenaNr):
arenaPath = "levels/arena{}/".format(arenaNr)
self.arena = loader.loadModel(arenaPath + "arena")
self.arena.setScale(2)
self.arena.reparentTo(render)
self.arena.hide()
ambientLight = AmbientLight("ambient_light")
ambientLight.setColor((0.2, 0.2, 0.2, 1))
self.alnp = render.attachNewNode(ambientLight)
sunLens = PerspectiveLens()
sunLens.setFilmSize(50)
sun = DirectionalLight("sun")
sun.setColor((1, 1, 1, 1))
sun.setShadowCaster(True, 2048, 2048)
sun.setScene(render)
#sun.showFrustum()
self.ambientSound = None
self.levelParticles = None
if arenaNr == 1:
sunLens.setNearFar(25, 45)
sun.setLens(sunLens)
self.sunNp = render.attachNewNode(sun)
self.sunNp.setPos(-10, -10, 30)
self.sunNp.lookAt(0, 0, 0)
self.ambientSound = loader.loadSfx(
"assets/audio/ambientLevel1.ogg")
self.ambientSound.setLoop(True)
self.fog = Fog("Outside Fog")
self.fog.setColor(0.3, 0.3, 0.5)
self.fog.setExpDensity(0.025)
self.levelParticles = ParticleEffect()
self.levelParticles.loadConfig("assets/fx/Leafs.ptf")
self.levelParticles.start(parent=render2d, renderParent=render2d)
elif arenaNr == 2:
sunLens.setFov(120, 40)
sunLens.setNearFar(2, 10)
sun.setLens(sunLens)
self.sunNp = render.attachNewNode(sun)
self.sunNp.setPos(0, 0, 5)
self.sunNp.lookAt(0, 0, 0)
self.fog = Fog("Temple Fog")
self.fog.setColor(0, 0, 0)
self.fog.setExpDensity(0.065)
def __init__(self, arenaNr):
arenaPath = "levels/arena%d/" % arenaNr
self.arena = loader.loadModel(arenaPath + "arena")
self.arena.setScale(2)
self.arena.reparentTo(render)
self.arena.hide()
ambientLight = AmbientLight("ambient_light")
ambientLight.setColor((0.2, 0.2, 0.2, 1))
self.alnp = render.attachNewNode(ambientLight)
sunLens = PerspectiveLens()
sunLens.setFilmSize(50)
sun = DirectionalLight("sun")
sun.setColor((1, 1, 1, 1))
sun.setShadowCaster(True, 2048, 2048)
sun.setScene(render)
#sun.showFrustum()
self.ambientSound = None
self.levelParticles = None
if arenaNr == 1:
sunLens.setNearFar(25,45)
sun.setLens(sunLens)
self.sunNp = render.attachNewNode(sun)
self.sunNp.setPos(-10, -10, 30)
self.sunNp.lookAt(0,0,0)
self.ambientSound = loader.loadSfx("assets/audio/ambientLevel1.ogg")
self.ambientSound.setLoop(True)
self.fog = Fog("Outside Fog")
self.fog.setColor(0.3,0.3,0.5)
self.fog.setExpDensity(0.025)
self.levelParticles = ParticleEffect()
self.levelParticles.loadConfig("assets/fx/Leafs.ptf")
self.levelParticles.start(parent = render2d, renderParent = render2d)
elif arenaNr == 2:
sunLens.setFov(120, 40)
sunLens.setNearFar(2,10)
sun.setLens(sunLens)
self.sunNp = render.attachNewNode(sun)
self.sunNp.setPos(0, 0, 5)
self.sunNp.lookAt(0,0,0)
self.fog = Fog("Temple Fog")
self.fog.setColor(0,0,0)
self.fog.setExpDensity(0.065)
def __create_directional_light(self,
lightId,
lightColor,
lightHpr,
shadow = True):
directionalLight = DirectionalLight(lightId)
directionalLight.setColor(lightColor)
directionalLight.setShadowCaster(shadow)
directionalLightNP = NodePath(directionalLight)
directionalLightNP.setHpr(lightHpr)
return directionalLightNP
def setupLights(self):
ambientLight = AmbientLight("ambientLight")
ambientLight.setColor((0.2, 0.2, 0.2, 1.0))
directionalLight = DirectionalLight("directionalLight")
directionalLight.setDirection(Vec3(0.0, 0.2, -1.0).normalized())
directionalLight.setColor((0.9, 0.9, 0.9, 1.0))
directionalLight.setShadowCaster(True, 1024, 1024)
directionalLight.getLens().setNearFar(-1000.0, 1000)
directionalLight.getLens().setFilmSize(200, 200)
directionalLight.getLens().setViewVector(
directionalLight.getDirection(), Vec3(1, 0, 0))
self.directionalLightNode = render.attachNewNode(directionalLight)
render.setLight(self.directionalLightNode)
render.setLight(render.attachNewNode(ambientLight))
def createLights(self):
"""Create an ambient light and a spotlight for shadows"""
self.render.clearLight()
alight = AmbientLight("ambientLight")
alight.setColor(Vec4(0.7, 0.7, 0.7, 1))
alightNP = self.worldRender.attachNewNode(alight)
self.worldRender.setLight(alightNP)
# Create a directional light for shadows
dlight = DirectionalLight("dLight")
dlight.setColor(Vec4(0.6, 0.6, 0.6, 1))
dlight.setShadowCaster(True, 1024, 1024)
dlight.getLens().setNearFar(1, 15)
dlight.getLens().setFilmSize(128, 128)
dlightNP = self.worldRender.attachNewNode(dlight)
dlightNP.setPos(0, 0, 10)
dlightNP.lookAt(0, 0, 0)
self.worldRender.setLight(dlightNP)
def createLighting(self):
light = DirectionalLight("light")
light.setColor(VBase4(0.4, 0.4, 0.4, 1))
light.setShadowCaster(True)
light.getLens().setNearFar(100.0, 400.0)
light.getLens().setFilmSize(400, 400)
# light.showFrustum()
np = self.render.attachNewNode(light)
np.setPos(100, -100, 200)
np.lookAt(0, 0, -100)
self.render.setLight(np)
light = AmbientLight("ambient")
light.setColor(VBase4(0.2, 0.2, 0.2, 1))
np = self.render.attachNewNode(light)
self.render.setLight(np)
def __init__(self, base):
self.base = base
# model
self.model = self.base.loader.loadModel("models/terrain")
self.model.reparentTo(self.base.render)
# lights
# ambient
alight = AmbientLight("alight")
alight.setColor(Vec4(0.4, 0.4, 0.4, 1))
alightP = self.base.render.attachNewNode(alight)
self.base.render.setLight(alightP)
# directional
sun = DirectionalLight("sun")
sun.setColor(Vec4(1, 0.973, 0.491, 1))
sun.setShadowCaster(True, 4096, 4096)
sun.getLens().setFilmSize(Vec2(30, 30))
sun.getLens().setNearFar(10, 100)
sun.getLens().setFov(100)
sunP = self.base.render.attachNewNode(sun)
sunP.setHpr(10, -60, 10)
self.base.render.setLight(sunP)
def background(self):
scene = loader.loadModel('maps/menu/terrain')
scene.reparentTo(self.root_node)
self.actor = Actor('actors/char', {'walk': 'actors/char-walk', 'hands': 'actors/char-hands'})
self.actor.reparentTo(scene)
self.actor.setPos(0, 1, 0)
moon = DirectionalLight('moon')
moon.setColor(hex_to_rgb('4d5acc', brightness=.2))
moon.setShadowCaster(True, 2048, 2048)
moon_np = scene.attachNewNode(moon)
moon_np.setPos(-5, -5, 10)
moon_np.lookAt(0, 0, 0)
scene.setLight(moon_np)
self.bonfire = prefab.Bonfire(scene)
self.bonfire.holder.setPos(0, -.08, .1)
ambient = AmbientLight('alight')
ambient.setColor(hex_to_rgb('141414'))
ambient_np = scene.attachNewNode(ambient)
scene.setLight(ambient_np)
def spin_camera_task(task):
angle_degrees = task.time * 2.0
if angle_degrees > 360:
angle_degrees -= 360
angle_radians = angle_degrees * (pi / 180)
base.camera.setPos(3 * sin(angle_radians), -3 * cos(angle_radians), 1)
base.camera.setHpr(angle_degrees, 4, 0)
return task.cont
base.taskMgr.add(spin_camera_task, 'spin_camera')
def __init__(self):
ShowBase.__init__(self)
gltf.patch_loader(self.loader)
properties = WindowProperties()
properties.setSize(1000, 750)
self.disableMouse()
self.environment = loader.loadModel("environment/island.gltf")
self.environment.reparentTo(render)
self.environment.setPos(0,0,-3)
self.environment.setHpr(0,-90,0)
""" I put this becase I think there is a default light that I cant reach and manupulate.
thets why I setLightsOff first. Otherwise Ican't create or cast shadows etc. """
self.environment.setLightOff()
mats = self.environment .findAllMaterials()
mats[0].clearBaseColor()
mats[1].clearBaseColor()
mats[0].setShininess(200)
mats[1].setShininess(100)
""" In this block I create a textureBuffer and create camera
on that buffer that its display region is upper right corner of the window
I use that region to create saveScreenShot xxxx or create a numpy array out of it
(numpy_image_data)
second try is to make a screenshot directly from the buffer which is not so important
Both works though """
self.useTrackball()
# ambientLight = AmbientLight("ambient light")
# ambientLight.setColor(Vec4(0.2, 0.2, 0.2, 1))
# self.ambientLightNodePath = render.attachNewNode(ambientLight)
# render.setLight(self.ambientLightNodePath)
# In the body of your code
mainLight = DirectionalLight("main light")
self.mainLightNodePath = render.attachNewNode(mainLight)
# Turn it around by 45 degrees, and tilt it down by 45 degrees
mainLight.setShadowCaster(True,1000,1000)
self.mainLightNodePath.setHpr(45, -45, 0)
render.setLight(self.mainLightNodePath)
""" I put it here again"""
self.environment.setLight(self.mainLightNodePath)
pointLight = PointLight("point light")
pointLight.setShadowCaster(True,1000,1000)
self.pointLightNodePath = render.attachNewNode(pointLight)
self.pointLightNodePath.setPos(0,0,10)
render.setLight(self.pointLightNodePath)
""" and again """
self.environment.setLight(self.pointLightNodePath)
render.setShaderAuto()
self.tempActor2 = Actor("models/cube.bam")
self.tempActor2.reparentTo(render)
self.tempActor2.setPos(-2, 2, -1)
self.tempActor2.setScale(.2)
self.monkey = Actor("models/monkey")
self.monkey.set_scale(.25)
self.monkey.reparentTo(render)
self.monkey.set_pos(-7,-7,2)
self.monkey.lookAt(self.tempActor2)
self.monkey2 = Actor("models/monkey")
self.monkey2.set_scale(.25)
self.monkey2.reparentTo(render)
self.monkey2.set_pos(0,3,1)
self.monkey2.lookAt(self.tempActor2)
tex=Texture()
self.mybuffer = self.win.makeTextureBuffer("My Buffer", 512, 512,tex,to_ram=True)
self.mybuffer.setSort(-100)
mycamera = self.makeCamera(self.mybuffer,displayRegion=(.5,1,.5,1))
mycamera.reparentTo(self.monkey)
tex2=Texture()
mybuffer2 = self.win.makeTextureBuffer("My Buffer2", 512, 512,tex,to_ram=True)
mybuffer2.setSort(-500)
mycamera2 = self.makeCamera(mybuffer2,displayRegion=(0,.5,0,.5))
mycamera2.reparentTo(self.monkey2)
self.graphicsEngine.renderFrame()
print(self.mybuffer.getActiveDisplayRegions())
"""shadows for cameras missing here in screenshot"""
save_it=self.mybuffer.getActiveDisplayRegion(0).saveScreenshotDefault('1111')
my_output=self.mybuffer.getActiveDisplayRegion(0).getScreenshot()
numpy_image_data=np.array(my_output.getRamImageAs("RGB"), np.float32)
"""shadows for cameras missing here in screenshot"""
save_it2=mybuffer2.getActiveDisplayRegion(0).saveScreenshotDefault('2222')
my_output2=mybuffer2.getActiveDisplayRegion(0).getScreenshot()
numpy_image_data2=np.array(my_output2.getRamImageAs("RGB"), np.float32)
print(numpy_image_data)
file_name=Filename.fromOsSpecific("save_gameDat_001.png")
self.mybuffer.saveScreenshot(file_name)
print('Cameras')
print(self.camList)
print('Number Of Display Regions')
print(self.win.getNumDisplayRegions())
print('Active Display Regions')
print(self.win.getActiveDisplayRegions())
print(self.win.getDisplayRegions())
print('Number Of Display Regions')
print(self.win.getNumDisplayRegions())
self.keyMap = {
"up" : False,
"down" : False,
"left" : False,
"right" : False,
"shoot" : False
}
self.accept("w", self.updateKeyMap, ["up", True])
self.accept("w-up", self.updateKeyMap, ["up", False])
self.accept("s", self.updateKeyMap, ["down", True])
self.accept("s-up", self.updateKeyMap, ["down", False])
self.accept("a", self.updateKeyMap, ["left", True])
self.accept("a-up", self.updateKeyMap, ["left", False])
self.accept("d", self.updateKeyMap, ["right", True])
self.accept("d-up", self.updateKeyMap, ["right", False])
self.accept("mouse1", self.updateKeyMap, ["shoot", True])
self.accept("mouse1-up", self.updateKeyMap, ["shoot", False])
self.updateTask = taskMgr.add(self.update, "update")
def __init__(self):
ShowBase.__init__(self)
self.calibrated = False
self.disableMouse()
self.time_total_img = []
self.time_total_sens = []
# ENV SETUP
self.env = quad(time_int_step, max_timesteps, direct_control=1, T=T)
self.sensor = sensor(self.env)
self.aux_dl = dl_in_gen(T, self.env.state_size, self.env.action_size)
self.error = []
state_dim = self.aux_dl.deep_learning_in_size
self.policy = ActorCritic(state_dim, action_dim=4, action_std=0).to(device)
#CONTROLLER SETUP
try:
self.policy.load_state_dict(torch.load('./controller/PPO_continuous_solved_drone.pth',map_location=device))
print('Saved policy loaded')
except:
print('Could not load policy')
sys.exit(1)
n_parameters = sum(p.numel() for p in self.policy.parameters())
print('Neural Network Number of Parameters: %i' %n_parameters)
# Load the environment model.
self.scene = self.loader.loadModel(mydir + "/models/city.egg")
self.scene.reparentTo(self.render)
self.scene.setScale(1, 1, 1)
self.scene.setPos(0, 0, 0)
# Load the skybox
self.skybox = self.loader.loadModel(mydir + "/models/skybox.egg")
self.skybox.setScale(100,100,100)
self.skybox.setPos(0,0,-500)
self.skybox.reparentTo(self.render)
# Also add an ambient light and set sky color.
skycol = panda3d.core.VBase3(135 / 255.0, 206 / 255.0, 235 / 255.0)
self.set_background_color(skycol)
alight = AmbientLight("sky")
alight.set_color(panda3d.core.VBase4(skycol * 0.04, 1))
alight_path = render.attachNewNode(alight)
render.set_light(alight_path)
# 4 perpendicular lights (flood light)
dlight1 = DirectionalLight('directionalLight')
dlight1.setColor(panda3d.core.Vec4(0.3,0.3,0.3,0.3))
dlight1NP = render.attachNewNode(dlight1)
dlight1NP.setHpr(0,0,0)
dlight2 = DirectionalLight('directionalLight')
dlight2.setColor(panda3d.core.Vec4(0.3,0.3,0.3,0.3))
dlight2NP = render.attachNewNode(dlight2)
dlight2NP.setHpr(-90,0,0)
dlight3 = DirectionalLight('directionalLight')
dlight3.setColor(panda3d.core.Vec4(0.3,0.3,0.3,0.3))
dlight3NP = render.attachNewNode(dlight3)
dlight3NP.setHpr(-180,0,0)
dlight4 = DirectionalLight('directionalLight')
dlight4.setColor(panda3d.core.Vec4(0.3,0.3,0.3,0.3))
dlight4NP = render.attachNewNode(dlight4)
dlight4NP.setHpr(-270,0,0)
render.setLight(dlight1NP)
render.setLight(dlight2NP)
render.setLight(dlight3NP)
render.setLight(dlight4NP)
# 1 directional light (Sun)
dlight = DirectionalLight('directionalLight')
dlight.setColor(panda3d.core.Vec4(1, 1, 1, 1)) # directional light is dim green
dlight.getLens().setFilmSize(panda3d.core.Vec2(50, 50))
dlight.getLens().setNearFar(-100, 100)
dlight.setShadowCaster(True, 4096*2, 4096*2)
# dlight.show_frustum()
dlightNP = render.attachNewNode(dlight)
dlightNP.setHpr(0,-65,0)
#Turning shader and lights on
render.setShaderAuto()
render.setLight(dlightNP)
# Add the spinCameraTask procedure to the task manager.
self.taskMgr.add(self.calibrate, 'Camera Calibration')
self.taskMgr.add(self.drone_position_task, 'Drone Position')
# Load and transform the quadrotor actor.
self.quad = self.loader.loadModel(mydir + '/models/quad.egg')
self.quad.reparentTo(self.render)
self.prop_1 = self.loader.loadModel(mydir + '/models/prop.egg')
self.prop_1.setPos(-0.26,0,0)
self.prop_1.reparentTo(self.quad)
self.prop_2 = self.loader.loadModel(mydir + '/models/prop.egg')
self.prop_2.setPos(0,0.26,0)
self.prop_2.reparentTo(self.quad)
self.prop_3 = self.loader.loadModel(mydir + '/models/prop.egg')
self.prop_3.setPos(0.26,0,0)
self.prop_3.reparentTo(self.quad)
self.prop_4 = self.loader.loadModel(mydir + '/models/prop.egg')
self.prop_4.setPos(0,-0.26,0)
self.prop_4.reparentTo(self.quad)
# Load the checkerboard actor
self.checker = self.loader.loadModel(mydir+ '/models/checkerboard.egg')
self.checker.reparentTo(self.render)
self.checker_scale = 0.5
self.checker_sqr_size = 0.2046
self.checker.setScale(self.checker_scale, self.checker_scale, 1)
self.checker.setPos(3*self.checker_scale*self.checker_sqr_size, 2.5*self.checker_scale*self.checker_sqr_size, 0.001)
#env cam
self.cam.node().getLens().setFilmSize(36, 24)
self.cam.node().getLens().setFocalLength(45)
self.cam.setPos(5,5,7)
self.cam.reparentTo(self.render)
self.cam.lookAt(self.quad)
if IMG_POS_DETER:
self.taskMgr.add(self.pos_deter, 'Position Determination')
window_size = (self.win.getXSize(), self.win.getYSize())
self.buffer = self.win.makeTextureBuffer('Buffer', *window_size, None, True)
self.tex = self.buffer.getTexture()
self.cam_1 = self.makeCamera(self.buffer)
self.cam_1.setName('cam_1')
self.cam_1.node().getLens().setFilmSize(36, 24)
self.cam_1.node().getLens().setFocalLength(45)
self.cam_1.reparentTo(self.quad)
self.cam_1.setPos(0,0,0.01)
self.cam_1.lookAt(self.quad)
self.pipe = panda3d.core.GraphicsPipeSelection.get_global_ptr().make_module_pipe('pandagl')
input('Start?')
class Starfox(ShowBase):
def __init__(self):
self.height = 500
super().__init__(self)
self.scene = self.loader.loadModel("./models/world.egg")
playerTexture = loader.loadTexture("models/starfoxShip.jpg")
enemyTexture = loader.loadTexture("models/enemyShip.jpg")
bulletTexture = loader.loadTexture("models/shot.png")
self.scene.reparentTo(self.render)
base.setBackgroundColor(0.1, 0.1, 0.1, 1)
self.player = self.scene.find("player")
self.player.setPythonTag("ObjectController", Player(self.player))
self.player.setTexture(playerTexture)
self.building_enemy = self.scene.find("building_enemy")
self.dynamic_enemy = self.scene.find("enemy1")
self.dynamic_enemy.setTexture(enemyTexture)
self.bullet = self.scene.find("bullet")
self.bullet.setTexture(bulletTexture)
base.cTrav = CollisionTraverser()
self.CollisionHandlerEvent = CollisionHandlerEvent()
base.enableParticles()
self.CollisionHandlerEvent.addInPattern('into-%in')
self.CollisionHandlerEvent.addOutPattern('out-%in')
self.accept('into-collision_player', self.crash)
self.accept('into-collision_plane', self.crash)
self.accept('into-collision_enemy', self.crash)
base.cTrav.addCollider(self.scene.find("player/collision**"),
self.CollisionHandlerEvent)
base.cTrav.addCollider(self.scene.find("basePlane/collision**"),
self.CollisionHandlerEvent)
self.player.find("**collision**").node().setFromCollideMask(0x3)
self.player.find("**collision**").node().setIntoCollideMask(0x3)
self.dynamic_enemy.find("**collision**").node().setFromCollideMask(0x5)
self.dynamic_enemy.find("**collision**").node().setIntoCollideMask(0x5)
self.building_enemy.find("**collision**").node().setFromCollideMask(
0x5)
self.building_enemy.find("**collision**").node().setIntoCollideMask(
0x5)
#base.cTrav.showCollisions(self.render)
self.taskMgr.add(self.update, "update")
InputManager.initWith(self, [
InputManager.arrowUp, InputManager.arrowDown,
InputManager.arrowLeft, InputManager.arrowRight,
InputManager.space, InputManager.keyX, InputManager.keyV
])
self.rails = self.scene.attachNewNode("rails")
self.scene.find("basePlane").setHpr(70, 0, 0)
self.rails.setPos(self.scene, 0, 0, 0)
self.player.reparentTo(self.rails)
self.player.setPos(self.rails, 0, 0, 0)
self.rails_y = -50
self.createStaticEnemy(self.building_enemy, 0, 50, 0)
self.createStaticEnemy(self.building_enemy, -50, 50, 0)
self.createStaticEnemy(self.building_enemy, -100, 50, 0)
self.createStaticEnemy(self.building_enemy, -70, 130, 0)
self.createStaticEnemy(self.building_enemy, -120, 80, 0)
self.createStaticEnemy(self.building_enemy, -220, 130, 0)
DynamicEnemy(self.dynamic_enemy,
self.scene,
Vec3(-230, 140, 10),
base.cTrav,
self.CollisionHandlerEvent,
type=ENEMY_TYPE.CHASER)
#DynamicEnemy(self.dynamic_enemy, self.scene, Vec3(-240,160,10) , base.cTrav, self.CollisionHandlerEvent)
#DynamicEnemy(self.dynamic_enemy, self.scene, Vec3(-250,200,10) , base.cTrav, self.CollisionHandlerEvent)
#DynamicEnemy(self.dynamic_enemy, self.scene, Vec3(-270,160,10) , base.cTrav, self.CollisionHandlerEvent)
#DynamicEnemy(self.dynamic_enemy, self.scene, Vec3(-250,200,10) , base.cTrav, self.CollisionHandlerEvent)
self.building_enemy.hide()
self.dynamic_enemy.hide()
self.fog = Fog("fog")
self.fog.setColor(0.1, 0.1, 0.1)
self.fog.setExpDensity(.3)
self.fog.setLinearRange(50, 150)
self.fog.setLinearFallback(45, 160, 320)
self.render.setFog(self.fog)
self.dirLight = DirectionalLight("dir light")
self.dirLight.color = (0.7, 0.7, 1, 1)
self.dirLightPath = self.render.attachNewNode(self.dirLight)
self.dirLightPath.setHpr(45, -45, 0)
self.dirLight.setShadowCaster(True, 512, 512)
render.setLight(self.dirLightPath)
filters = CommonFilters(base.win, base.cam)
filters.setBloom(size="large", mintrigger=0.2)
self.render.setShaderAuto()
self.initSounds()
self.initUI()
self.onGame = False
def initUI(self):
self.font = loader.loadFont('./fonts/Magenta.ttf')
self.lifes = [
OnscreenImage(image='./UI/fox-icon-png-8.png',
pos=(1.1, 0, 0.8),
scale=0.05),
OnscreenImage(image='./UI/fox-icon-png-8.png',
pos=(1.2, 0, 0.8),
scale=0.05)
]
self.lifes[0].setTransparency(True)
self.lifes[1].setTransparency(True)
self.dialogScreen = DirectDialog(frameSize=(-0.7, 0.7, -0.7, 0.7),
relief=DGG.FLAT)
s = OnscreenImage(image='./UI/fox-icon-png-8.png',
pos=(0, 0, -0.2),
scale=0.20,
parent=self.dialogScreen)
s.setTransparency(True)
self.titleUI = DirectLabel(text="Starfox Region 4",
parent=self.dialogScreen,
scale=0.1,
pos=(0, 0, .2),
text_font=self.font)
self.btn = DirectButton(text="Start",
command=self.startGame,
pos=(0, 0, 0),
parent=self.dialogScreen,
scale=0.07)
def startGame(self):
self.dialogScreen.hide()
self.flyingSound.play()
self.onGame = True
self.btn.hide()
def initSounds(self):
self.audio3d = Audio3DManager.Audio3DManager(base.sfxManagerList[0],
self.camera)
self.flyingSound = self.audio3d.loadSfx(
"./sounds/great fox flying.mp3")
self.flyingSound.setLoop(True)
self.audio3d.attachSoundToObject(self.flyingSound, self.player)
self.audio3d.setSoundVelocityAuto(self.flyingSound)
self.audio3d.setListenerVelocityAuto()
#self.audio3d.setDistanceFactor(100)
self.audio3d.setDropOffFactor(0)
self.fireSound = self.audio3d.loadSfx(
"./sounds/arwing double laser one shot.mp3")
self.crashSound = self.audio3d.loadSfx("./sounds/break.mp3")
def createStaticEnemy(self, original, px, py, pz):
be = original.copyTo(self.scene)
be.setPos(px, py, pz)
base.cTrav.addCollider(be.find("**collision**"),
self.CollisionHandlerEvent)
"""
self.pointLight = PointLight("point light")
self.pointLight.color = (1,1,1,1)
self.pointLightPath = self.render.attachNewNode(self.pointLight)
self.pointLightPath.setPos(px,py,pz)
self.pointLight.attenuation = (1,0,0)
#self.pointLight.setShadowCaster(True,1024,1024)
self.render.setLight(self.pointLightPath)
"""
def crash(self, evt):
self.crashSound.play()
objectInto = evt.getIntoNodePath().node().getParent(0).getPythonTag(
"ObjectController")
objectFrom = evt.getFromNodePath().node().getParent(0).getPythonTag(
"ObjectController")
if (objectInto != None):
objectInto.crash(objectFrom)
if (objectFrom != None):
objectFrom.crash(objectInto)
lifes = self.player.getPythonTag("ObjectController").getLifes()
if (lifes <= 0):
self.onGame = False
self.dialogScreen.show()
self.flyingSound.stop()
def update(self, evt):
#self.camera.setPos(0,-100,100)
lifes = self.player.getPythonTag("ObjectController").getLifes()
if (lifes > 2):
self.lifes[0].show()
self.lifes[1].show()
elif (lifes > 1):
self.lifes[0].show()
self.lifes[1].hide()
elif (lifes > 0):
self.lifes[0].hide()
self.lifes[1].hide()
self.camera.lookAt(self.player)
self.rails.setPos(self.scene, Path.getXOfY(self.rails_y), self.rails_y,
12.4)
self.rails.setHpr(Path.getHeading(self.rails_y), 0, 0)
self.dirLight.color = (self.rails_y / 600, 0.7, 1, 1)
self.camera.setHpr(Path.getHeading(self.rails_y), 0, 0)
if (self.onGame):
self.rails_y = self.rails_y + globalClock.getDt() * 10
#self.player.setPos(self.rails, 0, 0, sin(self.z/10.0)*40 )
relX, relZ, isShooting = self.player.getPythonTag(
"ObjectController").update(self.rails, globalClock.getDt())
self.camera.setPos(self.rails, relX, -30, relZ)
if (isShooting):
self.fireSound.play()
b = Bullet(
self.bullet, self.scene, self.player.getPos(self.scene),
base.cTrav, self.CollisionHandlerEvent,
self.scene.getRelativeVector(self.player,
Vec3(0, 1, 0)), 40, 0x4)
enemies = self.scene.findAllMatches("dynamicEnemy")
for e in enemies:
enemy = e.getPythonTag("ObjectController")
enemy.update(self.scene, globalClock.getDt(), self.player,
self.bullet)
bullets = self.scene.findAllMatches("bulletC")
for b in bullets:
bullet = b.getPythonTag("ObjectController")
bullet.update(self.scene, globalClock.getDt(), self.player)
return Task.cont
def load_scene(self):
# ground
sandbox = loader.loadModel('maps/practice/sandbox')
np = self.root_node.attachNewNode(BulletRigidBodyNode('Mesh'))
np.node().addShape(bullet_shape_from(sandbox))
np.setPos(0, 0, 0)
np.setCollideMask(BitMask32.allOn())
self.physics.world.attachRigidBody(np.node())
sandbox.reparentTo(np)
moon = DirectionalLight('moon')
moon.setColor(hex_to_rgb('ffffff'))
moon.setShadowCaster(True, 2048, 2048)
moon_np = self.root_node.attachNewNode(moon)
moon_np.setPos(-5, -5, 10)
moon_np.lookAt(0, 0, 0)
self.root_node.setLight(moon_np)
moon = DirectionalLight('sun')
moon.setColor(hex_to_rgb('666666'))
moon.setShadowCaster(True, 2048, 2048)
moon_np = self.root_node.attachNewNode(moon)
moon_np.setPos(5, 5, 10)
moon_np.lookAt(0, 0, 0)
self.root_node.setLight(moon_np)
# dynamic sphere
np = self.root_node.attachNewNode(BulletRigidBodyNode('Sphere'))
np.node().addShape(BulletSphereShape(1))
np.node().setMass(3.0)
np.setPos(5, 5, 2)
self.physics.world.attachRigidBody(np.node())
ball = loader.loadModel('geometry/ball')
ball.reparentTo(np)
self.char_marks.add('ball', ball, OnscreenText(text='sphere', scale=0.07), 1)
# dynamic box
np = self.root_node.attachNewNode(BulletRigidBodyNode('Box'))
np.node().addShape(BulletBoxShape(Vec3(0.5, 0.5, 0.5)))
np.node().setMass(1.0)
np.setPos(-1, -2, 2)
self.physics.world.attachRigidBody(np.node())
np.node().applyCentralImpulse((0, 2, 7))
box = loader.loadModel('geometry/box')
box.reparentTo(np)
self.char_marks.add('box', box, OnscreenText(text='cube', scale=0.06), 0.5)
# static
np = self.root_node.attachNewNode(BulletRigidBodyNode('Static'))
np.node().addShape(BulletBoxShape(Vec3(0.5, 0.5, 0.5)))
np.setPos(1, 2, 0.8)
self.physics.world.attachRigidBody(np.node())
box = loader.loadModel('geometry/box')
box.reparentTo(np)
def move_box(task):
angle_degrees = task.time * 12.0
if angle_degrees > 360:
angle_degrees -= 360
angle_radians = angle_degrees * (pi / 180)
np.setPos(5 * sin(angle_radians), -5 * cos(angle_radians), .5)
np.setHpr(angle_degrees, 4, 0)
return task.cont
base.taskMgr.add(move_box, 'move_box')
self.char_marks.add('static', box, OnscreenText(text='static', scale=0.08), 0.5)
class Viewer3D(ShowBase):
modes = {'CPK': 'load_CPK', 'backbone': 'load_bbone'}
def __init(self, pdb_file, mode='CPK'):
ShowBase.__init__(self)
if mode not in modes.keys():
raise Exception('No se reconoce el modo de visualizacion %s' %
mode)
self.mode = mode
#Desglosamos archivo PDB
parser = PDBParser(QUIET=True, PERMISSIVE=True)
structure = parser.get_structure('Structure', pdb_file)
#Creamos el modelo
self.pnode = render.attachNewNode("Model")
if mode == 'CPK':
self.load_CPK(structure, self.pnode)
elif mode == 'backbone':
self.load_bbone(structure, self.pnode)
#elif mode == 'elquesea':
#Colocamos la proteina en el centro
self.pnode.setPos(0, 0, 0)
#Colocamos la camara en el centro
p_radius = self.pnode.getBounds().getRadius()
p_center = self.pnode.getBounds().getCenter()
xc, yc, zc = p_center
base.cam.setPos(xc, -150 - yc - 2 * p_radius, zc)
base.cam.lookAt(xc, yc, zc)
#Luz ambiental
self.ambiente = AmbientLight('aluz')
self.ambiente.setColor(LVecBase4f(0.16, 0.16, 0.17, 1.0))
self.luza = render.attachNewNode(ambiente)
render.setLight(self.luza)
#Luz direccional
self.direccional = DirectionalLight('dluz')
self.direccional.setColor(LVecBase4f(0.8, 0.7, 0.75, 1.0))
self.direccional.setShadowCaster(True, 512, 512)
render.setShaderAuto()
self.luzd = render.attachNewNode(direccional)
self.luzd.setPos(0, -50, 0)
render.setLight(self.luzd)
self.luzd.lookAt(xc, yc, zc)
#Definimos modo de representacion
def load_CPK(self, structure, node):
for atom in structure.get_atoms():
x, y, z = atom.coord
id = atom.get_id()
a = loader.loadModel("data/atom_sphere")
a.setPos(x, y, z)
a.setColor(colorrgba(id))
a.setScale(vrad(id))
a.reparentTo(node)
node.flattenStrong()
def load_bbone(self, structure, node):
for chain in structure.get_chains():
carr = np.random.rand(3, 1)
ccolor = float(carr[0]), float(carr[1]), float(carr[2]), 1.0
can_atoms = [
atom for atom in chain.get_atoms()
if atom.get_name() == 'CA' or atom.get_name() == 'N'
]
can_coordinates = [atom.coord for atom in can_atoms]
for atom in can_atoms:
x, y, z = atom.coord
id = atom.get_id()
a = loader.loadModel("data/atom_sphere")
a.setPos(x, y, z)
a.reparentTo(pnode)
a.setColor(ccolor)
a.setScale(vrad(id) / 2.5)
lines = LineSegs()
lines.setColor(ccolor)
lines.moveTo(can_coordinates[0][0], can_coordinates[0][1],
can_coordinates[0][2])
for i in range(len(can_atoms))[1:]:
lines.drawTo(can_coordinates[i][0], can_coordinates[i][1],
can_coordinates[i][2])
lines.setThickness(6)
lnode = lines.create()
linenp = NodePath(lnode)
linenp.reparentTo(pnode)
node.flattenStrong()
class PandaViewer(ShowBase):
if len(sys.argv[1:]) != 1:
raise SystemExit("Uso: %s Archivo_PDB" % os.path.basename(sys.argv[0]))
def __init__(self):
ShowBase.__init__(self)
self.cloud = False
self.help = False
self.screen_text = []
#Desglosamos archivo PDB
pdbdata = sys.argv[1]
parser = PDBParser(QUIET=True, PERMISSIVE=True)
structure = parser.get_structure('model', pdbdata)
#Hacemos la prediccion DSSP
model = structure[0]
dssp = DSSP(model, pdbdata)
#Creamos los modelos
self.cpknode = render.attachNewNode("CPK")
self.aanode = render.attachNewNode("Aminoacids")
self.bbnode = render.attachNewNode("BackBone")
self.dsspnode = render.attachNewNode("DSSP")
self.nnode = render.attachNewNode("Cloud")
#CPK
for atom in structure.get_atoms():
x, y, z = atom.coord
atomid = atom.get_id()
a = loader.loadModel("data/atom_sphere")
a.setPos(x, y, z)
a.reparentTo(self.cpknode)
a.setColor(colorrgba(atomid))
a.setScale(vrad(atomid))
self.cpknode.flattenStrong()
#Aminoacids
self.residues = [
residue for residue in structure.get_residues()
if residue.get_resname() in resdict.keys()
]
for residue in self.residues:
resid = residue.get_resname()
color = colorrgba(restype(resid))
atoms = [atom for atom in residue.get_atoms()]
for atom in atoms:
x, y, z = atom.coord
atomid = atom.get_id()
a = loader.loadModel("data/atom_sphere")
a.setPos(x, y, z)
a.setColor(color)
a.setScale(vrad(atomid))
a.reparentTo(self.aanode)
self.residues2 = [
residue for residue in structure.get_residues()
if not residue in self.residues and residue.get_resname() != 'HOH'
]
for residue in self.residues2:
atoms = [atom for atom in residue.get_atoms()]
for atom in atoms:
x, y, z = atom.coord
atomid = atom.get_id()
a = loader.loadModel("data/atom_sphere")
a.setPos(x, y, z)
a.setColor(colorrgba(atomid))
a.setScale(vrad(atomid))
a.reparentTo(self.aanode)
self.aanode.flattenStrong()
self.aanode.hide()
#Backbone
for chain in structure.get_chains():
carr = np.random.rand(3, 1)
ccolor = float(carr[0]), float(carr[1]), float(carr[2]), 1.0
can_atoms = [
atom for atom in chain.get_atoms()
if atom.get_name() == 'CA' or atom.get_name() == 'N'
]
can_coordinates = [atom.coord for atom in can_atoms]
for atom in can_atoms:
x, y, z = atom.coord
atomid = atom.get_id()
a = loader.loadModel("data/atom_sphere")
a.setPos(x, y, z)
a.reparentTo(self.bbnode)
a.setColor(ccolor)
a.setScale(vrad(atomid) / 2.5)
lines = LineSegs()
lines.setColor(ccolor)
lines.moveTo(can_coordinates[0][0], can_coordinates[0][1],
can_coordinates[0][2])
for i in range(len(can_atoms))[1:]:
lines.drawTo(can_coordinates[i][0], can_coordinates[i][1],
can_coordinates[i][2])
lines.setThickness(6)
lnode = lines.create()
self.linenp = NodePath(lnode)
self.linenp.instanceTo(self.bbnode)
#Cloud
catoms = [atom for atom in chain.get_atoms()]
for atom in catoms:
x, y, z = atom.coord
atomid = atom.get_id()
a = loader.loadModel("data/atom_sphere")
a.setPos(x, y, z)
a.reparentTo(self.nnode)
a.setColor(ccolor)
a.setScale(vrad(atomid) * 1.1)
self.bbnode.flattenStrong()
self.bbnode.hide()
self.nnode.setTransparency(TransparencyAttrib.MAlpha)
self.nnode.setAlphaScale(0.3)
self.nnode.hide()
#DSSP
self.linenp.instanceTo(self.dsspnode)
self.struct3 = [dssp[key][2] for key in list(dssp.keys())]
for i in range(len(self.struct3)):
dsspcolor = crgbaDSSP(self.struct3[i])
can_atoms = [
atom for atom in self.residues[i]
if atom.get_name() == 'CA' or atom.get_name() == 'N'
]
for atom in can_atoms:
x, y, z = atom.coord
atomid = atom.get_id()
a = loader.loadModel("data/atom_sphere")
a.setPos(x, y, z)
a.reparentTo(self.dsspnode)
a.setColor(dsspcolor)
a.setScale(vrad(atomid) / 2.5)
self.dsspnode.flattenStrong()
self.dsspnode.hide()
#Colocamos la proteina en el centro
self.cpknode.setPos(0, 0, 0)
self.bbnode.setPos(0, 0, 0)
self.aanode.setPos(0, 0, 0)
self.nnode.setPos(0, 0, 0)
#Colocamos la camara en el centro
xc, yc, zc = self.cpknode.getBounds().getCenter()
self.center = xc, yc, zc
self.pradius = self.cpknode.getBounds().getRadius()
self.center_camera()
#Creamos la iluminacion de ambiente
self.ambient = AmbientLight('alight')
self.ambient.setColor(LVecBase4f(0.16, 0.16, 0.17, 1.0))
self.alight = render.attachNewNode(self.ambient)
render.setLight(self.alight)
#Creamos la iluminacion direccional
self.directional = DirectionalLight('dlight')
self.directional.setColor(LVecBase4f(0.8, 0.7, 0.75, 1.0))
self.directional.setShadowCaster(True, 512, 512)
render.setShaderAuto()
self.dlight = render.attachNewNode(self.directional)
self.dlight.setPos(0, -50, 0)
render.setLight(self.dlight)
self.dlight.lookAt(self.cpknode.getBounds().getCenter())
# Post procesado
render.setAntialias(AntialiasAttrib.MAuto)
#Teclado
self.accept('c', self.toggle_cloud)
self.accept('1', self.showmodel, [self.cpknode])
self.accept('2', self.showmodel, [self.aanode])
self.accept('3', self.showmodel, [self.bbnode])
self.accept('4', self.showmodel, [self.dsspnode])
self.accept('x', self.center_camera)
self.accept('arrow_left', self.taskMgr.add,
[self.spinCameraTaskX, "SpinCameraTaskX"])
self.accept('arrow_up', self.taskMgr.add,
[self.spinCameraTaskY, "SpinCameraTaskY"])
self.accept('arrow_down', self.stop_camera)
self.accept('escape', sys.exit)
def center_camera(self):
base.cam.setPos(self.center[0],
-10 - self.center[1] - 4 * self.pradius,
self.center[2])
base.cam.lookAt(self.center)
def toggle_cloud(self):
self.cloud = not self.cloud
if self.cloud:
self.nnode.show()
else:
self.nnode.hide()
def spinCameraTaskX(self, task):
base.disableMouse()
taskMgr.remove("SpinCameraTaskY")
angleDegrees = task.time * 20.0
angleRadians = angleDegrees * (pi / 180.0)
self.camera.lookAt(self.center)
self.camera.setHpr(angleDegrees, 0, 0)
return Task.cont
def spinCameraTaskY(self, task):
base.disableMouse()
taskMgr.remove("SpinCameraTaskX")
angleDegrees = task.time * 20.0
angleRadians = angleDegrees * (pi / 180.0)
self.camera.lookAt(self.center)
self.camera.setHpr(0, angleDegrees, 0)
return Task.cont
def stop_camera(self):
mat = Mat4(camera.getMat())
mat.invertInPlace()
base.mouseInterfaceNode.setMat(mat)
base.enableMouse()
self.taskMgr.remove("SpinCameraTaskX")
self.taskMgr.remove("SpinCameraTaskY")
def showmodel(self, node):
self.cpknode.hide()
self.aanode.hide()
self.bbnode.hide()
self.dsspnode.hide()
node.show()
class DBoard(DistributedObject):
def __init__(self, cr):
DistributedObject.__init__(self, cr)
self.accept("checkBoardAnimationDone", self.checkBoardAnimationDone)
base.messenger.send("registerLoadEvent", ["loadBoardDone"])
base.messenger.send("registerLoadEvent", ["loadTableDone"])
self.modelLoadList = {"board": False, "table": False}
self.boardAnimation = None
self.boardAnimationStarted = False
self.lightSun = DirectionalLight('light_sun')
self.lightSun.setColorTemperature(5300)
self.lightSun.setShadowCaster(True, 2048, 2048)
self.lightSunNP = render.attachNewNode(self.lightSun)
self.lightSunNP.setPos(-2, 2, 2)
self.lightSunNP.lookAt(2, -2, -0.5)
self.lightAmb = AmbientLight('light_ambient')
#self.lightAmb.setColor((0.1, 0.1, 0.1, 1))
self.lightAmb.setColorTemperature(4500)
c = self.lightAmb.getColor()
self.lightAmb.setColor((c.x / 2, c.y / 2, c.z / 2, 1))
self.lightAmbNP = render.attachNewNode(self.lightAmb)
self.accept("loadDone", self.loadDone)
self.boardSceneLoadTask = loader.loadModel(
"assets/models/board/BoardScene.bam", callback=self.boardLoaded)
self.tableLoadTask = loader.loadModel("assets/models/table/Table.bam",
callback=self.tableLoaded)
# render lights
render.setLight(self.lightSunNP)
render.setLight(self.lightAmbNP)
def boardLoaded(self, boardScene):
"""Callback event for when the board model has fully loaded"""
self.boardScene = boardScene
self.boardFlip = Actor(self.boardScene.find("**/BoardArmature"),
copy=False)
self.boardFlip.reparentTo(self.boardScene)
self.camFly = Actor(self.boardScene.find("**/CameraArmature"),
copy=False)
self.camFly.reparentTo(self.boardScene)
bone = self.camFly.exposeJoint(None, "modelRoot", "CamHolder")
base.camLens.setNear(0.01)
base.camLens.setFar(100)
base.camera.reparentTo(bone)
base.camera.setP(-90)
# render board
self.boardSceneNP = self.boardScene.reparentTo(render)
self.setupCollisions()
base.messenger.send("loadBoardDone")
base.messenger.send("loadDone", ["board"])
def tableLoaded(self, table):
"""Callback event for when the table model has fully loaded"""
self.table = table
# render table
self.tableNP = self.table.reparentTo(render)
base.messenger.send("loadTableDone")
base.messenger.send("loadDone", ["table"])
def loadDone(self, model):
"""Check function to determine if all models have loaded. If all models
have been loaded, the boardDone event will be fired."""
self.modelLoadList[model] = True
for key, value in self.modelLoadList.items():
if value == False: return
self.ignore("loadDone")
base.messenger.send("boardDone")
def announceGenerate(self):
# tell everyone interested, that the board DO has been generated
base.messenger.send(self.cr.uniqueName("board_generated"), [self.doId])
# call the base class method
DistributedObject.announceGenerate(self)
def disable(self):
self.ignoreAll()
self.boardScene.detachNode()
self.table.detachNode()
DistributedObject.disable(self)
def delete(self):
"""Cleanup just before deletion of the DO"""
# cleanup events
self.ignoreAll()
# cleanup models
self.boardFlip.cleanup()
self.camFly.cleanup()
self.boardFlip.removeNode()
self.camFly.removeNode()
self.table.removeNode()
self.boardAnimation = None
# cleanup light
try:
render.clearLight(self.lightSunNP)
render.clearLight(self.lightAmbNP)
except:
print("clear lights failed.")
self.lightSunNP.removeNode()
self.lightAmbNP.removeNode()
# cleanup collisions
for field in BoardMap.gameMap:
field.collisionNP.removeNode()
# cleanup other variables
self.modelLoadList = {"board": False, "table": False}
self.boardAnimation = None
self.boardAnimationStarted = False
DistributedObject.delete(self)
def start(self):
"""Start the board animation"""
taskMgr.step()
self.boardAnimationStarted = True
self.boardAnimation = Sequence(
Parallel(self.boardFlip.actorInterval("BoardFlipUp"),
self.camFly.actorInterval("CamFly")),
Func(base.messenger.send, "BoardAnimationDone"))
self.boardAnimation.start()
def checkBoardAnimationDone(self):
"""Check if the board animation has been stopped and resend the
respective event if it has."""
# check if we have an animation and it has actually been started once
if self.boardAnimation is not None and self.boardAnimationStarted:
# now check if the animation is done
if self.boardAnimation.isStopped():
# resend the event
base.messenger.send("BoardAnimationDone")
def setupCollisions(self):
"""Setup the collision solids for all fields.
NOTE: This can be removed once blend2bam supports invisible collision
model export"""
for field in BoardMap.gameMap:
# create a sphere collision solid
cs = CollisionSphere(0, 0, 0, 0.01)
cn = CollisionNode("{}-collision".format(field.name))
cn.addSolid(cs)
fieldNP = self.boardScene.find("**/{}".format(field.name))
field.collisionNP = fieldNP.attachNewNode(cn)
field.collisionNP.setCollideMask(BitMask32(0x80))
#Colocamos la proteina en el centro
pnode.setPos(0,0,0)
#Colocamos la camara en el centro
p_radius= pnode.getBounds().getRadius()
p_center= pnode.getBounds().getCenter()
xc, yc, zc = p_center
base.cam.setPos(xc, -150-yc-2*p_radius, zc)
base.cam.lookAt(xc, yc, zc)
#Creamos iluminacion del ambiente (para la sombra)
ambiente = AmbientLight('aluz')
ambiente.setColor(LVecBase4f(0.16, 0.16, 0.17, 1.0))
luza = render.attachNewNode(ambiente)
render.setLight(luza)
#Creamos una iluminacion direccional (para dar volumen)
direccional = DirectionalLight('dluz')
direccional.setColor(LVecBase4f(0.8, 0.7, 0.75, 1.0))
direccional.setShadowCaster(True, 512, 512)
render.setShaderAuto()
luzd = render.attachNewNode(direccional)
luzd.setPos(0, -50, 0)
render.setLight(luzd)
luzd.lookAt(xc, yc, zc)
base.run()
class NewSpaceCraft:
def __init__(self, base, quality=0, sun_angle=0):
self.base = base
folder = base.params("space_craft_folder")
self.model = base.loader.load_model(folder + "core.egg")
self.wheel = base.loader.load_model(folder + "wheel.egg")
self.sp = base.loader.load_model(folder + "solar_panel.egg")
self.model.reparentTo(base.render)
self.wheel.reparentTo(self.model)
self.rest_pos = NodePath("rest_pos")
self.rest_pos.reparent_to(self.model)
self.rest_pos.set_pos(LVector3f(0.0, -0.75, -0.24))
# self.wheel_lights = base.loader.load_model(folder + "wheel_lights.egg")
# self.wheel_lights.set_color(1, 1, 0)
# self.wheel_lights.reparentTo(self.wheel)
# self.wheel_lights.setLightOff()
# instanciating
self.placeholders = []
z1 = 0.4215
z2 = 0.67935
x1 = 1.136
x2 = 2.6915
for i, pos in enumerate(
((x1, 0, z1), (x2, 0, z1), (-x1, 0, z1), (-x2, 0, z1), (x1, 0, z2),
(x2, 0, z2), (-x1, 0, z2), (-x2, 0, z2))):
self.placeholders.append(self.model.attachNewNode("p" + str(i)))
self.placeholders[-1].set_pos(pos)
self.sp.instanceTo(self.placeholders[-1])
# wheel spinning task
self.spin_velocity = 0.01
if self.spin_velocity > 0.:
self.spin_task = self.wheel.hprInterval(duration=1 /
self.spin_velocity,
hpr=(360, 0, 0))
self.spin_task.loop()
# model light
self.sun_light = DirectionalLight('SUN_LIGHT_ON_SPACE_CRAFT')
self.sun_light.setColor((1., 1., 1., 1))
self.sun_light_node = self.base.render.attachNewNode(self.sun_light)
# self.sun_light_node.setHpr(-135, 0, 0)
self.base.render.setLight(self.sun_light_node)
if quality > 0:
print(quality * 512)
self.sun_light.setShadowCaster(True, quality * 512, quality * 512)
# self.sun_light.getLens().setFilmSize(60., 40.)
self.sun_light.getLens().setFilmSize(6., 4.)
self.sun_light.getLens().setNearFar(2., 6.)
self.sun_light_node.lookAt(NodePath(self.base.sun))
self.sun_light_node.set_pos(0, 3.5, 1)
self.sun_light_node.set_h(self.sun_light_node.get_h() + 180)
# self.model.set_r(180)
self.model.set_p(-90 + sun_angle)
# self.model.set_h(180)
self.model.set_bin('fixed', 10)
self.set_solar_panel_angle(70)
# self.show_shuttle_rest_pos()
# self.model.set_depth_write(0)
# self.model.set_depth_test(0)
def set_hpr(self, h, p, r):
self.model.set_hpr(h, p, r)
def get_shuttle_rest_pos(self):
return self.rest_pos.get_pos()
def get_shuttle_rest_hpr(self):
return self.rest_pos.get_hpr()
def get_connection_pos_and_hpr(self):
node = NodePath('test')
node.set_pos(0, 0, 0)
node.set_hpr(0, 90, 0)
node.reparent_to(self.rest_pos)
node.wrtReparentTo(self.base.render)
return node.get_pos(), node.get_hpr()
def connect_to_shuttle(self, node):
node.set_pos(0, 0, 0)
node.set_hpr(0, 90, 0)
node.reparent_to(self.rest_pos)
node.wrtReparentTo(self.base.render)
def show_shuttle_rest_pos(self):
arrow = Arrow(self.base)
arrow.set_color(0.5, 0.5, 0)
arrow.reparent_to(self.rest_pos)
arrow.look_at(LVector3f(0, 0, 1))
# l = Lamp(self.base, 'lamp', self.get_shuttle_rest_pos(), show_model=True)
@staticmethod
def get_shuttle_rest_direction():
return LVector3f(1, 0, 0)
def show_bounds(self):
self.sun_light.showFrustum()
for child in self.sun_light.getChildren():
if child.name == "frustum":
NodePath(child).setLightOff()
NodePath(child).set_color(1, 1, 0, 1)
NodePath(child).set_bin('fixed', 10)
self.model.showTightBounds()
def set_solar_panel_angle(self, angle):
self.sp.set_p(angle)
def solar_panel_increment(self, angle):
self.sp.set_p(self.sp.get_p() + angle)
print("sp :", self.sp.get_p())
def spin(self, angle, value):
if angle == 'p':
self.model.set_p(self.model.get_p() + value)
elif angle == 'h':
self.model.set_h(self.model.get_h() + value)
elif angle == 'r':
self.model.set_r(self.model.get_r() + value)
print(self.model.get_hpr())
def move_solar_panels(self, new_angle=None):
if new_angle is None:
new_angle = 180 * random()
if 0 <= new_angle <= 180:
angle = self.sp.get_h()
time = (new_angle - angle) * 0.1
if time < 0:
time = -time
task = self.sp.hprInterval(duration=time, hpr=(0, new_angle, 0))
task.start()
def get_light(self):
return self.sun_light_node
class VisualTest(ShowBase):
def __init__(self):
super().__init__(self)
self.scene = loader.loadModel("models/world")
self.player = self.scene.find("player")
self.basePlane = self.scene.find("basePlane")
self.player.reparentTo(self.render)
self.basePlane.reparentTo(self.render)
self.scene.remove_node()
self.taskMgr.add(self.update, "update")
self.camera.setPos(self.render, 0, -100, 70)
base.setBackgroundColor(0.1, 0.1, 0.1, 1)
self.dirLight = DirectionalLight("dir light")
self.dirLight.setShadowCaster(True, 512, 512)
self.dirLight.color = (1, 0, 1, 1)
self.dirLightPath = self.render.attachNewNode(self.dirLight)
self.dirLightPath.setHpr(45, -60, 0)
render.setLight(self.dirLightPath)
self.angleTime = 0.0
self.totalAngleTime = 10.0
self.hAngle = 0
self.ambientLight = AmbientLight("ambient")
self.ambientLight.color = (0.1, 0.1, 0.1, 1)
self.ambLightPath = self.render.attachNewNode(self.ambientLight)
render.setLight(self.ambLightPath)
self.pointLight = PointLight("point")
self.pointLight.color = (1, 1, 1, 1)
self.pointLightPath = self.render.attachNewNode(self.pointLight)
self.pointLightPath.setPos(0, 5, 5)
self.pointLight.setShadowCaster(True, 512, 512)
self.render.setLight(self.pointLightPath)
self.fog = Fog("fog")
self.fog.setColor(.1, .1, .1)
self.fog.setExpDensity(.3)
self.fog.setLinearRange(150, 200)
self.fog.setLinearFallback(45, 160, 320)
render.setFog(self.fog)
self.render.setShaderAuto()
self.p = self.render.attachNewNode("particles")
base.enableParticles()
p = ParticleEffect()
p.loadConfig('./mysmoke.ptf')
p.start(parent=self.p, renderParent=render)
self.p.setPos(self.player, 0, 0, 2)
self.font = loader.loadFont('./fonts/Magenta.ttf')
self.sceneName = DirectLabel(text="Starfox visual test",
parent=self.aspect2d,
scale=0.07,
pos=(-1.2, 0, 0.85),
text_font=self.font,
relief=None,
text_fg=(1, 1, 1, 1),
textMayChange=True,
text_align=TextNode.ALeft)
self.foxy = OnscreenImage(image='./UI/fox-icon-png-8.png',
pos=(1.2, 9, 0.85),
scale=0.1)
self.foxy.setTransparency(True)
self.controlsPanel = DirectDialog(frameSize=(-1.1, 1.1, -0.9, -0.7),
relief=DGG.FLAT)
btn = DirectButton(text="Rotate",
command=self.doRotate,
image='./UI/fox-icon-png-8.png',
pos=(-0.9, 0, -0.8),
parent=self.controlsPanel,
scale=0.07,
relief=None)
btn2 = DirectButton(text="Anin Light",
command=self.doLight,
image='./UI/fox-icon-png-8.png',
pos=(-0.7, 0, -0.8),
parent=self.controlsPanel,
scale=0.07,
relief=None)
self.camera.lookAt(self.player)
self.makeRotation = False
self.rotateAngles = 0
self.animLight = False
filter = CommonFilters(base.win, base.cam)
filter.setBloom(size="large", intensity=2)
#filter.setAmbientOcclusion(strength = 5, radius = 3)
filter.setCartoonInk(separation=4)
def doRotate(self):
self.makeRotation = True
return 0
def doLight(self):
self.animLight = True
return 0
def update(self, evt):
ang = (self.angleTime / self.totalAngleTime)
#self.camera.setPos(self.player, ang*100,ang*100,ang*100)
self.player.setPos(self.render, 0, 0, 1)
#self.camera.lookAt( Vec3(0,300,0) )
#self.p.setPos(self.player, 0,0,0,)
# self.dirLightPath.setHpr(ang*360.0 ,-60,0)
if (self.makeRotation):
self.makeRotation = False
self.rotateAngles = (self.rotateAngles + 90) % 360
self.player.setHpr(self.rotateAngles, 0, 0)
self.sceneName[
"text"] = f"Starfox visual test ({self.rotateAngles})"
self.camera.setPos(self.render, 10, 10, 10)
self.camera.lookAt(self.player)
if (ang >= 1):
self.angleTime = 0
self.angleTime = self.angleTime + globalClock.getDt()
self.dirLight.color = (ang, 0, 1, 1)
if self.animLight:
self.pointLightPath.setPos(ang * 10 - 5, ang * 10 - 5, ang * 5)
return Task.cont
def __init__(self):
ShowBase.__init__(self)
self.scene = self.loader.loadModel(models_dir + "hallway.bam") # Load the environment model
self.scene.reparentTo(self.render)
self.scene.setScale(1, 1, 1)
self.scene.setPos(0, 0, 1)
self.scene.setHpr(90, 0, 0)
# Add an ambient light and set sky color
sky_col = VBase3(135 / 255.0, 206 / 255.0, 235 / 255.0)
self.set_background_color(sky_col)
alight = AmbientLight("sky")
alight.set_color(VBase4(sky_col * 0.04, 1))
alight_path = self.render.attachNewNode(alight)
self.render.set_light(alight_path)
# # 4 perpendicular lights (flood light)
for light_no in range(4):
d_light = DirectionalLight('directionalLight')
d_light.setColor(Vec4(*([0.3] * 4)))
d_light_NP = self.render.attachNewNode(d_light)
d_light_NP.setHpr(-90 * light_no, 0, 0)
self.render.setLight(d_light_NP)
# # 1 directional light (Sun)
sun_light = DirectionalLight('directionalLight')
sun_light.setColor(Vec4(*([0.7] * 4))) # directional light is dim green
sun_light.getLens().setFilmSize(Vec2(0.8, 0.8))
sun_light.getLens().setNearFar(-0.3, 12)
sun_light.setShadowCaster(True, 2 ** 7, 2 ** 7)
self.dlightNP = self.render.attachNewNode(sun_light)
self.dlightNP.setHpr(0, -65, 0)
# Turning shader and lights on
self.render.setLight(self.dlightNP)
# Load and transform the quadrotor actor.
self.quad_model = self.loader.loadModel(models_dir + f'{quad_model_filename}.egg')
self.prop_models = []
for prop_no in range(4):
prop = self.loader.loadModel(models_dir + 'propeller.egg')
x = 0 if prop_no % 2 == 1 else (-0.26 if prop_no == 0 else 0.26)
y = 0 if prop_no % 2 == 0 else (-0.26 if prop_no == 3 else 0.26)
prop.setPos(x, y, 0)
prop.reparentTo(self.quad_model)
self.prop_models.append(prop)
self.prop_models = tuple(self.prop_models)
# self.quad_model.reparentTo(self.scene)
self.quad_model.setPos(0, 0, 2)
self.quad_neutral_hpr = (90, 0, 0)
self.quad_model.setHpr(*self.quad_neutral_hpr)
# env cam
self.cam_neutral_pos = (0, -4, 3)
self.cam.reparentTo(self.scene)
# self.cam_neutral_pos = (-4, 0, 1)
# self.cam.reparentTo(self.quad_model)
self.cam.setPos(*self.cam_neutral_pos)
self.cam.lookAt(self.quad_model)
self.enableParticles()
node = NodePath("PhysicsNode")
node.reparentTo(self.scene)
self.actor_node = ActorNode("quadrotor-physics")
# self.actor_node.getPhysicsObject().setMass(1)
self.actor_node_physics = node.attachNewNode(self.actor_node)
self.physicsMgr.attachPhysicalNode(self.actor_node)
self.quad_model.reparentTo(self.actor_node_physics)
# add gravity
# gravity_force_node = ForceNode('world-forces')
# gravityForce = LinearVectorForce(0, 0, -0.1) # gravity acceleration
# gravity_force_node.addForce(gravityForce)
# self.physicsMgr.addLinearForce(gravityForce)
self.time = datetime.datetime.today().strftime('%Y-%m-%d-%H.%M.%S')
self.simulation_folder = "\sims\\" + self.time + '\\'
self.simulation_folder_path = ROOT_DIR + self.simulation_folder
os.makedirs(self.simulation_folder_path)
self.movements = ''
self.taskMgr.add(self.camera_move, 'Camera Movement')
self.taskMgr.add(self.quad_move, 'Quad Movement')
self.taskMgr.add(self.rotate_propellers, 'Propellers Rotation')
self.taskMgr.add(self.save_image, 'Screenshot Capture')
# self.buffer: GraphicsBuffer = self.win.makeTextureBuffer(name='buffer', x_size=84, y_size=84, tex=None, to_ram=True)
# self.buffer.setActive(1)
self.images = []
self.image_index = 1
class MyApp(ShowBase):
def center_mouse(self):
self.win.movePointer(0,self.win.getXSize()/2,self.win.getYSize()/2)
def __init__(self):
#Game variables
self.health = 100
self.panda_kill_count = 0
self.level = 0
#Implementation variables
#self.color = [Vec4((204.0/255), (255.0/255), (204/255), 0.1),Vec4((0/255), (255.0/255), (255.0/255), 0.1),Vec4((255.0/255), (51.0/255), (255.0/255), 0.1),Vec4((153.0/255), (255.0/255), (153.0/255), 0.1),Vec4((255.0/255), (178.0/255), (102.0/255), 0.1),Vec4((229.0/255), (204.0/255), (255.0/255), 0.1)]
self.color = [Vec4(0.4,0.4,0.4,0.1)]
self.mirror=False
self.paused=False
self.displayed=False
self.game_started=False
self.randomthings_ = randomthings.RandomThings(self)
self.shifted_cam=False
self.is_firstP=False
self.old_anim2 = None
self.old_anim=None
self.timeout=False
(self.r,self.f,self.b,self.l)=(0,0,0,0)
self.inside_level=False
self.move_anim_queue=[]
self.anim_queue=[]
self.prev_time=0.0
self.bullets = []
self.rightspeed=0
self.forwardspeed=0
ShowBase.__init__(self)
self.makeDefaultPipe()
bb=self.pipe.getDisplayHeight()
aa=self.pipe.getDisplayWidth()
self.openDefaultWindow(size=(aa, bb))
import layer2d
self.layer2d = layer2d
self.layer2d.update_info('Loading...')
self.keyreader= ReadKeys(self,layer2d)
#Sounds
self.gunshot = self.loader.loadSfx("sounds/gunshot_se.ogg")
self.gunshot.setLoop(False)
self.music = self.loader.loadSfx("sounds/music.ogg")
self.music.setLoop(True)
self.zombie_die = self.loader.loadSfx('sounds/zombie_die.ogg')
self.zombie_die.setLoop(False)
self.kicked = self.loader.loadSfx('sounds/kicked.ogg')
self.kicked.setLoop(False)
self.hurt_sound = self.loader.loadSfx('sounds/hurt.ogg')
self.hurt_sound.setLoop(False)
self.dead_sound = self.loader.loadSfx('sounds/dead.ogg')
self.dead_sound.setLoop(False)
self.intro_sound = self.loader.loadSfx('sounds/intro.ogg')
self.intro_sound.setLoop(False)
self.intro_sound.play()
self.enableParticles()
self.center_mouse()
#self.disableMouse()
self.prev_pos = None
if base.mouseWatcherNode.hasMouse():
x=base.mouseWatcherNode.getMouseX()
y=base.mouseWatcherNode.getMouseY()
self.prev_pos = (x,y)
#Hide cursor
props = WindowProperties()
props.setCursorHidden(True)
self.win.requestProperties(props)
self.environ = self.loader.loadModel('models/ourworld')
self.environ.setPos(0,0,0)
self.environ.reparentTo(self.render)
self.pandaActor = Actor("models/hero_anim", {'kick':'models/hero_anim-kick','unready_to_shoot':'models/hero_anim-unready_to_shoot','jump':'models/hero_anim-jump',"shooting":"models/hero_anim-shooting","ready_to_shoot":"models/hero_anim-ready_to_shoot","ready_to_walk":"models/hero_anim-ready_to_run","ready_to_run":"models/hero_anim-ready_to_run","walk4":"models/hero_anim-walk1", "breathe": "models/hero_anim-breathe", "run": "models/hero_anim-walk"})
self.pandaActor.setPlayRate(3,'ready_to_shoot')
self.pandaActor.setPlayRate(-1.0,"ready_to_walk")
self.pandaActor.setPlayRate(1.5,'run')
self.pandaActor.setPlayRate(1.5,'ready_to_run')
self.pandaActor.reparentTo(self.render)
self.pandaActor.setPos(self.environ,0,0,100)
self.pandaActor.loop("breathe")
self.phy = NodePath("PhysicsNode")
self.phy.reparentTo(self.render)
self.pandaAN = ActorNode("PandaActor")
self.pandaActorPhysicsP = self.phy.attachNewNode(self.pandaAN)
self.physicsMgr.attachPhysicalNode(self.pandaAN)
self.pandaActor.reparentTo(self.pandaActorPhysicsP)
#set mass of panda
self.pandaAN.getPhysicsObject().setMass(100)
#apply gravity
self.gravityFN=ForceNode('world-forces')
self.gravityFNP=self.environ.attachNewNode(self.gravityFN)
self.gravityForce=LinearVectorForce(0,0,-30.81) #gravity acceleration
self.gravityFN.addForce(self.gravityForce)
self.physicsMgr.addLinearForce(self.gravityForce)
#camera stuff
self.camera.reparentTo(self.pandaActor)
self.camera.lookAt(self.pandaActor)
self.taskMgr.add(self.spinCameraTask, "zombieTask_SpinCameraTask")
self.taskMgr.doMethodLater(0.01,self.movePandaTask,"zombieTask_movePandaTask")
#Collision Handling
self.cTrav = CollisionTraverser()
self.collisionHandler = CollisionHandlerEvent()
#Add collider for terrain
self.groundCollider = self.environ.find("**/terrain")
#Add walker for panda
self.collision_sphere = CollisionSphere(0,0,1,1)
self.collNode = CollisionNode('pandaWalker')
self.cnodePath = self.pandaActor.attachNewNode(self.collNode)
self.cnodePath.node().addSolid(self.collision_sphere)
#AddZombieDetector for panda
self.zombie_sphere = CollisionSphere(0,0,3,1)
self.zomb_detector_node = CollisionNode('zombieDetector')
self.zomb_detector_NP = self.pandaActor.attachNewNode(self.zomb_detector_node)
self.zomb_detector_NP.node().addSolid(self.zombie_sphere)
#self.zomb_detector_NP.show()
#Add pusher against gravity
self.pusher = PhysicsCollisionHandler()
self.pusher.addCollider(self.cnodePath, self.pandaActorPhysicsP)
self.pusher.addCollider(self.zomb_detector_NP,self.pandaActorPhysicsP)
self.cTrav.addCollider(self.cnodePath,self.pusher)
self.cTrav.addCollider(self.zomb_detector_NP,self.pusher)
self.pusher.addInPattern('%fn-into-%in')
self.pusher.addAgainPattern('%fn-again-%in')
#Add collision handler patterns
self.collisionHandler.addInPattern('%fn-into-%in')
self.collisionHandler.addAgainPattern('%fn-again-%in')
self.abientLight = AmbientLight("ambientLight")
self.abientLight.setColor(Vec4(0.1, 0.1, 0.1, 1))
self.directionalLight = DirectionalLight("directionalLight")
self.directionalLight.setDirection(Vec3(-5, -5, -5))
self.directionalLight.setColor(Vec4((229.0/255), (204.0/255), (255.0/255), 0.7))
self.directionalLight.setSpecularColor(Vec4(0.4, 0.4, 0.4, 0.1))
self.directionalLight.setShadowCaster(True,512,512)
self.render.setLight(self.render.attachNewNode(self.abientLight))
self.render.setLight(self.render.attachNewNode(self.directionalLight))
self.render.setShaderAuto()
#create zombie land
self.zombieland = zombie.Zombies(self)
self.taskMgr.doMethodLater(0.01,self.zombieland.moveZombie, "zombieTask_ZombieMover")
layer2d.incBar(self.health)
self.taskMgr.add(self.game_monitor,"zombieTask_gameMonitor")
self.taskMgr.doMethodLater(2.7,self.music_play, "zombieTask_music")
#Add random useless things:
self.randomthings_.add_random_things()
def music_play(self,task):
self.music.play()
return Task.done
#def get_color(self):
# return self.color[min(len(self.color)-1,self.level)]
#GameMonitor
def game_monitor(self,task):
if self.paused:
return Task.cont
#Update Score
self.layer2d.update_score(self.panda_kill_count)
#Check for health of actor
if self.health <= 0:
self.dead_sound.play()
self.pandaActor.detachNode()
print "LOL u ded"
self.info = """Game Over..
Score: """ + str(self.panda_kill_count) + """
Press alt+f4 to quit the game.
"""
self.layer2d.update_info(self.info)
self.taskMgr.removeTasksMatching('zombieTask_*')
if self.game_started<>True:
if not self.displayed:
self.display_information()
self.pandaActor.setPos(self.pandaActorPhysicsP.getRelativePoint(self.render,Point3(10,10,100)))
return Task.cont
#Check if user is inside some level. if yes, pass.
if self.inside_level or self.timeout:
return Task.cont
self.inside_level = True
#self.health=100
self.timeout=True
print ".."
#The next lines will be executed only when the user is in between two levels (or at the beginning of the game)
#Display information based on game level
self.display_information()
print "HUEHUEHUEHUE"
#Schedule wave of zombies
self.taskMgr.doMethodLater(10,self.addWave, "zombieTask_ZombieAdder")
return Task.cont
def addWave(self,task):
##add a wave of 5 zombies, depending on the level.
##speed of zombie increases with each level
##durability of zombie increases with each level.
##Wave ends when all zombies die.
self.directionalLight.setSpecularColor(Vec4(0.4, 0.4, 0.4, 0.1))
self.layer2d.update_info("level"+str(self.level))
self.timeout=False
self.zombieland.add(5)
return Task.done
#information displayer
def display_information(self):
#display information based on levels.
print self.game_started
self.displayed=True
if self.game_started==False:
info = """
Welcome to PandaLand. Once upon a time, there used to be these cute
little creatures called Pandas. They were lazy, funny, and
adorable. But that is what we humans thought. Pandas are
actually an evil alien race that spread from planet to planet,
spreading destruction and terror everywhere. They ruled earth
several billion years ago. But our super ancestors (Dinosaurs)
fought agaisnt them with great valour and selflessness; and managed
to save planet Earth from doom. But the pandas went into hiding
(and became cute); until few days back! Now they seek to kill all.
You, the Joker, are our only hope,since Batman has retired.
Go Kill Pandas.For Mother Earth!
"""
self.layer2d.information['bg'] = (0,0,0,0.8)
else:
self.layer2d.update_info('')
if self.level==0:
info="""
Your game will start in a few seconds.
This is the first level. Pandas will spawn
and follow you. Shoot to kill.
Test out your controls while
they are still cute and harmless :)
Jump: Space
Shoot: LeftClick
Kick: RightClick
Walk: A/W/S/D
For more information, press P.
"""
self.layer2d.information['bg'] = (0,0,0,0.6)
elif self.level==1:
info="""
Level 0 Completed!
Starting Level 1.
Pandas have turned evil
and stronger. They will try
to eat you up.
To run:
Press Shift + A/S/W/D
"""
elif self.level==2:
info="""
Level 1 Completed!
Starting Level 2.
Pandas are even stronger now.
They will get stronger by
each level.
Your automatic shooting speed has
also improved due to experience
gained.
"""
elif self.level==3:
info="""
Level 2 Completed!
Starting Level 3.
Pandas also move faster
by each level. They really
want to eat you.
But don't worry, you also
run faster as the levels
proceed.
"""
else:
info = """
Level """ + str(self.level-1) + """ Completed!
Starting """ + str(self.level) + """ .
Well done!
Keep fighting, our fate lies
in your hands.
"""
self.layer2d.update_info(info)
#self.create_bullet()
def create_bullet(self):
self.bullet = self.loader.loadModel('models/gun/bullet')
self.gunshot.play()
self.bulletAN = ActorNode("BulletNode")
self.bulletActorPhysicsP = self.phy.attachNewNode(self.bulletAN)
self.physicsMgr.attachPhysicalNode(self.bulletAN)
self.bullet.reparentTo(self.bulletActorPhysicsP)
self.bulletAN.getPhysicsObject().setMass(1)
self.bullet.setPos(self.pandaActor,0,-3,3.5)
self.bullet.setScale(0.1,0.1,0.1)
self.bullet.setHpr(self.pandaActor,0,90,0)
self.bullet.setP(self.camera.getP()+90)
self.bullet_sphere = CollisionSphere(0,0,0,0.2)
self.bullet_collNode = CollisionNode('bullet')
self.bullet_cnodePath = self.bullet.attachNewNode(self.bullet_collNode)
self.bullet_cnodePath.node().addSolid(self.bullet_sphere)
#self.pusher.addCollider(self.bullet_cnodePath,self.bulletActorPhysicsP)
self.cTrav.addCollider(self.bullet_cnodePath,self.collisionHandler)
#self.bullet_cnodePath.show()
self.bullets += [self.bullet]
def bulletKiller(self,task):
if self.paused:
return Task.cont
self.bullets[0].remove_node()
self.bullets = self.bullets[1:]
return Task.done
def bulletThrower(self,task):
if self.paused:
return Task.cont
#make bullet move
if self.pandaActor.getCurrentAnim()<>'shooting' and self.pandaActor.getCurrentAnim()<>'ready_to_shoot':
self.pandaActor.play('shooting')
print "loL"
self.create_bullet()
self.bulletAN.getPhysicsObject().setVelocity(self.render.getRelativeVector(self.camera,Vec3(0,200,0)))
self.taskMgr.doMethodLater(max(0.05,0.1*(5-self.level)),self.bulletThrower, "zombieTask_bulletThrower")
self.taskMgr.doMethodLater(0.5,self.bulletKiller, "zombieTask_bulletKiller")
self.prev=True
if self.old_anim2==None:
self.old_anim2='breathe'
if self.old_anim2 not in ['run','walk4']:
self.old_anim2='breathe'
self.anim_queue = [(self.pandaActor,True,'unready_to_shoot'),(self.pandaActor,False,self.old_anim2)]
return Task.done
def movePandaTask(self,task):
if self.paused:
return Task.cont
tempos = self.pandaActor.getPos()
speed = 0.1
if self.run_:
speed+=0.3*self.level
self.rightspeed = -(self.r-self.l)*speed
self.forwardspeed = -(self.f-self.b)*speed
if (self.r-self.l)<>0 and (self.f-self.b)<>0:
#print self.forwardspeed
#print self.rightspeed
#sys.exit(0)
self.rightspeed *= 0.7
self.forwardspeed *= 0.7
self.pandaActor.setPos(self.pandaActor,self.rightspeed, self.forwardspeed,0)
return Task.again
def spinCameraTask(self, task):
if self.paused:
return Task.cont
if self.render.getRelativePoint(self.pandaActorPhysicsP,self.pandaActor.getPos())[2] < -10:
self.pandaAN.getPhysicsObject().setVelocity(0,0,30)
#self.pandaActor.setPos(self.pandaActorPhysicsP.getRelativePoint(self.render,Point3(10,10,100)))
self.prev_time=task.time
#play queued animations:
for x in self.move_anim_queue+self.anim_queue:
if x[0].getCurrentAnim()==None:
if x[1]:
x[0].play(x[2])
else:
x[0].loop(x[2])
if x in self.move_anim_queue:
self.move_anim_queue.remove(x)
elif x in self.anim_queue:
self.anim_queue.remove(x)
#Do other stuff
if self.mouseWatcherNode.hasMouse():
x=base.mouseWatcherNode.getMouseX()
y=base.mouseWatcherNode.getMouseY()
if self.prev_pos==None:
self.prev_pos = (x,y)
xx = self.prev_pos[0] - x
yy = self.prev_pos[1] + y
self.prev_pos = (xx,yy)
self.pandaActor.setHpr(self.pandaActor,-20*(pi/2.0)*x,0,0)
#self.camera.setHpr(self.pandaActor, 20*(pi/2.0)*x, 20*(pi/2.0)*yy, 0)
if self.is_firstP:
self.camera.lookAt(self.pandaActor)
self.camera.setPos(self.pandaActor,0,0,4)
self.camera.setHpr(self.camera,180,0,0)
else:
self.camera.setPos(self.pandaActor,0,8,5)
self.camera.lookAt(self.pandaActor)
if self.mirror:
self.camera.setY(-self.camera.getY())
self.camera.lookAt(self.pandaActor)
self.camera.setHpr(self.camera,0,20*(pi/2.0)*yy,0)
self.center_mouse()
#zombie collisions
return Task.cont
#User Actions:
def meelee(self):
#Make actor stomp here. or something
#Load animation
self.zombieland.meelee()
self.anim_queue += [(self.pandaActor,True,self.pandaActor.getCurrentAnim())]
self.pandaActor.play('kick')
#pass
def ranged_start(self):
#put animation here
self.old_anim = self.pandaActor.getCurrentAnim()
if self.old_anim not in ['shooting','unready_to_shoot','ready_to_shoot'] :
self.old_anim2 = self.old_anim
if self.old_anim not in ['ready_to_shoot','shooting','unready_to_shoot']:
self.pandaActor.play('ready_to_shoot')
self.taskMgr.add(self.bulletThrower, "zombieTask_bulletThrower")
def ranged_stop(self,task=None):
if self.paused:
return Task.cont
#stop animation here
if self.pandaActor.getCurrentAnim()<>'shooting' and task==None:
self.pandaActor.play('shooting')
self.taskMgr.remove("zombieTask_bulletThrower")
self.taskMgr.doMethodLater(0.5,self.ranged_stop,'zombieTask_rangedStop')
return Task.done
self.taskMgr.remove("zombieTask_bulletThrower")
return Task.done
class VisualTest(ShowBase):
def __init__(self):
super().__init__(self)
self.var1 = 0
self.scene = loader.loadModel("models/world")
playerTexture = loader.loadTexture("models/starfoxShip.jpg")
self.player = self.scene.find("player")
self.player.setTexture(playerTexture)
base.setBackgroundColor(0.1, 0.1, 0.1, 1)
enemyTexture = loader.loadTexture("models/enemyShip.jpg")
self.enemy = self.scene.find("enemy1")
self.enemy.setTexture(enemyTexture)
self.basePlane = self.scene.find("basePlane")
self.scene.reparentTo(self.render)
self.player.setPos(50, 50, 3)
self.enemy.setPos(50, 55, 0)
self.ambient = AmbientLight("ambient")
self.ambient.color = (0.1, 0.1, 0.1, 1)
self.ambientPath = self.render.attachNewNode(self.ambient)
render.setLight(self.ambientPath)
self.dirLight = DirectionalLight("dir light")
self.dirLight.color = (1, 1, 1, 1)
self.dirLightPath = self.render.attachNewNode(self.dirLight)
self.dirLightPath.setHpr(0, -90, 0)
self.dirLight.setShadowCaster(True, 512, 512)
render.setLight(self.dirLightPath)
self.pointLight = PointLight("point light")
self.pointLight.color = (1, 1, 1, 1)
self.pointLightPath = self.render.attachNewNode(self.pointLight)
self.pointLightPath.setPos(50, 52.5, 4)
self.pointLight.attenuation = (.5, 0, 0)
self.pointLight.setShadowCaster(True, 1024, 1024)
self.render.setLight(self.pointLightPath)
self.fog = Fog("fog")
self.fog.setColor(0.1, 0.1, 0.1)
self.fog.setExpDensity(.3)
self.fog.setLinearRange(150, 300)
self.fog.setLinearFallback(45, 160, 320)
self.render.setFog(self.fog)
self.render.setShaderAuto()
self.render.setAntialias(AntialiasAttrib.MAuto)
filters = CommonFilters(base.win, base.cam)
filters.setBloom(size="large")
filters.setAmbientOcclusion(strength=0.6, falloff=0.0005, radius=0.1)
filters.setCartoonInk(separation=2, color=(0, 0, 0, 1))
self.taskMgr.add(self.update, "update")
def update(self, evt):
self.var1 = self.var1 + 0.1
#self.dirLight.color = (self.var1,0,1,1)
#self.dirLightPath.setHpr(self.var1,-self.var1,0)
self.camera.setPos(60 + self.var1, 60 + self.var1, 20)
#self.pointLightPath.setPos(30+self.var1 ,52.5,4)
self.camera.lookAt(self.player)
return Task.cont
from direct.showbase.ShowBase import ShowBase
import simplepbr
from panda3d.core import DirectionalLight, AmbientLight
ShowBase()
pipeline = simplepbr.init()
lightSun = DirectionalLight('light_sun')
lightSun.setColorTemperature(5300)
lightSun.setShadowCaster(True, 2048, 2048)
lightSunNP = render.attachNewNode(lightSun)
lightSunNP.setPos(2, 2, 2)
lightSunNP.lookAt(0, 0, 0)
render.setLight(lightSunNP)
lightAmb = AmbientLight('light_ambient')
lightAmb.setColor((0.1, 0.1, 0.1, 1))
lightAmbNP = render.attachNewNode(lightAmb)
render.setLight(lightAmbNP)
model = base.loader.loadModel("./warrior.bam")
#model.setPos(0, 3, -0.5)
model.setScale(50)
model.reparentTo(render)
run()
class Dockit(DirectObject):
''' Main class of the Dockit! game '''
# VdW radius scale constant
radius_scale = 1.5
# Step to move ligand
move_step = 50
# Step to rotate ligand
rotate_step = 90
#Instructions
instructions = ['Dock it!','',
'X: a/d','Y: w/s','Z: q/e',
'Heading: r/f','Pitch: t/g','Roll: h/y',
'Cartoon: c','Control: x','Center: z',
'Help: v','Exit: escape']
def __init__(self, width, height, pdb_file1, pdb_file2, full_atom=True, debug=False):
''' Build Dockit! '''
self.multisamples = base.win.getFbProperties().getMultisamples()
self.cartoon = False
self.structures = False
self.help = False
self.text_on_screen = []
self.width = width
self.height = height
# Keyboard events
self.accept('c', self.toggle_cartoon)
self.accept('x', self.toggle_control_structures)
self.accept('z', self.center_camera)
self.accept('v', self.help_on_screen)
self.accept('escape', sys.exit)
self.keyMap = {"a":0, "d":0, "w":0, "s":0, "q":0, "e":0,
"r":0, "f":0, "g":0, "t":0, "h":0, "y":0}
# Load PDB structures
receptor = PDBReader.read_pdb_from_file(pdb_file1)
ligand = PDBReader.read_pdb_from_file(pdb_file2)
receptor.move_to_origin()
ligand.move_to_origin()
# Background
base.setBackgroundColor(0.7, 0.7, 0.7, 1.0)
# Load Color maps
color_map_cpk = CPK()
color_map_bfactor = BFactor(min_value=-14.0, max_value=8.0, middle_value=0.0)
# Load 3D model
self.receptor_node = render.attachNewNode("Receptor")
if full_atom:
self.load_protein_full_atom(receptor, self.receptor_node, color_map_bfactor)
else:
self.load_protein_residue(receptor, self.receptor_node)
self.receptor_node.reparentTo(render)
self.ligand_node = render.attachNewNode("Ligand")
if full_atom:
self.load_protein_full_atom(ligand, self.ligand_node, color_map_cpk)
else:
self.load_protein_residue(ligand, self.ligand_node)
self.ligand_node.reparentTo(render)
# Ambient lights
self.alight = AmbientLight('alight')
self.alight.setColor(LVecBase4f(0.162679, 0.162679, 0.169059, 1.0))
self.alnp = render.attachNewNode(self.alight)
render.setLight(self.alnp)
# Center receptor and ligand
self.center_proteins()
# Center camera on complexes
self.center = loader.loadModel("models/atom_sphere")
self.center.setColor(0.0, 0.53, 0.0, 1.0)
self.center_camera()
# DirectionalLight
self.dlight = DirectionalLight('dlight')
self.dlight.setColor(LVecBase4f(0.797448, 0.660287, 0.743222, 1.0))
self.dlight.setShadowCaster(True, 512, 512)
render.setShaderAuto()
self.dlnp = render.attachNewNode(self.dlight)
self.dlnp.setPos(0,-50,0)
render.setLight(self.dlnp)
self.dlnp.lookAt(self.center)
l1 = loader.loadModel("models/Dirlight")
l1.setColor(1.0, 1.0, 0.0, 1.0)
l1.setPos(0, -50, 0)
l1.setScale(1)
self.lights = [l1]
# Post processing
render.setAntialias(AntialiasAttrib.MAuto)
# Show control structures if required
if self.structures:
for light in self.lights:
light.reparentTo(render)
self.center.reparentTo(render)
# Movement functions
taskMgr.add(self.ligand_movement, 'ligand_movement')
# Key mapping
self.key_bindings()
# Show frame rate
if debug:
base.setFrameRateMeter(True)
# Create two windows from cameras pointing to each molecule
wx = base.win.getProperties().getXOrigin()
wy = base.win.getProperties().getYOrigin()
# Ligand window
wp = WindowProperties()
wp.setSize(300,300)
wp.setOrigin(self.width + wx + 10, wy - 50)
wp.setTitle('From Ligand')
self.ligand_view = base.openWindow(props=wp)
self.cam_ligand = base.camList[1]
self.cam_ligand.setPos(self.center.getX(), self.center.getY(), self.center.getZ())
self.cam_ligand.lookAt(self.receptor_node)
# Receptor window
wp = WindowProperties()
wp.setSize(300,300)
wp.setOrigin(self.width + wx + 10, wy + 300)
wp.setTitle('From Receptor')
self.receptor_view = base.openWindow(props=wp)
self.cam_receptor = base.camList[2]
self.cam_receptor.setPos(self.center.getX(), self.center.getY(), self.center.getZ())
self.cam_receptor.lookAt(self.ligand_node)
def key_bindings(self):
''' Define key bindings '''
base.accept('a', self.setKey, ["a",1])
base.accept('a-up', self.setKey, ["a",0])
base.accept('d', self.setKey, ["d",1])
base.accept('d-up', self.setKey, ["d",0])
base.accept('w', self.setKey, ["w",1])
base.accept('w-up', self.setKey, ["w",0])
base.accept('s', self.setKey, ["s",1])
base.accept('s-up', self.setKey, ["s",0])
base.accept('q', self.setKey, ["q",1])
base.accept('q-up', self.setKey, ["q",0])
base.accept('e', self.setKey, ["e",1])
base.accept('e-up', self.setKey, ["e",0])
base.accept('f', self.setKey, ["f",1])
base.accept('f-up', self.setKey, ["f",0])
base.accept('r', self.setKey, ["r",1])
base.accept('r-up', self.setKey, ["r",0])
base.accept('g', self.setKey, ["g",1])
base.accept('g-up', self.setKey, ["g",0])
base.accept('t', self.setKey, ["t",1])
base.accept('t-up', self.setKey, ["t",0])
base.accept('h', self.setKey, ["h",1])
base.accept('h-up', self.setKey, ["h",0])
base.accept('y', self.setKey, ["y",1])
base.accept('y-up', self.setKey, ["y",0])
def ligand_movement(self, task):
''' Compute ligand movement depending on key bindings '''
if (self.keyMap["a"]!=0):
self.ligand_node.setX(self.ligand_node.getX()-Dockit.move_step * globalClock.getDt())
if (self.keyMap["d"]!=0):
self.ligand_node.setX(self.ligand_node.getX()+Dockit.move_step * globalClock.getDt())
if (self.keyMap["q"]!=0):
self.ligand_node.setY(self.ligand_node.getY()-Dockit.move_step * globalClock.getDt())
if (self.keyMap["e"]!=0):
self.ligand_node.setY(self.ligand_node.getY()+Dockit.move_step * globalClock.getDt())
if (self.keyMap["w"]!=0):
self.ligand_node.setZ(self.ligand_node.getZ()-Dockit.move_step * globalClock.getDt())
if (self.keyMap["s"]!=0):
self.ligand_node.setZ(self.ligand_node.getZ()+Dockit.move_step * globalClock.getDt())
if (self.keyMap["r"]!=0):
self.ligand_node.setH(self.ligand_node.getH()-Dockit.rotate_step * globalClock.getDt())
if (self.keyMap["f"]!=0):
self.ligand_node.setH(self.ligand_node.getH()+Dockit.rotate_step * globalClock.getDt())
if (self.keyMap["g"]!=0):
self.ligand_node.setP(self.ligand_node.getP()-Dockit.rotate_step * globalClock.getDt())
if (self.keyMap["t"]!=0):
self.ligand_node.setP(self.ligand_node.getP()+Dockit.rotate_step * globalClock.getDt())
if (self.keyMap["h"]!=0):
self.ligand_node.setR(self.ligand_node.getR()-Dockit.rotate_step * globalClock.getDt())
if (self.keyMap["y"]!=0):
self.ligand_node.setR(self.ligand_node.getR()+Dockit.rotate_step * globalClock.getDt())
return task.cont
def setKey(self, key, value):
''' Record the state of the arrow keys '''
self.keyMap[key] = value
def load_protein_full_atom(self, protein, node, color_map):
''' Display a given protein using spheres models for each atom '''
atoms = protein.get_atoms()
self.atom_objects = []
for atom in atoms:
a = loader.loadModel("models/atom_sphere")
a.setPos(atom.get_x(), atom.get_y(), atom.get_z())
a.setScale(atom.get_radius() / Dockit.radius_scale)
self.apply_color(a, atom, color_map)
a.reparentTo(node)
node.flattenStrong()
def load_protein_residue(self, protein, node):
''' Display a given protein using spheres models for each atom '''
residues = protein.get_residues()
self.residues_objects = []
for residue in residues:
r = loader.loadModel("models/atom_sphere")
x,y,z = residue.get_center_coordinates()
r.setPos(x, y, z)
r.setScale(4.0 / Dockit.radius_scale)
r.setColor(LVecBase4f(1.0, 0.59, 0.0, 1.0))
r.setColorScale(LVecBase4f(1, 1, 1, 1))
r.reparentTo(node)
node.flattenStrong()
def apply_color(self, a3d, atom, color_map):
''' Apply a color map to the element '''
if isinstance(color_map, BFactor):
color = color_map.get_color_by_bfactor(atom.get_b_factor())
else:
color = color_map.get_color_by_element(atom.get_element())
red, green, blue, alpha = color.get_rgba()
a3d.setColor(LVecBase4f(red, green, blue, alpha))
a3d.setColorScale(LVecBase4f(1, 1, 1, 1))
def toggle_cartoon(self):
''' Use Cartoon ink filter '''
self.cartoon = not self.cartoon
if self.cartoon:
tempnode = NodePath(PandaNode("temp node"))
tempnode.setAttrib(LightRampAttrib.makeSingleThreshold(0.4, 0.6))
tempnode.setShaderAuto()
base.cam.node().setInitialState(tempnode.getState())
self.separation = 1.3 # Pixels
self.filters = CommonFilters(base.win, base.cam)
self.filters.setCartoonInk(separation=self.separation)
# Currently using MAuto antialias, uncomment to use different
#render.setAntialias(AntialiasAttrib.MBetter)
#self.filters.finalQuad.setAntialias(AntialiasAttrib.MBetter)
else:
self.filters.cleanup()
base.cam.node().setInitialState(self.alight.getState())
def toggle_control_structures(self):
''' Show control structures as lights and center nodes and bounds if required '''
self.structures = not self.structures
for light in self.lights:
if not self.structures:
light.detachNode()
else:
light.reparentTo(render)
if self.structures:
self.receptor_node.showBounds()
self.ligand_node.showBounds()
self.center.reparentTo(render)
print "Number of multisamples available: %d" % self.multisamples
else:
self.receptor_node.hideBounds()
self.ligand_node.hideBounds()
self.center.detachNode()
def center_proteins(self):
''' Move receptor and ligand to a centered position depending on its size '''
# Center the receptor
receptor_radius = self.receptor_node.getBounds().getRadius()
receptor_center = self.receptor_node.getBounds().getCenter()
self.receptor_node.setPos(0,receptor_radius,0)
# Center the ligand
ligand_radius = self.ligand_node.getBounds().getRadius()
self.ligand_node.setPos(receptor_center[0]-receptor_radius-ligand_radius,
receptor_center[1],
receptor_center[2])
self.ligand_node.lookAt(self.receptor_node)
def center_camera(self):
''' Center camera on scene '''
xc, yc, zc = (self.receptor_node.getBounds().getCenter() + self.ligand_node.getBounds().getCenter()) / 2.0
self.center.setPos(xc, yc, zc)
ligand_radius = self.ligand_node.getBounds().getRadius()
receptor_radius = self.receptor_node.getBounds().getRadius()
scene_center = self.center.getPos()
base.cam.setPos(scene_center[0], -10-scene_center[1]-2*ligand_radius-2*receptor_radius, scene_center[2])
base.cam.lookAt(self.center)
def help_on_screen(self):
''' Show commands on screen '''
self.help = not self.help
if self.help:
i = 0
for instruction in Dockit.instructions:
self.text_on_screen.append(self.__gen_label_text(instruction,i))
i += 1
else:
for text in self.text_on_screen:
text.destroy()
del self.text_on_screen[:]
def __gen_label_text(self, text, i):
''' Auxiliar function to display text line by line '''
return OnscreenText(text = text, pos = (-1.6, .9-.06*i), fg=(1,1,1,1),
align = TextNode.ALeft, scale=0.06, mayChange = 0)
