def __init__(self):
ShowBase.__init__(self)
# Turn Auto Shaders and Antialiasing
self.render.setShaderAuto()
self.render.setAntialias(AntialiasAttrib.MAuto)
# Setup Bloom and Blur Filters
self.filters = CommonFilters(base.win, base.cam)
self.filters.setBloom(blend=(1, 0, 0, 1),
desat=-0.5,
intensity=6.0,
size=2)
#self.filters.setBlurSharpen(amount=0.5)
# Create Ambient Lighting
alight = AmbientLight('alight')
alight.setColor(VBase4(1, 1, 1, 1))
alnp = render.attachNewNode(alight)
self.render.setLight(alnp)
# Load Model and Add it to Scene
self.environ = self.loader.loadModel("untitled.egg")
self.environ.reparentTo(self.render)
self.environ.setTransparency(TransparencyAttrib.MAlpha)
def __init__(self):
BaseRenderer.__init__(self) # <- important
ShowBase.__init__(self)
client = BulletClient(pb.DIRECT)
client.setAdditionalSearchPath(pybullet_data.getDataPath())
self.client = client
# bind external renderer
plugin = RenderingPlugin(client, self)
# setup scene
self.nodes = {}
self.camLens.setNearFar(3, 7)
self.camLens.setFilmSize(Vec2(0.030, 0.030))
self.render.setAntialias(AntialiasAttrib.MAuto)
self.render.setDepthOffset(1)
self.render.setShaderAuto()
self.setupScene(client)
self.setupLights()
# setup filters
if args.ambient_occlusion:
filters = CommonFilters(self.win, self.cam)
filters.setAmbientOcclusion()
# setup periodic tasks
self.time = 0
self.taskMgr.add(self.spinCameraTask, "SpinCameraTask")
self.taskMgr.add(self.stepSimulationTask, "StepSimulationTask")
if args.debug:
self.oobe()
class MyApp(ShowBase):
def __init__(self):
ShowBase.__init__(self)
# Turn Auto Shaders and Antialiasing
self.render.setShaderAuto()
self.render.setAntialias(AntialiasAttrib.MAuto)
# Setup Bloom and Blur Filters
self.filters = CommonFilters(base.win, base.cam)
self.filters.setBloom(blend=(1,0,0,1), desat=-0.5, intensity=6.0, size=2)
#self.filters.setBlurSharpen(amount=0.5)
# Create Ambient Lighting
alight = AmbientLight('alight')
alight.setColor(VBase4(1, 1, 1, 1))
alnp = render.attachNewNode(alight)
self.render.setLight(alnp)
# Load Model and Add it to Scene
self.environ = self.loader.loadModel("untitled.egg")
self.environ.reparentTo(self.render)
self.environ.setTransparency(TransparencyAttrib.MAlpha)
def __init__(self):
base.disableMouse()
# Turns off the default mouse-camera controls in Panda3D.
base.setBackgroundColor(0, 0, 0)
# Sets the background to black.
self.inputManager = InputManager()
# Creates an InputManager to handle all of the user input in the game.
self.track = Track()
# Creates the track the cycles will race on.
self.cycle1 = Cycle(self.inputManager, self.track, 1, "Bert", ai=False)
self.cycle2 = Cycle(self.inputManager, self.track, 2, "Ernie")
# Creates one uncontrolled cycle, and one player controlled cycle.
taskMgr.doMethodLater(10, self.debugTask, "Debug Task")
# Tells the debugTask to run once every ten seconds. The debug task is a good
# place to put various data print outs about the game to help with debugging.
self.filters = CommonFilters(base.win, base.cam)
filterok = self.filters.setBloom(blend=(0, 0, 0, 1),
desat=-0.5,
intensity=3.0,
size=2)
render.setShaderAuto()
def __init__(self):
ShowBase.__init__(self)
base.setBackgroundColor(0, 0, 0)
#render.setShaderAuto()
#Load the Lights
ambilight = AmbientLight('ambilight')
ambilight.setColor(VBase4(1, 1, 1, 1))
render.setLight(render.attachNewNode(ambilight))
self.filters = CommonFilters(base.win, base.cam)
filterok = self.filters.setBloom(blend=(0, 0, 0, 1),
desat=-0.8,
intensity=4.0,
size="big")
## self.glowSize=4
## ts = TextureStage('ts')
## ts.setMode(TextureStage.MGlow)
self.tron = loader.loadModel("data/models/vehicles/vehicle01")
self.tron.reparentTo(render)
self.tron2 = loader.loadModel("data/models/vehicles/vehicle02")
self.tron2.reparentTo(render)
self.tron2.setX(5)
self.tron3 = loader.loadModel("data/models/vehicles/vehicle03")
self.tron3.reparentTo(render)
self.tron3.setX(-5)
def __init__(self):
#Create a buffer for storing the shadow texture,
#the higher the buffer size the better quality the shadow.
self.shadowBuffer = base.win.makeTextureBuffer("Shadow Buffer",2048,2048)
self.shadowBuffer.setClearColorActive(True)
self.shadowBuffer.setClearColor((0,0,0,1))
self.shadowCamera = base.makeCamera(self.shadowBuffer)
self.shadowCamera.reparentTo(render)
self.lens = base.camLens
self.lens.setAspectRatio(1/1)
self.shadowCamera.node().setLens(self.lens)
self.shadowCamera.node().setCameraMask(BitMask32.bit(1))
#Make everything rendered by the shadow camera grey:
self.initial = NodePath('initial')
self.initial.setColor(.75,.75,.75,1,1)
self.initial.setTextureOff(2)
self.initial.setMaterialOff(2)
self.initial.setLightOff(2)
self.shadowCamera.node().setInitialState(self.initial.getState())
#The cameras pos effects the shadows dirrection:
self.shadowCamera.setPos(-10, 0,20)
self.shadowCamera.lookAt(0,0,0)
#Make the shadows soft by bluring the screen:
self.filters = CommonFilters(self.shadowBuffer,self.shadowCamera)
self.filters.setBlurSharpen(.1)
self.shadowTexture = self.shadowBuffer.getTexture()
#Draw the shadowTexture on sceen:
self.imageObject = OnscreenImage(image = self.shadowTexture,pos = (-.75,0,.75),scale=.2)
def __createBuffer(self):
if self.shadowsHidden or not (self.shadowsEnabled):
return None
self.__destroyBuffer()
if not base.win.getGsg():
return None
if self.fMoreShadows and False:
self.shadowBuffer = base.win.makeTextureBuffer('shadow',
1024 * 4,
1024 * 4,
tex=self.shadowTex)
else:
self.shadowBuffer = base.win.makeTextureBuffer('shadow',
1024,
1024,
tex=self.shadowTex)
#self.shadowBuffer.setSort(30)
self.shadowBuffer.setClearColor(self.clearColor)
dr = self.shadowBuffer.makeDisplayRegion()
dr.setCamera(self.shadowCam)
#self.setupTask = taskMgr.doMethodLater(0, self.__setupCamera, 'setupCamera')
self.filters = CommonFilters(self.shadowBuffer, self.shadowCam)
self.filters.setBlurSharpen(.5)
def __init__(self):
#loadPrcFile("Config.prc")
ShowBase.__init__(self)
self.config = ConfigManager.loadSettings()
#Config stuff here
self.filters = CommonFilters(base.win, base.cam)
self.AOEnabled = False
self.bloomEnabled = False
self.invertEnabled = False
self.OSD = True
self.shadersLoaded = False
self.xray_mode = False
self.show_model_bounds = False
self.fogEnabled = True
self.mouseEnabled = False
#Store which keys are currently pressed
self.keyMap = {
"1": 0,
"escape": 0,
"left": 0,
"right": 0,
"forward": 0,
"backward": 0,
"cam-left": 0,
"cam-right": 0,
}
self.ButtonImage = loader.loadModel(
"phase_3/models/gui/quit_button.bam")
self.introButtons()
def __init__(self):
ShowBase.__init__(self)
self.disableMouse()
props = WindowProperties()
props.setTitle('Test')
self.win.requestProperties(props)
# self.render.setAntiAlias(AntialiasAttrib.MAuto)
self.transitions = Transitions(self.loader)
self.transitions.setFadeColor(0, 0, 0)
self.filters = CommonFilters(self.win, self.cam)
# self.filters.setCartoonInk()
self.filters.setBlurSharpen(1)
# self.filters.setVolumetricLighting(self.render)
# self.buffer = self.win.makeTextureBuffer("Post-processing buffer", self.win.getXSize(), self.win.getXSize())
# print self.buffer.getYSize()
# self.texture = self.buffer.getTexture()
# self.buffer.setSort(-100)
#
# self.originalCamera = self.camera
# self.offScreenCamera = self.makeCamera(self.buffer)
# self.camera = self.offScreenCamera
#
# self.img = OnscreenImage(image=self.texture, pos=(0, 0, 0.5))
self.scene = None
self.channel = Channel()
def __init__(self):
base.disableMouse()
# Turns off the default mouse-camera controls in Panda3D.
base.setBackgroundColor(0, 0, 0)
# Sets the background to black.
self.inputManager = InputManager()
# Creates an InputManager to handle all of the user input in the game.
taskMgr.doMethodLater(10, self.debugTask, "Debug Task")
# Tells the debugTask to run once every ten seconds. The debug task is a good
# place to put various data print outs about the game to help with debugging.
self.filters = CommonFilters(base.win, base.cam)
filterok = self.filters.setBloom(blend=(0, 0, 0, 1),
desat=-0.5,
intensity=3.0,
size=2)
render.setShaderAuto()
# Turns on Panda3D's automatic shader generation.
self.menuGraphics = loader.loadModel("../Models/MenuGraphics.egg")
self.fonts = {
"silver": loader.loadFont("../Fonts/LuconSilver.egg"),
"blue": loader.loadFont("../Fonts/LuconBlue.egg"),
"orange": loader.loadFont("../Fonts/LuconOrange.egg")
}
self.race = Race(self.inputManager)
self.race.createDemoRace()
self.createStartMenu()
class ShadowCreator:
def __init__(self):
self.shadowBuffer = base.win.makeTextureBuffer('Shadow Buffer', 2048,
2048)
self.shadowBuffer.setClearColorActive(True)
self.shadowBuffer.setClearColor((0, 0, 0, 1))
self.shadowCamera = base.makeCamera(self.shadowBuffer)
self.shadowCamera.reparentTo(render)
self.lens = base.camLens
self.lens.setAspectRatio(1 / 1)
self.shadowCamera.node().setLens(self.lens)
self.shadowCamera.node().setCameraMask(BitMask32.bit(1))
self.initial = NodePath('initial')
self.initial.setColor(0.75, 0.75, 0.75, 1, 1)
self.initial.setTextureOff(2)
self.initial.setMaterialOff(2)
self.initial.setLightOff(2)
self.shadowCamera.node().setInitialState(self.initial.getState())
self.shadowCamera.setPos(-10, 0, 20)
self.shadowCamera.lookAt(0, 0, 0)
self.filters = CommonFilters(self.shadowBuffer, self.shadowCamera)
self.filters.setBlurSharpen(0.1)
self.shadowTexture = self.shadowBuffer.getTexture()
self.imageObject = OnscreenImage(image=self.shadowTexture,
pos=(-0.75, 0, 0.75),
scale=0.2)
def toggleAmbientOcclusion(self, checked): filters = CommonFilters(base.win, base.cam) if checked == True: filters.setAmbientOcclusion() else: filters.delAmbientOcclusion()
def toggleToonShading(self, checked): filters = CommonFilters(base.win, base.cam) if checked == True: filters.setCartoonInk() else: filters.delCartoonInk()
def setBloomed(self):
#setupfilters and shaders
self.filters = CommonFilters(base.win, base.cam)
#self.filters.setCartoonInk(separation=1.0)
self.filters.setBloom(size="small")
#self.filters.setVolumetricLighting(myCamera.cameraLightNode)
render.setAttrib(LightRampAttrib.makeHdr0())
pass
def __init__(self):
ShowBase.__init__(self)
# Disable the camera trackball controls.
self.disableMouse()
# Load the environment model.
self.environ = self.loader.loadModel("models/environment")
# Reparent the model to render.
self.environ.reparentTo(self.render)
# Apply scale and position transforms on the model.
self.environ.setScale(0.25, 0.25, 0.25)
self.environ.setPos(-8, 42, 0)
# Add the spinCameraTask procedure to the task manager.
self.taskMgr.add(self.spinCameraTask, "SpinCameraTask")
# Load and transform the panda actor.
self.pandaActor = Actor(models="models/panda-model",
anims={"walk": "models/panda-walk4"})
self.pandaActor.setScale(0.005, 0.005, 0.005)
self.pandaActor.reparentTo(self.render)
# Loop its animation.
self.pandaActor.loop("walk")
# Create the four lerp intervals needed for the panda to
# walk back and forth.
A = Point3(0, 10, 0)
B = Point3(0, -10, 0)
pandaPosInterval1 = self.pandaActor.posInterval(13, B, startPos=A)
pandaPosInterval2 = self.pandaActor.posInterval(13, A, startPos=B)
pandaHprInterval1 = self.pandaActor.hprInterval(3,
Point3(180, 0, 0),
startHpr=Point3(
0, 0, 0))
pandaHprInterval2 = self.pandaActor.hprInterval(3,
Point3(0, 0, 0),
startHpr=Point3(
180, 0, 0))
# Create and play the sequence that coordinates the intervals.
self.pandaPace = Sequence(pandaPosInterval1,
pandaHprInterval1,
pandaPosInterval2,
pandaHprInterval2,
name="pandaPace")
self.pandaPace.loop()
self.teapot = self.loader.loadModel('models/teapot')
self.teapot.reparentTo(self.render)
self.console = Console(self)
self.filters = CommonFilters(self.win, self.cam)
self.filters.setCartoonInk()
self.filters.setAmbientOcclusion()
self.filters.setBloom()
class BurdenOfProof(ShowBase):
def __init__(self):
ShowBase.__init__(self)
self.useAdvancedVisualEffects = ConfigVariableBool(
"use-advanced-visual-effects", True)
self.game = Game()
self.setupFilters()
self.setupModels()
self.setupKeyboardControl()
self.motionController = MotionController(self)
self.camera.setPos(0.0, 0.0, 1.7)
def setupKeyboardControl(self):
self.accept("escape", sys.exit)
def setupFilters(self):
if (self.useAdvancedVisualEffects):
self.filters = CommonFilters(self.win, self.cam)
self.filters.setBloom()
def setupModels(self):
self.cityModel = self.loader.loadModel("data/models/city")
self.cityModel.reparentTo(self.render)
self.cityModel.setP(-90.0)
self.pandaActor = Actor("models/panda-model",
{"walk": "models/panda-walk4"})
self.pandaActor.setScale(0.005, 0.005, 0.005)
self.pandaActor.loop("walk")
population = self.game.getPopulation()
self.characterInstances = []
for i in range(1, population.getCharacterCount()):
instance = self.render.attachNewNode("characterInstance")
instance.setPos(
population.getCharacter(i).getPosition(self.game.getTime()))
self.pandaActor.instanceTo(instance)
self.characterInstances.append(instance)
self.taskMgr.add(self.update, "updateTask")
def update(self, task):
self.game.update(oneMinute) # TODO(?) compute actual milliseconds
population = self.game.getPopulation()
for i in range(1, population.getCharacterCount()):
self.characterInstances[i - 1].setPos(
population.getCharacter(i).getPosition(self.game.getTime()))
return Task.cont
class filters():
def __init__(self):
self.filters = CommonFilters(base.win, base.cam)
self.initCartoonInk()
def initCartoonInk(self):
self.filters.setCartoonInk(separation=-1)
class BurdenOfProof(ShowBase):
def __init__(self):
ShowBase.__init__(self)
self.useAdvancedVisualEffects = ConfigVariableBool(
"use-advanced-visual-effects", True)
self.game = Game()
self.setupFilters()
self.setupModels()
self.setupKeyboardControl()
self.motionController = MotionController(self)
self.camera.setPos(0.0, 0.0, 1.7)
def setupKeyboardControl(self):
self.accept("escape", sys.exit)
def setupFilters(self):
if (self.useAdvancedVisualEffects):
self.filters = CommonFilters(self.win, self.cam)
self.filters.setBloom()
def setupModels(self):
self.cityModel = self.loader.loadModel("data/models/city")
self.cityModel.reparentTo(self.render)
self.cityModel.setP(-90.0)
self.pandaActor = Actor("models/panda-model",
{"walk": "models/panda-walk4"})
self.pandaActor.setScale(0.005, 0.005, 0.005)
self.pandaActor.loop("walk")
population = self.game.getPopulation()
self.characterInstances = []
for i in range(1, population.getCharacterCount()):
instance = self.render.attachNewNode("characterInstance")
instance.setPos(
population.getCharacter(i).getPosition(self.game.getTime()))
self.pandaActor.instanceTo(instance)
self.characterInstances.append(instance)
self.taskMgr.add(self.update, "updateTask")
def update(self, task):
self.game.update(oneMinute) # TODO(?) compute actual milliseconds
population = self.game.getPopulation()
for i in range(1, population.getCharacterCount()):
self.characterInstances[i - 1].setPos(
population.getCharacter(i).getPosition(self.game.getTime()))
return Task.cont
class filters():
def __init__(self):
self.filters = CommonFilters(base.win, base.cam)
self.initCartoonInk()
def initCartoonInk(self):
self.filters.setCartoonInk(separation= -1)
def __init__(self):
base.disableMouse()
# Turns off the default mouse-camera controls in Panda3D.
base.setBackgroundColor(0, 0, 0)
# Sets the background to black.
self.inputManager = InputManager()
# Creates an InputManager to handle all of the user input in the game.
#taskMgr.doMethodLater(10, self.debugTask, "Debug Task")
# Tells the debugTask to run once every ten seconds. The debug task is a good
# place to put various data print outs about the game to help with debugging.
self.filters = CommonFilters(base.win, base.cam)
filterok = self.filters.setBloom(blend=(0, 0, 0, 1),
desat=-0.5,
intensity=3.0,
size=2)
# Creates a bloom filter that will integrate with the Glow maps applied to objects to create
# the halos around glowing objects.
render.setShaderAuto()
# Turns on Panda3D's automatic shader generation.
self.menuGraphics = loader.loadModel("../Models/MenuGraphics.egg")
# Loads the egg that contains all the menu graphics.
self.fonts = {
"silver": loader.loadFont("../Fonts/LuconSilver.egg"),
"blue": loader.loadFont("../Fonts/LuconBlue.egg"),
"orange": loader.loadFont("../Fonts/LuconOrange.egg")
}
# Loads the three custom fonts our game will use.
preloader = Preloader(self.fonts)
hud = HUD(self.fonts)
# Creates the HUD.
self.race = Race(self.inputManager, hud)
self.race.createDemoRace()
# creates an instance of the race class and tells it to
# start a demo race.
self.createStartMenu()
# creates the start menu.
musicMgr = base.musicManager
self.music = musicMgr.getSound(
"../Sound/Loveshadow-Takin_Yo_Time_(The_Wingman_Mix).wav")
self.music.setLoop(True)
self.music.setVolume(.5)
self.music.play()
def _loadFilters(self):
self.terrain.setShaderInput('waterlevel', self._water_level)
# load default shaders
cf = CommonFilters(base.win, base.cam)
# bloomSize
cf.setBloom(size='small', desat=0.7, intensity=1.5, mintrigger=0.6, maxtrigger=0.95)
# hdrtype:
render.setAttrib(LightRampAttrib.makeHdr1())
# perpixel:
render.setShaderAuto()
def _loadFilters(self):
self.terrain.setShaderInput('waterlevel', self._water_level)
# load default shaders
cf = CommonFilters(base.win, base.cam)
#bloomSize
cf.setBloom(size='small', desat=0.7, intensity=1.5, mintrigger=0.6, maxtrigger=0.95)
#hdrtype:
render.setAttrib(LightRampAttrib.makeHdr1())
#perpixel:
render.setShaderAuto()
def postProcessingChanged():
global filters
if enablePostProcessing:
if filters == None:
filters = CommonFilters(base.win, base.cam)
render.setAttrib(LightRampAttrib.makeHdr1())
filters.setBloom(intensity = 1, size = 2)
else:
if filters != None:
filters.delBloom()
saveConfigFile()
def __init__(self, mouse):
ShowBase.__init__(self)
self.mouse = mouse
self.joy_x = None
self.joy_y = None
props = WindowProperties()
props.setMouseMode(WindowProperties.MRelative) # keep mouse in screen
self.disableMouse()
self.win.requestProperties(props)
self.setBackgroundColor(0, 0, 0)
# Make missiles glow
self.filters = CommonFilters(self.win, self.cam)
self.filters.setBloom(blend=(0, 0, 0, 1), desat=-0.5, intensity=3.0, size="large")
self.screen_width = self.win.getXSize()
self.screen_height = self.win.getYSize()
self.center_x = self.screen_width/2
self.center_y = self.screen_height/2
# self.win.movePointer(0, self.center_x, self.center_y)
self.enableParticles()
self.cTrav = CollisionTraverser()
# self.cTrav.setRespectPrevTransform(True)
self.pusher = PhysicsCollisionHandler()
self.pusher.addInPattern('%fn-into-%in')
self.target = None
self.maxvel = 50
self.roll_time = 0
self.fuel = 1000
self.ship()
self.sounds()
self.hud()
self.part = Spacedust(self)
self.events()
self.camLens.setFov(70)
self.camLens.setNear(1)
self.camLens.setFar(500)
self.get_key = {
"ACCEL": False,
"DECEL": False,
"FORWARD_THRUST": False,
"REVERSE_THRUST": False,
"ROLL_LEFT": False,
"ROLL_RIGHT": False,
"ROLL_LEFT_BEG": False,
"ROLL_RIGHT_BEG": False,
"FIRE": False,
"FIRING": False,
"LOCK": False,
"LOCKING": False,
}
self.AIworld = AIWorld(self.render)
self.taskMgr.add(self.update, "task-update")
self.taskMgr.doMethodLater(1, self.fuel_usage, "task-fuel-usage")
self.taskMgr.add(self.AI_update, "AI-update")
self.gen_enemy()
class Filters:
"""Class handles postprocessing filters and effects"""
def __init__(self,manager,xml):
self.cf = CommonFilters(base.win,base.cam)
self.reload(manager,xml)
def reload(self,manager,xml):
hdr = xml.find('hdr')
if hdr!=None:
self.hdrtype = hdr.get('type')
assert self.hdrtype in ['0', '1', '2']
else:
self.hdrtype = None
self.perpixel = xml.find('perpixel')!=None
bloom = xml.find('bloom')
if bloom!=None:
self.bloomSize = bloom.get('size', 'medium')
else:
self.bloomSize = None
self.showbuffers = xml.find('showbuffers')!=None
def start(self):
if self.hdrtype!=None:
render.setAttrib(getattr(LightRampAttrib, "makeHdr" + self.hdrtype)())
if self.perpixel:
render.setShaderAuto()
if self.bloomSize!=None:
self.cf.setBloom(size=self.bloomSize)
if self.showbuffers:
base.bufferViewer.toggleEnable()
def stop(self):
if self.hdrtype!=None:
render.clearAttrib(LightRampAttrib.getClassType())
if self.perpixel:
render.setShaderOff()
if self.bloomSize!=None:
self.cf.delBloom()
if self.showbuffers:
base.bufferViewer.toggleEnable()
def initShader(self):
tempnode = NodePath(PandaNode("temp node"))
tempnode.setAttrib(LightRampAttrib.makeSingleThreshold(0.5, 0.9))
tempnode.setShaderAuto()
base.cam.node().setInitialState(tempnode.getState())
self.separation = 1 # Pixels
self.filters = CommonFilters(base.win, base.cam)
filterok = self.filters.setBloom()
if (filterok == False):
addTitle(
"Toon Shader: Video card not powerful enough to do image postprocessing"
)
sys.exit
class ShaderManager():
def __init__(self):
#needed for physics and particle system
base.enableParticles()
render.setShaderAuto()
def setBloomed(self):
#setupfilters and shaders
self.filters = CommonFilters(base.win, base.cam)
#self.filters.setCartoonInk(separation=1.0)
self.filters.setBloom(size="small")
#self.filters.setVolumetricLighting(myCamera.cameraLightNode)
render.setAttrib(LightRampAttrib.makeHdr0())
pass
def __init__(self):
base.enableParticles() # noqa: F821
render.setShaderAuto() # noqa: F821
self._explosion_lights = self._set_explosion_lights()
self._transition = Transitions(loader) # noqa: F821
self._transition.setFadeColor(0, 0, 0)
self.stench_effect = Stench()
self.love_fog = LoveFog()
filters = CommonFilters(base.win, base.cam) # noqa: F821
filters.setBloom(size="large", mintrigger=0.8, intensity=2.1)
def __init__(self, parent):
self._parent = parent
DirectFrame.__init__(self,
parent=self._parent,
relief=None,
pos=(0.0, 0.0, 0.0),
scale=(1.0, 1.0, 1.0))
self.filter = CommonFilters(base.win,
base.cam) # Only affects primary window
# Ambient Occlusion
self.samples = 0
self.radius = 0.0
self.amount = 0.0
self.strength = 0.0
# Blur/Sharpen
self.blur = 1.0 # this is normal value, 0.0 blurs it
# Cartoon Ink
self.cartoonSep = 0.0
self.cartoonR = 0.0
self.cartoonB = 0.0
self.cartoonG = 0.0
# todo: Add bloom
# Boolean Filters
self.HDREnabled = False
self.invertedEnabled = False
self.sRGBEnabled = False
self.halfPixelShiftEnabled = False
self.viewGlowEnabled = False
# Other Filters
self.exposure = 0.0
self.SAMPLES_MAX = 128
self.RAD_MAX = 1.0
self.AMT_MAX = 64.0
self.STR_MAX = 0.01
self.INCREMENT = 1
self.numSamples = None
self.numRadius = None
self.circleModel = loader.loadModel(
'phase_3/models/gui/tt_m_gui_mat_nameShop')
self.barTexture = loader.loadTexture('phase_3/maps/slider.png')
self.loadGUI()
def __init__(self):
super().__init__()
self.set_background_color(0, 0, 0, 1)
self.cam.setPos(0, -12, 0)
self.trees = NodePath("trees")
self.tree1 = self.loader.loadModel('my-models/christmas_tree')
self.tree1.setPos(0, 0, -2.5)
self.tree1.reparentTo(self.trees)
self.tree2 = self.loader.loadModel('my-models/christmas_tree')
self.tree2.setPos(4, 5, -2.5)
self.tree2.reparentTo(self.trees)
self.tree3 = self.loader.loadModel('my-models/christmas_tree')
self.tree3.setPos(-4, 7, -2.5)
self.tree3.reparentTo(self.trees)
self.trees.reparentTo(self.render)
self.floor = self.loader.loadModel('my-models/floor')
self.floor.setPos(0, 0, -2.5)
self.floor.reparentTo(self.render)
self.light_model = self.loader.loadModel('models/misc/sphere')
self.light_model.setScale(0.2, 0.2, 0.2)
# self.light_model.setPos(4, -4, 0)
self.light_model.reparentTo(self.render)
plight = PointLight("plight")
plight.setShadowCaster(True, 1024, 1024)
self.render.setShaderAuto()
plnp = self.light_model.attachNewNode(plight)
# plight.setAttenuation((1, 0, 0)) # constant, linear, and quadratic.
self.trees.setLight(plnp)
alight = AmbientLight("alight")
alight.setColor((0.04, 0.04, 0.04, 1))
alnp = self.render.attachNewNode(alight)
self.trees.setLight(alnp)
self.floor.setLight(plnp)
self.floor.setLight(alnp)
filters = CommonFilters(self.win, self.cam)
filters.setBloom(size="large")
self.taskMgr.add(self.move_light, "move-light")
def __init__(self):
ShowBase.__init__(self)
self.disableMouse()
props = WindowProperties()
props.setTitle('Test')
self.win.requestProperties(props)
# self.render.setAntiAlias(AntialiasAttrib.MAuto)
self.transitions = Transitions(self.loader)
self.transitions.setFadeColor(0, 0, 0)
self.filters = CommonFilters(self.win, self.cam)
# self.filters.setCartoonInk()
self.filters.setBlurSharpen(1)
# self.filters.setVolumetricLighting(self.render)
# self.buffer = self.win.makeTextureBuffer("Post-processing buffer", self.win.getXSize(), self.win.getXSize())
# print self.buffer.getYSize()
# self.texture = self.buffer.getTexture()
# self.buffer.setSort(-100)
#
# self.originalCamera = self.camera
# self.offScreenCamera = self.makeCamera(self.buffer)
# self.camera = self.offScreenCamera
#
# self.img = OnscreenImage(image=self.texture, pos=(0, 0, 0.5))
self.scene = None
self.channel = Channel()
def runConfiguration():
#Grundeinstellungen
base.setFrameRateMeter(True)
base.setBackgroundColor(0, 0, 0)
#Bloom Filter
CFilters = CommonFilters(base.win, base.cam)
filterok = CFilters.setBloom(blend=(0, 0, 0, 1),
desat=-0.1,
mintrigger=0.0,
intensity=6.0,
size="small")
if filterok == 0:
print "Deine Grafikkarte unterstuetzt kein Bloom Filter: Shader Error"
def __init__(self):
base.disableMouse()
base.setBackgroundColor(0.52, 0.80, 0.99)
self.inputManager = InputManager()
self.filters = CommonFilters(base.win, base.cam)
filterok = self.filters.setBloom(blend=(0, 0, 0, 1), desat=-0.5, intensity=3.0, size=2)
render.setShaderAuto()
self.menuGraphics = loader.loadModel("Models/MenuGraphics.egg")
self.fonts = {
"silver": loader.loadFont("Fonts/LuconSilver.egg"),
"blue": loader.loadFont("Fonts/LuconBlue.egg"),
"orange": loader.loadFont("Fonts/LuconOrange.egg")
}
gui = Gui(self.fonts)
self.race = Race(self.inputManager, gui)
self.race.createDemoRace()
self.createStartMenu()
musicMgr = base.musicManager
self.music = musicMgr.getSound("Sound/music_1.wav")
self.music.setLoop(True)
self.music.setVolume(.5)
self.music.play()
def postInit(self):
#
# initialize game content
#
# camera
base.camLens.setNearFar(1.0, 10000)
base.camLens.setFov(75)
a = 33
base.camera.setPos(0, -a, a + 3) #80)
# collision
base.cTrav = CollisionTraverser("base collision traverser")
base.cHandler = CollisionHandlerEvent()
base.cPusher = CollisionHandlerPusher()
base.cQueue = CollisionHandlerQueue()
base.globalClock = ClockObject.getGlobalClock()
base.cHandler.addInPattern('%fn-into-%in')
base.cHandler.addOutPattern('%fn-out-%in')
base.cHandler.addAgainPattern('%fn-again-%in')
# ai init
base.AIworld = AIWorld(render)
# 3d manager
base.audio3d = Audio3DManager(base.sfxManagerList[0], camera)
# manager
self.archiveManager = ArchiveManager()
self.mapManager = MapManager()
self.initHeroInfo = None
# Lock
self.lock = threading.Lock()
self.gameThread = None
self.filters = CommonFilters(base.win, base.cam)
# UI
self.menu = Menu()
self.option = Option()
self.archive = Archive()
self.death = Death()
# self.oobe()
#self.Archive_status = 0
# self.menuMusic = loader.loadMusic("assets/audio/menuMusic.ogg")
# self.menuMusic.setLoop(True)
# self.fightMusic = loader.loadMusic("assets/audio/fightMusic.ogg")
# self.fightMusic.setLoop(True)
# base.audio3d = Audio3DManager(base.sfxManagerList[0], camera)
self.titleVideo, self.titleCard = loadVideo('title.mp4')
self.isInited = False
self.isSkip = False
self.isRenew = False
#
# Event handling
#
self.accept("escape", self.__escape)
#
# Start with the menu
#
self.request("Menu")
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())
class ToonMaker(DirectObject):
def __init__(self):
base.disableMouse()
base.cam.node().getLens().setNear(10.0)
base.cam.node().getLens().setFar(9999999)
camera.setPos(0, -50, 0)
# Check video card capabilities.
if (base.win.getGsg().getSupportsBasicShaders() == 0):
addTitle("Toon Shader: Video driver reports that shaders are not supported.")
return
# Enable a 'light ramp' - this discretizes the lighting,
# which is half of what makes a model look like a cartoon.
# Light ramps only work if shader generation is enabled,
# so we call 'setShaderAuto'.
tempnode = NodePath(PandaNode("temp node"))
tempnode.setAttrib(LightRampAttrib.makeSingleThreshold(0.5, 0.4))
tempnode.setShaderAuto()
base.cam.node().setInitialState(tempnode.getState())
# Use class 'CommonFilters' to enable a cartoon inking filter.
# This can fail if the video card is not powerful enough, if so,
# display an error and exit.
self.separation = 1 # Pixels
self.filters = CommonFilters(base.win, base.cam)
filterok = self.filters.setCartoonInk(separation=self.separation)
if (filterok == False):
addTitle("Toon Shader: Video card not powerful enough to do image postprocessing")
return
# Create a non-attenuating point light and an ambient light.
plightnode = PointLight("point light")
plightnode.setAttenuation(Vec3(1,0,0))
plight = render.attachNewNode(plightnode)
plight.setPos(30,-50,0)
alightnode = AmbientLight("ambient light")
alightnode.setColor(Vec4(0.8,0.8,0.8,1))
alight = render.attachNewNode(alightnode)
render.setLight(alight)
render.setLight(plight)
# Panda contains a built-in viewer that lets you view the
# results of all render-to-texture operations. This lets you
# see what class CommonFilters is doing behind the scenes.
self.accept("v", base.bufferViewer.toggleEnable)
self.accept("V", base.bufferViewer.toggleEnable)
base.bufferViewer.setPosition("llcorner")
self.accept("s", self.filters.manager.resizeBuffers)
# These allow you to change cartooning parameters in realtime
self.accept("escape", sys.exit, [0])
def __init__(self, neweval, starList=[]):#, console=[]):
#messenger.toggleVerbose()
self.stars=starList
self.mouselook=True
self.zoom = .33
self.mapMode = False
self.evaluator = neweval
self.hudScale = 1
self.objectScale=.01
self.starScale = .1
self.skyScale=40000
self.dt=.02
self.starting=True
self.mouseX = 0
self.mouseY = 0
self.dX=0
self.dY=0
self.dZ=0
self.player = Body()
## self.mouseBody = Body()
## self.mouseBody.name = "mouse"
self.player.name = "player"
self.player.mass = 0
self.player.position.x=0
self.player.position.y=0
self.player.position.z=-0.04
self.player.orientation.y=90
self.accRate =2
# self.player.bodies=[]
# self.evaluator.system.bodies.append(self.player)
neweval.system.bodies.append(self.player)
self.evaluator= soPhysics.soPhysics(neweval.system)
self.evaluator.system.moveToStar()
self.filters = CommonFilters(base.win, base.cam)
self.filterok = self.filters.setBloom(blend=(1,1,1,1), desat=-0.5, intensity=1.0, size="small")
self.glowSize=1
#base.enableParticles()
#self.p = ParticleEffect()
#self.p.loadConfig("sun2.ptf")
self.loadPlanets()
#self.console = console
self.toggleConsole()
if len(starList)>0:
self.loadStars()
base.camLens.setNear(0.01)
base.camLens.setFar(100000)
# base.camLens.setFar(170000000000000000000000000000000000000)
self.mouselook=False
#render.setShaderAuto()
self.loadLights()
taskMgr.add(self.move,"move")
def compose_filters(self, win, cam, seperation=.6):
"""
function to handle the composing, which makes for the basic look and feel of the game
also handles any filters which are attached to the cam
:return:
"""
# set up the lightramp effect
tempnode = NodePath(PandaNode("temp node"))
tempnode.setAttrib(LightRampAttrib.makeSingleThreshold(
0.5, 0.4)) # warning can be ignored..
tempnode.setShaderAuto()
cam.node().setInitialState(tempnode.getState())
self.separation = seperation # Pixels
self.filters = CommonFilters(win, cam)
filterok = self.filters.setCartoonInk(separation=self.separation)
if (filterok == False):
return
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")
class World:
def __init__(self):
base.disableMouse()
# Turns off the default mouse-camera controls in Panda3D.
base.setBackgroundColor(0, 0, 0)
# Sets the background to black.
self.inputManager = InputManager()
# Creates an InputManager to handle all of the user input in the game.
taskMgr.doMethodLater(10, self.debugTask, "Debug Task")
# Tells the debugTask to run once every ten seconds. The debug task is a good
# place to put various data print outs about the game to help with debugging.
self.filters = CommonFilters(base.win, base.cam)
filterok = self.filters.setBloom(blend=(0, 0, 0, 1),
desat=-0.5,
intensity=3.0,
size=2)
render.setShaderAuto()
# Turns on Panda3D's automatic shader generation.
self.menuGraphics = loader.loadModel("../Models/MenuGraphics.egg")
self.fonts = {
"silver": loader.loadFont("../Fonts/LuconSilver.egg"),
"blue": loader.loadFont("../Fonts/LuconBlue.egg"),
"orange": loader.loadFont("../Fonts/LuconOrange.egg")
}
self.race = Race(self.inputManager)
self.race.createDemoRace()
self.createStartMenu()
def createStartMenu(self):
menu = Menu(self.menuGraphics, self.fonts, self.inputManager)
menu.initMenu([
0, None, ["New Game", "Quit Game"],
[[self.race.createRace, self.createReadyDialogue],
[base.userExit]], [[None, None], [None]]
])
def createReadyDialogue(self):
menu = Menu(self.menuGraphics, self.fonts, self.inputManager)
menu.initMenu([
3, "Are you ready?", ["Yes", "Exit"],
[[self.race.startRace], [self.race.createDemoRace]], [[3], [None]]
])
def debugTask(self, task):
print(taskMgr)
# prints all of the tasks in the task manager.
return task.again
class Filters():
def __init__(self):
self.filters = CommonFilters(base.win, base.cam)
self.glowShader = loader.loadShader("./shaders/glowShader.sha")
def enableFilters(self, player):
#self.filters.setBloom(mintrigger=.35)
self.filters.setBloom(blend=(1, 0, .2, 1), desat=-1, intensity=10, size="small")
#self.filters.setCartoonInk(separation=-5)
self.filters.setAmbientOcclusion(numsamples = 2, radius = 0.0025, amount = 2, strength = 0.001, falloff = 0.01)
player.setShader(self.glowShader)
player.setShaderInput("scale",4,4)
path = render.find("renderDummy")
path.setShader(self.glowShader)
path.setShaderInput("scale",1,1,1)
def __init__(self):
ShowBase.__init__(self)
self.filters = CommonFilters(self.win, self.cam)
self.render.setShaderAuto()
self.initP3D()
self.audio3d = Audio3DManager.Audio3DManager(self.sfxManagerList[0], self.cam)
self.audio3d.setDopplerFactor(.7)
self.splash = Splash(base, self,
sys.argv[1] if len(sys.argv) > 1 else False
)
def initShader(self):
tempnode = NodePath(PandaNode("temp node"))
tempnode.setAttrib(LightRampAttrib.makeSingleThreshold(0.5, 0.9))
tempnode.setShaderAuto()
base.cam.node().setInitialState(tempnode.getState())
self.separation = 1 # Pixels
self.filters = CommonFilters(base.win, base.cam)
filterok = self.filters.setBloom()
if (filterok == False):
addTitle("Toon Shader: Video card not powerful enough to do image postprocessing")
sys.exit
def init_lights(self):
"""init_lights
Set up light system
"""
self.filters = CommonFilters(base.win, base.cam)
filterok = self.filters.setBloom(blend=(0,0,0,.5), desat=-0.5,
intensity=1.0, size="small")
if filterok == False:
print "Your video card cannot handle this"
return
self.glowSize=.2
# Create a simple directional light
self.lights = {}
#Set up directional light
self.lights['dlight'] = render.attachNewNode (DirectionalLight\
('DirectionalLight'))
self.lights['dlight'].setColor(VBase4(1, 1, 1, 1))
render.setLight(self.lights['dlight'])
self.lights['dlight'].setPos(50,50,50)
self.lights['dlight'].lookAt(0,0,0)
#Sun position
self.lights['sunPos'] = 0
# Create an ambient light
self.lights['alight'] = AmbientLight('AmbientLight')
self.lights['alight'].setColor(VBase4(0.1, 0.1, 0.1, 0.1))
self.lights['alnp'] = render.attachNewNode(self.lights['alight'])
render.setLight(self.lights['alnp'])
#Create an invisible "sun" node which the dlight will lookAt()
self.lights['sun_node'] = render.attachNewNode("sun_node")
self.lights['sun_node'].setPos(10,10,10)
self.lights['sun_node'].setScale(2)
#Create a sun model that will be a visual representation of where the
# sun is. Will be, essentially, in the opposite position of the
# fake sun node
self.lights['sun_model'] = loader.loadModel(target_dir+'/models/sphere.egg')
self.lights['sun_model'].reparentTo(render)
self.lights['sun_model'].setPos(10,10,10)
self.lights['sun_model'].setScale(2)
self.lights['sky_box'] = loader.loadModel(target_dir+'/models/skybox.egg')
self.lights['sky_box'].reparentTo(render)
self.lights['sky_box'].setScale(5)
sky_tex = loader.loadTexture(\
target_dir+'/models/textures/clouds_bw.png')
sky_tex.setWrapU(Texture.WMRepeat)
sky_tex.setWrapV(Texture.WMRepeat)
self.lights['sky_box'].setTexture(sky_tex,1)
def __init__(self, app_object):
self.app = app_object
self.n = 0
cmnd = ""
self.commandBox = ""
self.store = ["","","",""]
ShowBase.__init__(self)
self.title1 = self.AddTitle(-0.65, "Type your commands here:")
self.title2 = self.AddTitle(0.90, "You have entered:")
self.instArea = self.AddInstructions(0.82, cmnd)
self.cmndArea = self.AddArea()
base.setFrameRateMeter(True)
base.setBackgroundColor(0,0,0)
self.cube = loader.loadModel("models/cube")
self.cube.setPos(0, 0, 0)
self.cube.reparentTo(self.render)
self.cube.setScale((cx), 3, 1)
# cam
self.cam.setPos(60, -80, 22)
light = PointLight('light')
self.render.setLight(self.cam.attachNewNode(light))
self.cam.lookAt(self.cube)
self.i = 1
self.sy = 1
self.sx = 1
self.sz = 1
self.addx =1
self.addy =1
self.addz =1
#self.negy = -7
#self.posy = 7
#CENTER
#setting up the bloom effect
filters = CommonFilters(base.win, base.cam)
filters.setBloom(blend=(0.0,0.0,0.0,1.0), mintrigger = 0.9, desat=-0.5, intensity=8.0, size="small")
rootDir = os.path.abspath(os.path.dirname(sys.argv[0]))
loadPrcFile(os.path.join(rootDir, "config.prc"))
class ShadowCreator:
def __init__(self):
self.shadowBuffer = base.win.makeTextureBuffer('Shadow Buffer', 2048, 2048)
self.shadowBuffer.setClearColorActive(True)
self.shadowBuffer.setClearColor((0, 0, 0, 1))
self.shadowCamera = base.makeCamera(self.shadowBuffer)
self.shadowCamera.reparentTo(render)
self.lens = base.camLens
self.lens.setAspectRatio(1 / 1)
self.shadowCamera.node().setLens(self.lens)
self.shadowCamera.node().setCameraMask(BitMask32.bit(1))
self.initial = NodePath('initial')
self.initial.setColor(0.75, 0.75, 0.75, 1, 1)
self.initial.setTextureOff(2)
self.initial.setMaterialOff(2)
self.initial.setLightOff(2)
self.shadowCamera.node().setInitialState(self.initial.getState())
self.shadowCamera.setPos(-10, 0, 20)
self.shadowCamera.lookAt(0, 0, 0)
self.filters = CommonFilters(self.shadowBuffer, self.shadowCamera)
self.filters.setBlurSharpen(0.1)
self.shadowTexture = self.shadowBuffer.getTexture()
self.imageObject = OnscreenImage(image=self.shadowTexture, pos=(-0.75, 0, 0.75), scale=0.2)
def register(self, render, camera, keys, render2d):
State.register(self, render, camera, keys, render2d)
self.node.attachNewNode(self.stage.maps[self.room].getNode())
for c in self.characters:
self.status[c].reparentTo(self.node2d)
for char in self.characters.values():
char.getNode().reparentTo(self.node)
char.stunRender = self.node
for l in self.stage.getLights():
render.setLight(l)
# COWABUNGA test!!!
self.hearts = {}
numChar=0
self.heartsNode = NodePath(PandaNode('hearts'))
self.heartsNode.reparentTo(self.node2d)
for char in self.characters:
self.hearts[char] = []
for i in range(Character.maxHearts):
self.hearts[char].append(Sprite("heart.png", 0.05, 0.05))
self.hearts[char][i].setPos(-0.8 + 1.4*numChar + (i%3)*0.055 , -0.9 - int(i/3)*0.055)
self.hearts[char][i].getNode().reparentTo(self.heartsNode)
numChar += 1
#COWABUNGA comment this to stop the madness
render.setAttrib(LightRampAttrib.makeSingleThreshold(0.1, 1))
# THE TRUE CARTOON SHADER :P
# self.separation = 1 # Pixels
self.filters = CommonFilters(base.win, self.camera.camera)
# cell shading
# filterok = self.filters.setCartoonInk(separation=self.separation)
# glow
filterok = self.filters.setBloom(blend=(0.5,0.5,0.5,1), desat=-0.5, intensity=0.5, size="small")
self.camera.setPos(0, -2.5, -2.5)
self.camera.lookAt(0, 0, 0)
def loadShaders(self):
# Check video card capabilities for shaders.
if (base.win.getGsg().getSupportsBasicShaders() == 0):
addTitle("Glow Filter: Video driver reports that shaders are not supported.")
return False
# Load filters
self.filters = CommonFilters(base.win, base.cam)
filterok = self.filters.setBloom(blend=(0,0,0,1), desat=-0.5, intensity=3.0, size="small")
if (filterok == False):
addTitle("Toon Shader: Video card not powerful enough to do image postprocessing")
return False
self.glowSize=1
# Shadow shaders
# TODO: Implement shadows
return True
def setupShaders(self):
"""
Creates shaders for cartoon outline and enables
shaders for shadows
"""
if self.base.win.getGsg().getSupportsBasicShaders() == 0:
return
thickness = 1.0
for camera in self.playerCameras:
self.filters = CommonFilters(self.base.win, camera)
filterEnabled = self.filters.setCartoonInk(separation=thickness)
if filterEnabled == False:
# Couldn't enable filter, video card probably
# doesn't support filter
return
self.worldRender.setShaderAuto()
def configurePanda(self):
"""configurePanda
parameters:
self
returns:
none
Description:
Set the rendering and display options for panda.
"""
props = WindowProperties()
props.setCursorHidden(True)
#props.setSize(1440, 900)
#props.setFullscreen(1)
base.win.requestProperties(props)
render.setShaderAuto()
base.disableMouse()
base.setFrameRateMeter(True)
#render.setAntialias(AntialiasAttrib.MAuto)
#render.setAntialias(AntialiasAttrib.MMultisample,4)
self.filters = CommonFilters(base.win, base.cam)
self.filters.setBloom(blend=(1,0,0,1), desat=-0.5, intensity=6.0, size=2)
class World:
def __init__(self):
base.disableMouse()
base.setBackgroundColor(0.52, 0.80, 0.99)
self.inputManager = InputManager()
self.filters = CommonFilters(base.win, base.cam)
filterok = self.filters.setBloom(blend=(0, 0, 0, 1), desat=-0.5, intensity=3.0, size=2)
render.setShaderAuto()
self.menuGraphics = loader.loadModel("Models/MenuGraphics.egg")
self.fonts = {
"silver": loader.loadFont("Fonts/LuconSilver.egg"),
"blue": loader.loadFont("Fonts/LuconBlue.egg"),
"orange": loader.loadFont("Fonts/LuconOrange.egg")
}
gui = Gui(self.fonts)
self.race = Race(self.inputManager, gui)
self.race.createDemoRace()
self.createStartMenu()
musicMgr = base.musicManager
self.music = musicMgr.getSound("Sound/music_1.wav")
self.music.setLoop(True)
self.music.setVolume(.5)
self.music.play()
def createStartMenu(self):
menu = Menu(self.menuGraphics, self.fonts, self.inputManager)
menu.initMenu([0, None, ["New Game", "Quit Game"], [[self.race.createRace, self.createReadyDialogue], [base.userExit]], [[None, None], [None]]])
def createReadyDialogue(self):
menu = Menu(self.menuGraphics, self.fonts, self.inputManager)
menu.initMenu([3, "Ready?", ["Yes", "Exit"], [[self.race.startRace], [self.race.createDemoRace]], [[3], [None]]])
def debugTask(self, task):
print(taskMgr)
return task.again
def __init__(self):
ShowBase.__init__(self)
self.createLoadScreen('./LEGameAssets/Textures/title_screen.png')
base.graphicsEngine.renderFrame()
#== Environment and Rendering Settings ==
base.setFrameRateMeter(FLAG_SHOW_FRAMES_PER_SECOND)
if FLAG_USE_AUTOSHADER:
render.setShaderAuto()
self.filters = CommonFilters(base.win, self.cam) # NEW
if FLAG_SHOW_GLOW:
bloomSize = 4#'small'
filterok = self.filters.setBloom(blend=(0,0,0,1), desat=-0.5, intensity=3.0, size=bloomSize)
if (filterok == False):
print 'WARNING:Video card not powerful enough to do image postprocessing'
#tex = loader.loadTexture("./LEGameAssets/Textures/loadbar_tray.png")
self.loadBar = DirectWaitBar(text = "", value = 0, scale =(.35,.5,.5), pos = (0.006,.83,.83))
#self.loadBar['barRelief'] = DirectWaitBar.GROOVE
#self.loadBar['scale'] = 0.05
#self.loadBar['barTexture'] = tex
self.loadBar['barColor'] = (6.0/255.0, 11.0/255, 28.0/255.0, 1)
self.loadBar.reparentTo(render2d)
self.loadBar.hide()
base.graphicsEngine.renderFrame()
self.setBackgroundColor(166.0/255.0,207.0/255.0,240.0/255.0,1)
self.skybox = self.loader.loadModel("LEGameAssets/Models/skybox_final.egg")
self.skybox.setScale(50)
self.skybox.reparentTo(render)
#== Load the level and the managers ==
self.assets, self.objects, self.gameObjects, self.sounds, self.sequences= loadWorld(SCENE_FILE, LIBRARY_INDEX)
self.loadBar['value'] += 5
base.graphicsEngine.renderFrame()
self.conversations = loadConversations(SCENE_FILE, LIBRARY_INDEX)
self.scenes = {}
self.loadScenes()
self.loadBar['value'] += 5
base.graphicsEngine.renderFrame()
self.journalMgr = JournalMgr(self)
self.loadJournal(self.journalMgr,JOURNAL_FILE)
self.conversationMgr = ConversationMgr(self, self.conversations)
self.scriptMgr = ScriptMgr(self)
self.scriptMgr.loadScripts(SCRIPTS_LIST)
self.scriptInterface = ScriptInterface(self)
self.inventoryMgr = InventoryMgr(self)
loadInventory(self.inventoryMgr,INVENTORY_FILE)
self.loadBar['value'] += 5
base.graphicsEngine.renderFrame()
self.ranSequences = []
#== Main Character ==
self.hero = None
for name, gameObj in self.gameObjects.iteritems():
if gameObj.getNP().hasTag('LE-mainChar'):
self.hero = gameObj
break
else:
# make a default hero
defaultHeroNP = loader.loadModel("panda")
self.hero = GameObject(defaultHeroNP)
self.hero.reparentTo(render)
self.hero.setPos(0, 0, 0)
self.hero.setTag('LE-mainChar', '180')
self.gameObjects[self.hero.getName()] = self.hero
self.setCollideMasks(self.gameObjects)
# remove the hero from the objects dict so it cannot be clicked by player
if self.hero.getName() in self.objects:
del self.objects[self.hero.getName()]
#== Camera ==
camHeightFactor = CAMERA_HEIGHT
camTrailFactor = -CAMERA_TRAIL # careful of +/- distinction
self.heroHeight = self.getModelHeight(self.hero)
self.heroHeadingOffset = float(self.hero.getTag('LE-mainChar'))
self.lastHeroH = self.hero.getH(render) + self.heroHeadingOffset
# setup the camera pivot, which will follow the main character model and anchor the camera
self.camPivot = NodePath('camPivot')
self.camPivot.reparentTo(render)
self.camHeight = camHeightFactor*self.heroHeight
self.camTrail = camTrailFactor*self.heroHeight
self.cam.setPos(self.camPivot.getPos() + (0, self.camTrail, self.camHeight))
self.cam.wrtReparentTo(self.camPivot)
self.placeCamera(self.hero) # match X and Y to main character
self.alignCamera(self.hero) # match heading to main character
#self.camPivot.setH(render, self.hero.getH(render) + self.heroHeadingOffset)
self.gameCam = self.cam
#== Collisions ==
self.setupCollisions()
#== Controls ==
self.disableMouse()
self.keyMap = { 'w':False, 'a':False, 's':False, 'd':False }
self.enableMovement(self.hero)
self.accept("mouse1", self.onClickin3D)
self.accept('escape', sys.exit)
self.accept('z', render.place)
#== UI and Combat ==
self.gameplayUI = GameplayUI(self)
self.gameplayUI.hideAll()
# for health bars and on screen UI
self.overlayAmbientLight = AmbientLight('overlayAmbientLight')
self.overlayAmbientLight.setColor(VBase4(1.0, 1.0, 1.0, 1.0))
self.overlayAmbientLightNP = render.attachNewNode(self.overlayAmbientLight)
# initialize the combat manager (which includes AI) now that a main character and gameplayUI instance and overlay light is established
self.combatMgr = CombatMgr(self)
# initialize player's spells
self.heroSpells = []
for properties in PLAYER_SPELLS:
spell = Spell(self.hero, properties)
self.heroSpells.append(spell)
#== Start Tasks
taskMgr.add(self.moveHeroTask, 'moveHeroTask', appendTask=True)
taskMgr.add(self.cameraFollowTask, 'cameraFollowTask', appendTask=True)
taskMgr.add(self.processHeroCollisions, 'processHeroCollisions')
taskMgr.add(self.updateHeroHeight, 'updateHeroHeight')
self.combatMgr.startTasks()
self.accept('enter', self.destroyLoadScreen)
self.destroyLoadScreen()
def __init__(self):
# Initialize the ShowBase class from which we inherit, which will
# create a window and set up everything we need for rendering into it.
ShowBase.__init__(self)
self.disableMouse()
self.cam.node().getLens().setNear(10.0)
self.cam.node().getLens().setFar(200.0)
camera.setPos(0, -50, 0)
# Check video card capabilities.
if not self.win.getGsg().getSupportsBasicShaders():
addTitle("Toon Shader: Video driver reports that Cg shaders are not supported.")
return
# Enable a 'light ramp' - this discretizes the lighting,
# which is half of what makes a model look like a cartoon.
# Light ramps only work if shader generation is enabled,
# so we call 'setShaderAuto'.
tempnode = NodePath(PandaNode("temp node"))
tempnode.setAttrib(LightRampAttrib.makeSingleThreshold(0.5, 0.4))
tempnode.setShaderAuto()
self.cam.node().setInitialState(tempnode.getState())
# Use class 'CommonFilters' to enable a cartoon inking filter.
# This can fail if the video card is not powerful enough, if so,
# display an error and exit.
self.separation = 1 # Pixels
self.filters = CommonFilters(self.win, self.cam)
filterok = self.filters.setCartoonInk(separation=self.separation)
if (filterok == False):
addTitle(
"Toon Shader: Video card not powerful enough to do image postprocessing")
return
# Show instructions in the corner of the window.
self.title = addTitle(
"Panda3D: Tutorial - Toon Shading with Normals-Based Inking")
self.inst1 = addInstructions(0.06, "ESC: Quit")
self.inst2 = addInstructions(0.12, "Up/Down: Increase/Decrease Line Thickness")
self.inst3 = addInstructions(0.18, "V: View the render-to-texture results")
# Load a dragon model and animate it.
self.character = Actor()
self.character.loadModel('models/nik-dragon')
self.character.reparentTo(render)
self.character.loadAnims({'win': 'models/nik-dragon'})
self.character.loop('win')
self.character.hprInterval(15, (360, 0, 0)).loop()
# Create a non-attenuating point light and an ambient light.
plightnode = PointLight("point light")
plightnode.setAttenuation((1, 0, 0))
plight = render.attachNewNode(plightnode)
plight.setPos(30, -50, 0)
alightnode = AmbientLight("ambient light")
alightnode.setColor((0.8, 0.8, 0.8, 1))
alight = render.attachNewNode(alightnode)
render.setLight(alight)
render.setLight(plight)
# Panda contains a built-in viewer that lets you view the
# results of all render-to-texture operations. This lets you
# see what class CommonFilters is doing behind the scenes.
self.accept("v", self.bufferViewer.toggleEnable)
self.accept("V", self.bufferViewer.toggleEnable)
self.bufferViewer.setPosition("llcorner")
self.accept("s", self.filters.manager.resizeBuffers)
# These allow you to change cartooning parameters in realtime
self.accept("escape", sys.exit, [0])
self.accept("arrow_up", self.increaseSeparation)
self.accept("arrow_down", self.decreaseSeparation)
class World(ShowBase): # CONDISER: change to DirectObject/FSM
def __init__(self):
ShowBase.__init__(self)
self.createLoadScreen('./LEGameAssets/Textures/title_screen.png')
base.graphicsEngine.renderFrame()
#== Environment and Rendering Settings ==
base.setFrameRateMeter(FLAG_SHOW_FRAMES_PER_SECOND)
if FLAG_USE_AUTOSHADER:
render.setShaderAuto()
self.filters = CommonFilters(base.win, self.cam) # NEW
if FLAG_SHOW_GLOW:
bloomSize = 4#'small'
filterok = self.filters.setBloom(blend=(0,0,0,1), desat=-0.5, intensity=3.0, size=bloomSize)
if (filterok == False):
print 'WARNING:Video card not powerful enough to do image postprocessing'
#tex = loader.loadTexture("./LEGameAssets/Textures/loadbar_tray.png")
self.loadBar = DirectWaitBar(text = "", value = 0, scale =(.35,.5,.5), pos = (0.006,.83,.83))
#self.loadBar['barRelief'] = DirectWaitBar.GROOVE
#self.loadBar['scale'] = 0.05
#self.loadBar['barTexture'] = tex
self.loadBar['barColor'] = (6.0/255.0, 11.0/255, 28.0/255.0, 1)
self.loadBar.reparentTo(render2d)
self.loadBar.hide()
base.graphicsEngine.renderFrame()
self.setBackgroundColor(166.0/255.0,207.0/255.0,240.0/255.0,1)
self.skybox = self.loader.loadModel("LEGameAssets/Models/skybox_final.egg")
self.skybox.setScale(50)
self.skybox.reparentTo(render)
#== Load the level and the managers ==
self.assets, self.objects, self.gameObjects, self.sounds, self.sequences= loadWorld(SCENE_FILE, LIBRARY_INDEX)
self.loadBar['value'] += 5
base.graphicsEngine.renderFrame()
self.conversations = loadConversations(SCENE_FILE, LIBRARY_INDEX)
self.scenes = {}
self.loadScenes()
self.loadBar['value'] += 5
base.graphicsEngine.renderFrame()
self.journalMgr = JournalMgr(self)
self.loadJournal(self.journalMgr,JOURNAL_FILE)
self.conversationMgr = ConversationMgr(self, self.conversations)
self.scriptMgr = ScriptMgr(self)
self.scriptMgr.loadScripts(SCRIPTS_LIST)
self.scriptInterface = ScriptInterface(self)
self.inventoryMgr = InventoryMgr(self)
loadInventory(self.inventoryMgr,INVENTORY_FILE)
self.loadBar['value'] += 5
base.graphicsEngine.renderFrame()
self.ranSequences = []
#== Main Character ==
self.hero = None
for name, gameObj in self.gameObjects.iteritems():
if gameObj.getNP().hasTag('LE-mainChar'):
self.hero = gameObj
break
else:
# make a default hero
defaultHeroNP = loader.loadModel("panda")
self.hero = GameObject(defaultHeroNP)
self.hero.reparentTo(render)
self.hero.setPos(0, 0, 0)
self.hero.setTag('LE-mainChar', '180')
self.gameObjects[self.hero.getName()] = self.hero
self.setCollideMasks(self.gameObjects)
# remove the hero from the objects dict so it cannot be clicked by player
if self.hero.getName() in self.objects:
del self.objects[self.hero.getName()]
#== Camera ==
camHeightFactor = CAMERA_HEIGHT
camTrailFactor = -CAMERA_TRAIL # careful of +/- distinction
self.heroHeight = self.getModelHeight(self.hero)
self.heroHeadingOffset = float(self.hero.getTag('LE-mainChar'))
self.lastHeroH = self.hero.getH(render) + self.heroHeadingOffset
# setup the camera pivot, which will follow the main character model and anchor the camera
self.camPivot = NodePath('camPivot')
self.camPivot.reparentTo(render)
self.camHeight = camHeightFactor*self.heroHeight
self.camTrail = camTrailFactor*self.heroHeight
self.cam.setPos(self.camPivot.getPos() + (0, self.camTrail, self.camHeight))
self.cam.wrtReparentTo(self.camPivot)
self.placeCamera(self.hero) # match X and Y to main character
self.alignCamera(self.hero) # match heading to main character
#self.camPivot.setH(render, self.hero.getH(render) + self.heroHeadingOffset)
self.gameCam = self.cam
#== Collisions ==
self.setupCollisions()
#== Controls ==
self.disableMouse()
self.keyMap = { 'w':False, 'a':False, 's':False, 'd':False }
self.enableMovement(self.hero)
self.accept("mouse1", self.onClickin3D)
self.accept('escape', sys.exit)
self.accept('z', render.place)
#== UI and Combat ==
self.gameplayUI = GameplayUI(self)
self.gameplayUI.hideAll()
# for health bars and on screen UI
self.overlayAmbientLight = AmbientLight('overlayAmbientLight')
self.overlayAmbientLight.setColor(VBase4(1.0, 1.0, 1.0, 1.0))
self.overlayAmbientLightNP = render.attachNewNode(self.overlayAmbientLight)
# initialize the combat manager (which includes AI) now that a main character and gameplayUI instance and overlay light is established
self.combatMgr = CombatMgr(self)
# initialize player's spells
self.heroSpells = []
for properties in PLAYER_SPELLS:
spell = Spell(self.hero, properties)
self.heroSpells.append(spell)
#== Start Tasks
taskMgr.add(self.moveHeroTask, 'moveHeroTask', appendTask=True)
taskMgr.add(self.cameraFollowTask, 'cameraFollowTask', appendTask=True)
taskMgr.add(self.processHeroCollisions, 'processHeroCollisions')
taskMgr.add(self.updateHeroHeight, 'updateHeroHeight')
self.combatMgr.startTasks()
self.accept('enter', self.destroyLoadScreen)
self.destroyLoadScreen()
##== Utility and World Initialization functions =============================##
def loadJournal(self,journalMgr,journalFile):
f = open(Filename(journalFile).toOsSpecific())
doc = xml.dom.minidom.parse(f)
root = doc.childNodes[0]
for n in root.childNodes:
if n.localName == "journalEntries":
journalMgr.decode(n)
f.close()
def getModelHeight(self, model):
min, max = Point3(), Point3()
model.calcTightBounds(min, max)
return max.getZ() - min.getZ()
def createLoadScreen(self, imageFile='./LEGameAssets/Textures/load_screen.png'):
self.loadScreen = OnscreenImage(image=imageFile)
aspect2d.hide()
self.loadScreen.reparentTo(render2d)
if(hasattr(self, "gameplayUI")):
self.gameplayUI.hideAll()
def destroyLoadScreen(self):
self.loadBar.hide()
self.loadScreen.detachNode()
self.loadScreen.destroy()
aspect2d.show()
self.ignore('enter')
self.gameplayUI.showAll()
for name, gameObj in self.gameObjects.iteritems():
gameObj.callTrigger(self, 'LE-trigger-onScene')
def startLoadBar(self, range=100):
self.loadBar.show()
self.loadBar['range'] = range
self.loadBar['value'] = 0
base.graphicsEngine.renderFrame()
def increaseLoadBar(self, value):
self.loadBar['value'] += value
base.graphicsEngine.renderFrame()
##== Collisions =============================================================##
def setupCollisions(self):
self.cTrav = CollisionTraverser('mainTraverser')
self.cTrav.setRespectPrevTransform(True)
# Line collider for setting hero height based on ground geometry
heroLine = CollisionNode('heroLine')
heroLine.addSolid(CollisionRay(Point3(0,0,self.heroHeight), Vec3(0,0,-1)))
heroLine.setFromCollideMask(BITMASK_GROUND)
heroLine.setIntoCollideMask(BitMask32.allOff())
self.heroGroundCollide = render.attachNewNode(heroLine)
self.heroGroundHandler = CollisionHandlerQueue()
self.cTrav.addCollider(self.heroGroundCollide, self.heroGroundHandler)
# cameraSphere = CollisionNode('cameraSphere')
# cameraSphere.addSolid(CollisionSphere(0,0,0,10))
# cameraSphere.setFromCollideMask(BITMASK_CAMERA)
# cameraSphere.setIntoCollideMask(BitMask32.allOff())
# self.cameraSphereCollide = self.cam.attachNewNode(cameraSphere)
# self.cameraSphereQueue = CollisionHandlerQueue()
# self.cTrav.addCollider(self.cameraSphereCollide, self.cameraSphereQueue)
self.herowallcollision = False
self.heroWallCollideX = render.attachNewNode("heroWallX")
self.heroWallCollideY = render.attachNewNode("heroWallY")
self.heroWallCollideZ = render.attachNewNode("heroWallZ")
# Line collider for running into obstacles and walls in X direction
heroLineX = CollisionNode('heroLineX')
heroLineX.addSolid(CollisionRay(Point3(0,0,0), Vec3(0,0,1)))
self.heroWallCollideLineX = self.heroWallCollideX.attachNewNode(heroLineX)
self.heroWallCollideLineX.node().setFromCollideMask(BITMASK_WALL_TERRAIN)
self.heroWallCollideLineX.node().setIntoCollideMask(BitMask32.allOff())
self.heroWallQueueX = CollisionHandlerQueue()
self.cTrav.addCollider(self.heroWallCollideLineX, self.heroWallQueueX)
# Line collider for running into obstacles and walls in Y direction
heroLineY = CollisionNode('heroLineY')
heroLineY.addSolid(CollisionRay(Point3(0,0,0), Vec3(0,0,1)))
self.heroWallCollideLineY = self.heroWallCollideY.attachNewNode(heroLineY)
self.heroWallCollideLineY.node().setFromCollideMask(BITMASK_WALL_TERRAIN)
self.heroWallCollideLineY.node().setIntoCollideMask(BitMask32.allOff())
self.heroWallQueueY = CollisionHandlerQueue()
self.cTrav.addCollider(self.heroWallCollideLineY, self.heroWallQueueY)
# Line collider for running into obstacles and walls in Z direction
heroLineZ = CollisionNode('heroLineZ')
heroLineZ.addSolid(CollisionRay(Point3(0,0,0), Vec3(0,0,1)))
self.heroWallCollideLineZ = self.heroWallCollideZ.attachNewNode(heroLineZ)
self.heroWallCollideLineZ.node().setFromCollideMask(BITMASK_WALL_TERRAIN)
self.heroWallCollideLineZ.node().setIntoCollideMask(BitMask32.allOff())
self.heroWallQueueZ = CollisionHandlerQueue()
self.cTrav.addCollider(self.heroWallCollideLineZ, self.heroWallQueueZ)
# # Sphere collider for running into obstacles and walls
# heroSphere = CollisionNode('heroSphere')
# heroSphere.addSolid(CollisionSphere(0,0,0,7))
# self.heroWallCollide = render.attachNewNode(heroSphere)
# self.heroWallCollide.node().setFromCollideMask(BITMASK_WALL)
# self.heroWallCollide.node().setIntoCollideMask(BitMask32.allOff())
# self.heroWallQueue = CollisionHandlerQueue()
# self.cTrav.addCollider(self.heroWallCollide, self.heroWallQueue)
# self.herowallcollision = False
# Sphere collider for running into obstacles and walls in X direction
heroSphereX = CollisionNode('heroSphereX')
heroSphereX.addSolid(CollisionSphere(0,0,0,7))
self.heroWallCollideSphereX = self.heroWallCollideX.attachNewNode(heroSphereX)
self.heroWallCollideSphereX.node().setFromCollideMask(BITMASK_WALL)
self.heroWallCollideSphereX.node().setIntoCollideMask(BitMask32.allOff())
#self.heroWallQueueX = CollisionHandlerQueue()
self.cTrav.addCollider(self.heroWallCollideSphereX, self.heroWallQueueX)
self.herowallcollision = False
# Sphere collider for running into obstacles and walls in Y direction
heroSphereY = CollisionNode('heroSphereY')
heroSphereY.addSolid(CollisionSphere(0,0,0,7))
self.heroWallCollideSphereY = self.heroWallCollideY.attachNewNode(heroSphereY)
self.heroWallCollideSphereY.node().setFromCollideMask(BITMASK_WALL)
self.heroWallCollideSphereY.node().setIntoCollideMask(BitMask32.allOff())
#self.heroWallQueueY = CollisionHandlerQueue()
self.cTrav.addCollider(self.heroWallCollideSphereY, self.heroWallQueueY)
# Sphere collider for running into obstacles and walls in Z direction
heroSphereZ = CollisionNode('heroSphereZ')
heroSphereZ.addSolid(CollisionSphere(0,0,0,7))
self.heroWallCollideSphereZ = self.heroWallCollideZ.attachNewNode(heroSphereZ)
self.heroWallCollideSphereZ.node().setFromCollideMask(BITMASK_WALL)
self.heroWallCollideSphereZ.node().setIntoCollideMask(BitMask32.allOff())
#self.heroWallQueueZ = CollisionHandlerQueue()
self.cTrav.addCollider(self.heroWallCollideSphereZ, self.heroWallQueueZ)
# Ray collider for clicking on objects in the game
self.pickerCollisionQueue = CollisionHandlerQueue()
self.pickerCN = CollisionNode('pickerRayCN')
self.pickerCNP = self.cam.attachNewNode(self.pickerCN)
self.pickerCN.setFromCollideMask(BITMASK_CLICK)
self.pickerCN.setIntoCollideMask(BitMask32.allOff())
self.pickerRay = CollisionRay()
self.pickerCN.addSolid(self.pickerRay)
self.cTrav.addCollider(self.pickerCNP, self.pickerCollisionQueue)
# Sphere collider for triggering scripts
self.heroCN = CollisionNode('heroCN')
self.heroCN.addSolid(CollisionSphere(0, 0, 0, 5)) # TODO: find good radius
self.heroCNP = self.hero.attachNewNode(self.heroCN)
self.heroCN.setFromCollideMask(BITMASK_HERO_COLLIDE)
self.heroCN.setIntoCollideMask(BitMask32.allOff())
self.heroCollisionQueue = CollisionHandlerQueue()
self.cTrav.addCollider(self.heroCNP, self.heroCollisionQueue)
# Line collider for transparency
self.cameraEntriesPre = []
radius = self.getModelHeight(self.hero)*CAMERA_TRAIL/2
self.cameraCollisionQueue = CollisionHandlerQueue()
self.cameraHero = CollisionNode('cameraHero')
self.cameraHeroLine = CollisionSegment(self.hero.getPos(render), self.cam.getPos(render))
self.cameraHero.addSolid(self.cameraHeroLine)
self.cameraHero.setFromCollideMask(BITMASK_CAMERA)
self.cameraHero.setIntoCollideMask(BitMask32.allOff())
self.cameraHeroP = self.render.attachNewNode(self.cameraHero)
self.cTrav.addCollider(self.cameraHeroP, self.cameraCollisionQueue)
#self.cameraHeroP.show()
if FLAG_SHOW_COLLISIONS:
self.cTrav.showCollisions(render)
# TODO: show specific collision nodepaths
def setCollideMasks(self, gameObjDict):
for name, obj in gameObjDict.iteritems():
bitmask = obj.getCollideMask()
if obj.hasTag('LE-ground'):
bitmask |= BITMASK_GROUND
#obj.getNP().setCollideMask(bitmask) # TODO: remove
if obj.hasTag('LE-attackable'):
bitmask |= BITMASK_CLICK
if obj.hasTag('LE-wall'):
if(isinstance(obj.getNP(), GeoMipTerrain)):
bitmask |= BITMASK_TERRAIN
else:
bitmask |= BITMASK_WALL
if obj.scripts.has_key('LE-trigger-onClick'):
bitmask |=BITMASK_CLICK
if obj.scripts.has_key('LE-trigger-onCollision'):
bitmask |=BITMASK_HERO_COLLIDE
if obj.hasTag('OBJRoot'):
if obj.hasTag('LE-ground') or obj.hasTag('LE-mainChar'):
pass
else:
bitmask |= BITMASK_CAMERA
obj.setCollideMask(bitmask)
def onClickin3D(self):
pickedObj = None
if self.conversationMgr.isConversationOpen():
return
if base.mouseWatcherNode.hasMouse():
mpos = base.mouseWatcherNode.getMouse()
else:
return
self.cTrav.addCollider(self.pickerCNP, self.pickerCollisionQueue)
self.pickerRay.setFromLens(self.cam.node(), mpos.getX(), mpos.getY())
self.cTrav.traverse(render)
if(self.pickerCollisionQueue.getNumEntries() > 0):
self.pickerCollisionQueue.sortEntries()
for i in range(self.pickerCollisionQueue.getNumEntries()):
parent = self.pickerCollisionQueue.getEntry(i).getIntoNodePath().getParent()
while not self.objects.has_key(parent.getName()):
if(parent.getName() == "render"):
return
parent = parent.getParent()
pickedObj = parent
if(pickedObj == None):
continue
else:
break
#if pickedObj.hasTag("LE-trigger-onClick"): # TODO: needed, or is having key in self.objects enough?
if (pickedObj == None):
return
self.pickerCollisionQueue.clearEntries()
self.cTrav.removeCollider(self.pickerCNP)
gameObj = self.gameObjects[pickedObj.getName()]
distToTarget = self.hero.getDistance(gameObj)
if self.combatMgr.checkCanAttack(self.hero, gameObj):
if distToTarget <= self.heroSpells[self.curSpellIndex].getAttackRange():
self.combatMgr.queueAttack(self.hero, self.heroSpells[self.curSpellIndex], gameObj)
else:
textObject = OnscreenText(text = 'The target is out of range!',fg =(1,0,0,1), pos = (0, 0), scale = 0.09, align = TextNode.ACenter )
def destroyWarning1():
textObject.destroy()
sequence =Sequence(Wait(2), Func(destroyWarning1))
sequence.start()
return
elif(distToTarget > CLICK_RANGE):
textObject = OnscreenText(text = 'The target is out of range!',fg =(1,0,0,1), pos = (0, 0), scale = 0.09, align = TextNode.ACenter )
def destroyWarning2():
textObject.destroy()
sequence =Sequence(Wait(2), Func(destroyWarning2))
sequence.start()
return
gameObj.callTrigger(self, 'LE-trigger-onClick')
# Task for processing hero's collisions with GameObjects, triggering OnCollision scripts
def processHeroCollisions(self, task):
#self.cTrav.traverse(render)
debug("processHeroCollisions")
# CONSIDER: may not be necessary to sort
if(self.heroCollisionQueue.getNumEntries() > 0):
self.heroCollisionQueue.sortEntries()
debug("queue size: "+str(self.heroCollisionQueue.getNumEntries()))
for i in range(self.heroCollisionQueue.getNumEntries()):
# CONSIDER: if entry.hasInto(): for efficiency
debug("i: "+str(i))
# TODO: check if GameObject is passable, and react accordingly (store old position, revert to it)
if(self.heroCollisionQueue.getNumEntries() <= 0):
return
entry = self.heroCollisionQueue.getEntry(i)
debug("entry: "+str(entry))
if(entry):
intoNP = entry.getIntoNodePath()
else:
continue
if (intoNP != None) or (not intoNP.isEmpty()):
while not self.objects.has_key(intoNP.getName()):
if(intoNP.getName() == "render"):
return task.cont
intoNP = intoNP.getParent()
pickedObj = intoNP
if pickedObj == None:
continue
gameObj = self.gameObjects[pickedObj.getName()]
gameObj.callTrigger(self, 'LE-trigger-onCollision')
return task.cont
##== Camera Movement ========================================================##
# places the camera pivot to match the position of the node path parameter
# used to have the camera pivot match the main character's position as he moves
def placeCamera(self, np):
self.camPivot.setX(render, np.getX(render))
self.camPivot.setY(render, np.getY(render))
def alignCamera(self, np):
self.camPivot.setH(render, self.hero.getH(render) + self.heroHeadingOffset)
self.cam.setP(CAMERA_PITCH)
def cameraFollowTask(self, task):
heroH = self.hero.getH(render) + self.heroHeadingOffset
camPivotH = self.camPivot.getH(render)
# normalizes the headings to avoid jumps in the difference
# which could come from passing 360 and going back to 0, for example
# TODO: stress test, esp. with different values of self.heroHeadingOffset
while heroH + 180 < camPivotH:
heroH += 360
while camPivotH + 180 < heroH:
camPivotH += 360
self.lastHeroH = heroH
rotateLeft = (heroH >= camPivotH)
rotateRight = not rotateLeft
diff = math.fabs(heroH - camPivotH)
if diff > CAMERA_TURN_THRESHOLD:
if rotateLeft:
self.camPivot.setH(self.camPivot.getH() + CAMERA_TURN_SPEED)
elif rotateRight:
self.camPivot.setH(self.camPivot.getH() - CAMERA_TURN_SPEED)
# if(len(self.cameraEntriesPre)>0):
# #print self.cameraEntriesPre
# if(self.hero.getDistance(self.cam) > 5):
# moveAmount = min(globalClock.getDt()*200,5.0)
# pos = self.cam.getQuat().getForward()*moveAmount
# newpos = self.cam.getPos() + pos
# self.oldCameraEntriesPre = []
# for e in self.cameraEntriesPre:
# self.oldCameraEntriesPre.append(e)
# self.cam.setFluidPos(newpos)
#
# else:
# if(self.hero.getDistance(self.cam) < 100):
# moveAmount = min(globalClock.getDt()*200,5.0)
# pos = self.cam.getQuat().getForward()*(-moveAmount)
# oldpos = self.cam.getPos()
# newpos = self.cam.getPos() + pos
# self.cam.setFluidPos(newpos)
# for e in self.oldCameraEntriesPre:
# #print e.getIntoNodePath()
# self.cTrav.traverse(e.getIntoNodePath())
# #self.cTrav.traverse(render)
# if(len(self.cameraSphereQueue.getEntries())>0):
# self.cam.setFluidPos(oldpos)
return task.cont
def runCamera(self, cameraName, sequence, isLoop = False):
debug("Running the camera")
#debug(str(self.sequences))
self.oldCamera = self.cam
self.dr = self.win.makeDisplayRegion()
dr2 = self.cam.node().getDisplayRegion(0)#
self.objects[cameraName].node().setLens(base.camLens)
parent = self.cam.getParent()
self.cam.detachNode()
self.dr.setCamera(self.objects[cameraName])
def temp():
dr2.setCamera(self.oldCamera)
self.oldCamera.reparentTo(parent)
self.dr.setActive(False)
del self.dr
self.dr = None
self.accept("mouse1", self.onClickin3D)
debug("Ran")
if(isLoop):
newSequence = Sequence(sequence)
self.addSequence(newSequence)
def stopCameraFromLoop():
newSequence.finish()
temp()
self.accept("mouse1", stopCameraFromLoop)
self.addSequence(newSequence)
newSequence.loop()
else:
newSequence = Sequence(sequence,Func(temp))
def stopCamera():
newSequence.finish()
self.accept("mouse1", stopCamera)
self.addSequence(newSequence)
newSequence.start()
##== Character Movement =====================================================##
def moveHeroTo(self, destinationObj):
pos = destinationObj.getPos(render)
hpr = destinationObj.getHpr(render)
self.hero.setPosHpr(render, pos, hpr)
self.placeCamera(self.hero)
self.alignCamera(self.hero)
def updateHeroHeight(self, task=None):
groundEntries = []
#move the collision line to the hero position
self.heroGroundCollide.setPos(self.hero.getPos(render))
#loop through every collision entry for the line
for e in self.heroGroundHandler.getEntries():
if e.getIntoNodePath().hasNetTag('OBJRoot'):
#find the actual root of the object
np = e.getIntoNodePath().findNetTag('OBJRoot')
#only react to objects that are tagged as the ground
if np.hasTag('LE-ground'):
groundEntries.append(e)
if groundEntries:
#sort the collision entries based on height
groundEntries.sort(lambda x,y: cmp(y.getSurfacePoint(render).getZ(),\
x.getSurfacePoint(render).getZ()))
#set hero height and pivot height
self.hero.setZ(groundEntries[0].getSurfacePoint(render).getZ() + MAIN_CHAR_GROUND_OFFSET)
self.camPivot.setZ(groundEntries[0].getSurfacePoint(render).getZ() + MAIN_CHAR_GROUND_OFFSET)
# TODO: unlink these from being in the same task in case we want pivot to not be linked to hero (ex. cutscene)
self.heroGroundHandler.clearEntries()
return task.cont
def updateHeroPos(self, queue, stepSize):
wallEntries = []
for w in queue.getEntries():
np = w.getIntoNodePath().findNetTag('OBJRoot')
if np.hasTag('LE-wall'):
if self.isInObstacleRange(self.hero, w, stepSize):
wallEntries.append(w)
if len(wallEntries) > 0:
self.herowallcollision = True
#self.collisionsurfaceP = wallEntries[0].getSurfacePoint(render)
else:
self.herowallcollision = False
def updateCameraCollision(self):
self.cameraHeroLine.setPointA(self.cam.getPos(render))
self.cameraHeroLine.setPointB(self.hero.getPos(render))
if(self.cameraEntriesPre):
for i in self.cameraEntriesPre:
i.getIntoNodePath().setTransparency(TransparencyAttrib.MAlpha)
i.getIntoNodePath().setAlphaScale(1.0)
del self.cameraEntriesPre[:]
for i in self.cameraCollisionQueue.getEntries():
i.getIntoNodePath().setAlphaScale(0.5)
self.cameraEntriesPre.append(i)
def moveHero(self,direction, dt):
temp = render.attachNewNode("Dummy")#NodePath()
moveStep = MAIN_CHAR_MOVE_SPEED*dt
if moveStep > MAIN_CHAR_MAX_STEP:
moveStep = MAIN_CHAR_MAX_STEP
temp.setPos(self.camPivot, 0,direction*moveStep, 0)
#oldPos = self.heroWallCollideX.getPos()
self.heroWallCollideX.setX(temp.getX())
self.heroWallCollideY.setY(temp.getY())
self.heroWallCollideZ.setZ(temp.getZ())#+10)
self.cTrav.traverse(render)
#check on X direction
self.updateHeroPos(self.heroWallQueueX, moveStep)
self.moveHeroToWallCollide(Point3(temp.getX(),self.hero.getY(),self.hero.getZ()))
#check on Y direction
self.updateHeroPos(self.heroWallQueueY, moveStep)
self.moveHeroToWallCollide(Point3(self.hero.getX(),temp.getY(),self.hero.getZ()))
#check on Z direction
self.updateHeroPos(self.heroWallQueueZ, moveStep)
self.moveHeroToWallCollide(Point3(self.hero.getX(),self.hero.getY(),temp.getZ()))
self.heroWallCollideX.setPos(self.hero.getPos())
self.heroWallCollideY.setPos(self.hero.getPos())
self.heroWallCollideZ.setPos(self.hero.getPos())
self.placeCamera(self.hero)
self.updateCameraCollision()
temp.detachNode()
def moveHeroToWallCollide(self,pos):
if self.herowallcollision==False:
self.hero.setPos(pos)#self.camPivot, 0, MAIN_CHAR_MOVE_SPEED, 0)
def isInObstacleRange(self, mover, colEntry, stepSize):
colPoint = colEntry.getSurfacePoint(render)
if colPoint[2] >= mover.getZ(render):
dist = findDistance3D(mover.getX(), mover.getY(), mover.getZ(), colPoint[0], colPoint[1], colPoint[2])
obstacleThreshold = self.heroHeight*self.heroHeight + stepSize*stepSize
if dist*dist <= obstacleThreshold:
return True
return False
def turnHeroLeft(self):
up = render.getRelativeVector(base.cam, Vec3(0, 0, 1))
up.normalize()
curHeroQuat = self.hero.getQuat()
newHeroQuat = Quat()
newHeroQuat.setFromAxisAngle(MAIN_CHAR_ROTATE_SPEED, up)
self.hero.setQuat(curHeroQuat*newHeroQuat)
self.hero.setR(0)
self.hero.setP(0)
self.updateCameraCollision()
def turnHeroRight(self):
up = render.getRelativeVector(base.cam, Vec3(0, 0, 1))
up.normalize()
curHeroQuat = self.hero.getQuat()
newHeroQuat = Quat()
newHeroQuat.setFromAxisAngle(-MAIN_CHAR_ROTATE_SPEED, up)
self.hero.setQuat(curHeroQuat*newHeroQuat)
self.hero.setR(0)
self.hero.setP(0)
self.updateCameraCollision()
def disableMovement(self, gameObj):
if gameObj.getName() == self.hero.getName():
self.ignore('w')
self.ignore('w-up')
self.ignore('a')
self.ignore('a-up')
self.ignore('s')
self.ignore('s-up')
self.ignore('d')
self.ignore('d-up')
else:
if gameObj.getAIBehaviorsHandle().behaviorStatus('pursue') != -1:
gameObj.getAIBehaviorsHandle().pauseAi('pursue')
def enableMovement(self, gameObj):
if gameObj.getName() == self.hero.getName():
self.accept('w', self.setKeyStatus, extraArgs=['w', True])
self.accept('w-up', self.setKeyStatus, extraArgs=['w', False])
self.accept('a', self.setKeyStatus, extraArgs=['a', True])
self.accept('a-up', self.setKeyStatus, extraArgs=['a', False])
self.accept('s', self.setKeyStatus, extraArgs=['s', True])
self.accept('s-up', self.setKeyStatus, extraArgs=['s', False])
self.accept('d', self.setKeyStatus, extraArgs=['d', True])
self.accept('d-up', self.setKeyStatus, extraArgs=['d', False])
else:
if gameObj.getAIBehaviorsHandle().behaviorStatus('pursue') == 'paused':
gameObj.getAIBehaviorsHandle().resumeAi('pursue')
def setKeyStatus(self, key, isDown):
self.keyMap[key] = isDown
print self.hero.getName()
######################################################################
## # ZJC - 07/29/2011: THIS CODE WAS COMMENTED OUT BECAUSE A MORE EFFICIENT WAY WAS FOUND
##
## prefixList = []
## #NEXT LINE- ZJC - 07/29/2011: This line is used to mark where to import the array used to deal with import flags.
## #LoaderFlagImportArray
## name = self.hero.getName().split('_')[0] # ZJC - 07/29/2011: name is assumed to be formatted NAME_otherstuff
## name2 = self.hero.getName().split('_')[1] # ZJC - 07/29/2011: name2 is assumed to be PREFIX_NAME_otherstuff
## if name in prefixList: # ZJC - 07/29/2011: Checks if the name is in the array, if it is name is not formatted as assumed
## name = name2 # ZJC - 07/29/2011: Use the second format if the first name is in the list
## print name
######################################################################
name = self.hero.getName().split('_')[0] # ZJC - 07/29/2011: Assumes format is Name_mod:#
## print name
for i in range(len(self.here.getName().split('_'))): # ZJC - 07/29/2011: Loop will check every possibility in the name string for any level of merges/imports
name2 = self.hero.getName().split('_')[i] # ZJC - 07/29/2011: name2 holds the current piece of the name string
if ("mod:" in name2) and (name != name2): # ZJC - 07/29/2011: This means the name format is Prefix(es)_Name_mod:#
name = self.hero.getName().split('_')[i-1] # ZJC - 07/29/2011: Assigns correct model name, the one just before mod:#
if isDown:
if key == 'w':
if self.hero.getActorHandle() != None:
self.hero.getActorHandle().stop(name + '_ani_idle') # ZJC - 07/26/2011: Stop the 'name' specific idle animation
self.hero.getActorHandle().setPlayRate(1.0, name + '_ani_run') # ZJC - 07/26/2011: Set play rate for the 'name' specific run animation
self.hero.getActorHandle().loop(name + '_ani_run') # ZJC - 07/26/2011: Run the 'name' specific run animation
self.keyMap['s'] = False
elif key == 's':
if self.hero.getActorHandle() != None:
self.hero.getActorHandle().stop(name + '_ani_idle') # ZJC - 07/26/2011: Stop the 'name' specific idle animation
self.hero.getActorHandle().setPlayRate(-0.7, name + '_ani_run') # ZJC - 07/26/2011: Set play rate for the 'name' specific run animation
self.hero.getActorHandle().loop(name + '_ani_run') # ZJC - 07/26/2011: Run the 'name' specific run animation
self.keyMap['w'] = False
elif key == 'a':
self.keyMap['d'] = False
elif key == 'd':
self.keyMap['a'] = False
elif not isDown:
if key == 'w':
if not self.keyMap['s']:
if self.hero.getActorHandle() != None:
self.hero.getActorHandle().stop(name + '_ani_run') # ZJC - 07/26/2011: Stop the 'name' specific run animation
self.hero.getActorHandle().loop(name + '_ani_idle') # ZJC - 07/26/2011: Run the 'name' specific idle animation
elif key == 's':
if not self.keyMap['w']:
if self.hero.getActorHandle() != None:
self.hero.getActorHandle().stop(name + '_ani_run') # ZJC - 07/26/2011: Stop the 'name' specific run animation
self.hero.getActorHandle().loop(name + '_ani_idle') # ZJC - 07/26/2011: Run the 'name' specific idle animation
elif key == 'a':
pass
elif key == 'd':
pass
## ZJC - 07/26/2011: This was the previous version of the code, it has been commented out and left as
## a reference. The changes made are defined in the comments above.
## if isDown:
## if key == 'w':
## if self.hero.getActorHandle() != None:
## self.hero.getActorHandle().stop('anim_idleFemale') # TODO: make a constant / set in LE
## self.hero.getActorHandle().setPlayRate(1.0, 'anim_jogFemale')
## self.hero.getActorHandle().loop('anim_jogFemale')
## self.keyMap['s'] = False
## elif key == 's':
## if self.hero.getActorHandle() != None:
## self.hero.getActorHandle().stop('anim_idleFemale') # TODO: make a constant / set in LE
## self.hero.getActorHandle().setPlayRate(-0.7, 'anim_jogFemale')
## self.hero.getActorHandle().loop('anim_jogFemale')
## self.keyMap['w'] = False
## elif key == 'a':
## self.keyMap['d'] = False
## elif key == 'd':
## self.keyMap['a'] = False
## elif not isDown:
## if key == 'w':
## if not self.keyMap['s']:
## if self.hero.getActorHandle() != None:
## self.hero.getActorHandle().stop('anim_jogFemale')
## self.hero.getActorHandle().loop('anim_idleFemale')
## elif key == 's':
## if not self.keyMap['w']:
## if self.hero.getActorHandle() != None:
## self.hero.getActorHandle().stop('anim_jogFemale')
## self.hero.getActorHandle().loop('anim_idleFemale')
## elif key == 'a':
## pass
## elif key == 'd':
## pass
def moveHeroTask(self, task):
dt = globalClock.getDt()
direction = int(self.keyMap['w'])-int(self.keyMap['s'])
self.moveHero(direction, dt)
if self.keyMap['a']:
self.turnHeroLeft()
elif self.keyMap['d']:
self.turnHeroRight()
return task.cont
##== Scene Handling =========================================================##
def loadScenes(self):
# NOTE: Do not remove! This function is populated by StandaloneExporter
pass
def addSequence(self, sequence):
self.ranSequences.append(sequence)
#this is for changing scenes
def resetAllSequences(self):
for seq in self.ranSequences:
seq.finish()
dr = self.cam.node().getDisplayRegion(0)
dr.setCamera(self.gameCam)
self.ranSequences = []
def openScene(self, sceneName):
if (self.scenes.has_key(sceneName)==False):
print "ERROR:There is no scene under the name ", sceneName,"."
return
self.startLoadBar(12)
self.createLoadScreen()
#Part2:Clear all of the collision lists
self.cTrav.removeCollider(self.heroCNP)
self.heroGroundHandler.clearEntries()
self.heroCollisionQueue.clearEntries()
self.resetAllSequences()
self.increaseLoadBar(1)
#Part3: stop all of the tasks
taskMgr.remove('processHeroCollisions')
taskMgr.remove('updateHeroHeight')
taskMgr.remove('moveHeroTask')
taskMgr.remove('cameraFollowTask')
taskMgr.remove("updateShaders") # ?
self.combatMgr.stopTasks()
self.gameplayUI.stop()
self.gameplayUI.removeAllHealthBars()
self.increaseLoadBar(1)
#Part1.1: Stop currently running parts like conversations or camera
if(self.conversationMgr.isConversationOpen()):
self.conversationMgr.closeConversation()
#Part 1.2: stop the camera
self.increaseLoadBar(1)
#Part4: Turn-Off all of the player controls
self.ignore("mouse1")
self.increaseLoadBar(1)
#Part5: Remove all of the game elements that are related with the current scene
del self.combatMgr
self.increaseLoadBar(1)
#Part6: Remove all of the children and the lights from the render
render.getChildren().detach()
render.clearLight()
self.increaseLoadBar(1)
#Part7:Add the camera and hero or any game element that should be exist in any scene back
self.camPivot.reparentTo(render)
self.hero.reparentTo(render)
#self.heroWallCollide.reparentTo(render)
self.heroWallCollideX.reparentTo(render)
self.heroWallCollideY.reparentTo(render)
self.heroWallCollideZ.reparentTo(render)
self.heroGroundCollide.reparentTo(render)
self.cameraHeroP.reparentTo(render)
self.overlayAmbientLightNP.reparentTo(render)
self.increaseLoadBar(1)
#Part8:Add the new objects from the new scene
self.assets, self.objects, self.gameObjects, self.sounds, self.sequences = loadWorld(self.scenes[sceneName], LIBRARY_INDEX)
self.increaseLoadBar(1)
#Part9:Add the hero to the new gameObject list and remove the duplicates of the hero
self.gameObjects[self.hero.getName()] = self.hero
if(self.objects.has_key(self.hero.getName())):
object = self.objects[self.hero.getName()]
if(object.hasTag('LE-mainChar')):
object.detachNode()
del self.objects[self.hero.getName()]
for name, gameObj in self.gameObjects.iteritems():
if gameObj.getNP().hasTag('LE-ground'):
#debug("is Ground")
bitmask = gameObj.getNP().getCollideMask()
bitmask |= BITMASK_GROUND
gameObj.getNP().setCollideMask(bitmask)
self.increaseLoadBar(1)
#Part10:Restart the tasks.
self.combatMgr = CombatMgr(self)
taskMgr.add(self.processHeroCollisions, 'processHeroCollisions')
taskMgr.add(self.updateHeroHeight, 'updateHeroHeight')
taskMgr.add(self.moveHeroTask, 'moveHeroTask')
taskMgr.add(self.cameraFollowTask, 'cameraFollowTask')
self.combatMgr.startTasks()
self.gameplayUI.start()
self.increaseLoadBar(1)
self.setCollideMasks(self.gameObjects)
self.increaseLoadBar(1)
#Part11: Change the color of the sky
if(sceneName.startswith("interior") or sceneName.startswith("Interior")):
self.setBackgroundColor(BGC_DARK_GREY)
else:
self.skybox.reparentTo(render)
self.setBackgroundColor(BGC_LIGHT_BLUE)
self.increaseLoadBar(1)
#Part12: Restart the player controls
self.accept("mouse1", self.onClickin3D)
self.increaseLoadBar(1)
self.accept("enter",self.destroyLoadScreen)
debug("After open Scene: "+str(self.heroCollisionQueue.getNumEntries()))
self.heroCollisionQueue.clearEntries()
self.cTrav.addCollider(self.heroCNP, self.heroCollisionQueue)
self.destroyLoadScreen()
def volumetricLightTest(self, model): fltr = CommonFilters(base.win, base.cam) fltr.setVolumetricLighting(model,64,2,.85,0.3)
class Universe(DirectObject):
def __init__(self, neweval, starList=[]):#, console=[]):
#messenger.toggleVerbose()
self.stars=starList
self.mouselook=True
self.zoom = .33
self.mapMode = False
self.evaluator = neweval
self.hudScale = 1
self.objectScale=.01
self.starScale = .1
self.skyScale=40000
self.dt=.02
self.starting=True
self.mouseX = 0
self.mouseY = 0
self.dX=0
self.dY=0
self.dZ=0
self.player = Body()
## self.mouseBody = Body()
## self.mouseBody.name = "mouse"
self.player.name = "player"
self.player.mass = 0
self.player.position.x=0
self.player.position.y=0
self.player.position.z=-0.04
self.player.orientation.y=90
self.accRate =2
# self.player.bodies=[]
# self.evaluator.system.bodies.append(self.player)
neweval.system.bodies.append(self.player)
self.evaluator= soPhysics.soPhysics(neweval.system)
self.evaluator.system.moveToStar()
self.filters = CommonFilters(base.win, base.cam)
self.filterok = self.filters.setBloom(blend=(1,1,1,1), desat=-0.5, intensity=1.0, size="small")
self.glowSize=1
#base.enableParticles()
#self.p = ParticleEffect()
#self.p.loadConfig("sun2.ptf")
self.loadPlanets()
#self.console = console
self.toggleConsole()
if len(starList)>0:
self.loadStars()
base.camLens.setNear(0.01)
base.camLens.setFar(100000)
# base.camLens.setFar(170000000000000000000000000000000000000)
self.mouselook=False
#render.setShaderAuto()
self.loadLights()
taskMgr.add(self.move,"move")
def loadLights(self):
plight = PointLight('plight')
plight.setColor(VBase4(1, 1, 1, 1))
self.plnp = render.attachNewNode(plight)
self.plnp.setPos(0, 0, 0)
render.setLight(self.plnp)
self.ambientLight = AmbientLight( 'ambientLight' )
self.ambientLight.setColor( Vec4( 0.1, 0.1, 0.1, 1 ) )
self.ambientLightNP = render.attachNewNode( self.ambientLight.upcastToPandaNode() )
render.setLight(self.ambientLightNP)
def loadStars(self):
print "loading stars"
for star in self.stars:
star.body.node = render.attachNewNode(star.body.name)
star.body.sphere = loader.loadModelCopy("models/dodecahedron")
sunMaterial =Material()
#sunMaterial.setEmission(VBase4(1,1,1,1))
sunMaterial.setEmission(VBase4(star.color[0],star.color[1],star.color[2], 1))
star.body.node.setMaterial(sunMaterial)
star.body.sphere.reparentTo(star.body.node)
star.body.sphere.setScale(self.starScale * star.radius)
star.body.node.setPos(star.body.position.x,star.body.position.y,star.body.position.z)
def setTexture(self, body, i):
if body.mass< 0.001:
body.texture = loader.loadTexture("models/earthmoon.jpg")
elif body.mass >= 0.001 and body.mass < .002:
body.texture = loader.loadTexture("models/mars.jpg")
elif body.mass >= .002 and body.mass < .003:
body.texture = loader.loadTexture("models/venus.jpg")
elif body.mass >= .003 and body.mass < .006:
body.texture = loader.loadTexture("models/mercury.jpg")
elif body.mass >= .006 and body.mass < .009:
body.texture = loader.loadTexture("models/pluto.jpg")
elif body.mass >= .009 and body.mass < .01:
body.texture = loader.loadTexture("models/uranus.jpg")
elif body.mass >= .01 and body.mass < .03:
body.texture = loader.loadTexture("models/saturn.jpg")
elif body.mass >= .03 and body.mass < .05:
body.texture = loader.loadTexture("models/neptune.jpg")
elif body.mass >= .05 and body.mass < .1:
body.texture = loader.loadTexture("models/saturn.jpg")
elif body.mass >= .1 and body.mass < .2:
body.texture = loader.loadTexture("models/jupiter.jpg")
else :
print body.mass
sunMaterial =Material()
sunMaterial.setTwoside(True)
body.name = "star"
#body.setColor(VBase4(1,1,1,1))
#self.p.start(parent = body.node, renderParent = body.node)
if body.mass >=.7 and body.mass < 1.0: #M type
body.texture = loader.loadTexture("models/Mstar.jpg")
sunMaterial.setEmission(VBase4(1,.6,.6,1))
elif body.mass >= 1.0 and body.mass < 1.5: #K type
body.texture = loader.loadTexture("models/Kstar.jpg")
sunMaterial.setEmission(VBase4(1,.6,.6,1))
elif body.mass >= 1.0 and body.mass < 1.5: #G type
body.texture = loader.loadTexture("models/GMstar.jpg")
sunMaterial.setEmission(VBase4(1,.6,.6,1))
#elif body.mass >= 1.5 and body.mass < 1.5: #G type
#body.texture = loader.loadTexture("models/Mstar.jpg")
#sunMaterial.setEmission(VBase4(1,.6,.6,1))
else:
body.texture = loader.loadTexture("models/Ostar.jpg")
sunMaterial.setEmission(VBase4(.8,.8,1,1))
body.node.setShaderAuto()
body.node.setMaterial(sunMaterial)
body.sphere.setTexture(body.texture,1)
def loadSinglePlanet(self, body,i):
body.node = render.attachNewNode(body.name)
if self.evaluator.gridSystem.names[i]!="player" and body.name != "player":
body.sphere = loader.loadModelCopy("models/planet_sphere")
body.sphere.reparentTo(body.node)
self.scalebody( i)
## scaleRate = ((math.sqrt(self.evaluator.gridSystem.mass[i]))/100)+.01
## body.sphere.setScale(scaleRate)
## self.evaluator.gridSystem.rad[i]=scaleRate
## body.mass=self.evaluator.gridSystem.mass[i]
## self.setTexture(body, i)
body.node.setPos(self.evaluator.gridSystem.pos[i][0],
self.evaluator.gridSystem.pos[i][1],
self.evaluator.gridSystem.pos[i][2])
else:
self.loadPlayer(body)
def detachNode(self, i):
#count = len(self.evaluator.system.bodies)-1
print "detaching node: ",i#count
self.evaluator.system.bodies[i].node.detachNode()
def loadPlanets(self):
pval = self.evaluator.gridSystem.player
print "player: ",pval
print self.evaluator.gridSystem.getPlayerIndex()
i=0
for body in self.evaluator.system.bodies:
if i ==pval:
print "player at: ",i
self.loadPlayer(self.player)
if i != pval:
self.loadSinglePlanet(body,i)
i+=1
self.sky = loader.loadModel("models/solar_sky_sphere")
self.sky_tex = loader.loadTexture("models/startex.jpg")
self.sky.setTexture(self.sky_tex, 1)
self.sky.setScale(self.skyScale)
self.sky.reparentTo(render)
def scaleUp(self):
self.accRate*= 1.01
print "accRate increasing",self.accRate
## print self.starScale
## for star in self.stars:
## star.body.sphere.setScale(self.starScale)
def scaleDown(self):
self.accRate*= .99
print "accRate decreasing",self.accRate
## print self.starScale
## for star in self.stars:
## star.body.sphere.setScale(self.starScale)
def toggleConsole(self):
print "toggle console"
#self.console.toggle()
def addPlanet(self):
self.loadSinglePlanet(self.evaluator.system.addSinglePlanet())
return
def loadRoid(self, abody):
if(len(self.player.bodies)<10):
self.player.bodies.append(abody)
self.evaluator.system.bodies.append(abody)
self.evaluator.accelerateCuda()
abody.node = render.attachNewNode(abody.name)
abody.model = loader.loadModelCopy("models/planet_sphere")
abody.model.reparentTo(abody.node)
abody.texture = loader.loadTexture("models/pluto.jpg")
abody.model.setScale(.01)
abody.node.setPos(abody.position.x ,abody.position.y ,abody.position.z)
return
def deloadRoid(self):
if(len(self.player.bodies) >0):
abody = self.player.bodies.pop()
self.evaluator.system.bodies.pop()
abody.node.detachNode()
return
def loadPlayer(self, abody):
abody.node = render.attachNewNode(abody.name)
abody.model = loader.loadModelCopy("models/fighter")
abody.model.reparentTo(abody.node)
if abody.name == "player":
abody.texture = loader.loadTexture("models/texturemap.png")
elif abody.name == "mouse":
abody.texture = loader.loadTexture("models/sun.jpg")
abody.model.setScale(.00005)
abody.radius=.00005
i = self.evaluator.gridSystem.getPlayerIndex()
self.evaluator.gridSystem.rad[i]=0.01
abody.node.setPos(self.evaluator.gridSystem.pos[i][0],
self.evaluator.gridSystem.pos[i][1],
self.evaluator.gridSystem.pos[i][2])
def exit(self):
quit()
return
def fullscreen(self):
print "doh"
def move(self,task):
# self.accept("p", self.addPlanet)
self.accept("`", self.toggleConsole)
self.accept("wheel_right", self.tiltLeft)
self.accept("wheel_left", self.tiltRight)
# self.accept("mouse6", self.tiltLeft)
# self.accept("mouse7", self.tiltRight)
#self.accept("w", self.tiltLeft)
#self.accept("r", self.tiltRight)
self.accept("mouse2", self.handlemouse2Click)
#self.accept("mouse3", self.handleRightMouseClick)
#self.accept("mouse1", self.handleLeftMouseClick)
self.accept("wheel_up", self.zoomIn)
self.accept("wheel_down", self.zoomOut)
self.accept("escape", self.exit)
self.accept("space",self.stop)
self.accept("s",self.brake)
self.accept("w",self.accelerate)
self.accept("f",self.fullscreen)
self.accept("m",self.togglemap)
self.accept("[",self.scaleDown)
self.accept("]",self.scaleUp)
self.accept("l",self.togglemouselook)
dt = self.dt
if not self.mapMode:
self.evaluator.accelerateCuda()
self.updateMouse(self.player)
if self.starting:
dt=dt/2.0
self.starting=False
#self.reloadPlanets()
self.setAllPositions()
return Task.cont
def tiltLeft(self):
print "left"
self.player.orientation.z-=10
def tiltRight(self):
print "right"
self.player.orientation.z+=10
def togglemouselook(self):
print "toggling mouselook"
if self.mouselook:
self.mouselook = False
else:
self.mouselook = True
def togglemap(self):
print "toggling map"
if (self.mapMode):
self.mapMode=False
self.zoom=1.1
else:
self.mapMode=True
self.zoom = 59000
def accelerate(self):
print "accelerating ship"
i = self.evaluator.gridSystem.getPlayerIndex()
self.evaluator.gridSystem.acc[i][0]+=self.dX*8
self.evaluator.gridSystem.acc[i][1]+=self.dY*8
self.evaluator.gridSystem.acc[i][2]+=self.dZ*8
#self.evaluator.gridSystem.printBody(i)
return
def stop(self):
i = self.evaluator.gridSystem.player
print "stopping ship", i
self.evaluator.gridSystem.printBody(i)
self.evaluator.gridSystem.vel[i][0]=0.0
self.evaluator.gridSystem.vel[i][1]=0.0
self.evaluator.gridSystem.vel[i][2]=0.0
return
def brake(self):
print "slowing ship"
i = self.evaluator.gridSystem.player
self.evaluator.gridSystem.printBody(i)
self.evaluator.gridSystem.acc[i][0]-=self.dX
self.evaluator.gridSystem.acc[i][1]-=self.dY
self.evaluator.gridSystem.acc[i][2]-=self.dZ
def handleMouse2(self):
print "deccelerating ship"
self.player.acceleration.x-=self.dX/10
self.player.acceleration.y-=self.dY/10
self.player.acceleration.z-=self.dZ/10
def handlemouse2Click(self):
print "mouse2"
self.togglemouselook()
def handlemouseLeftClick(self):
print "mouseLeft"
def handlemouseRightClick(self):
print "mouseRight"
def handleLeftMouseClick(self):
print "impactor deployed"
abody=Body()
abody.velocity.x = self.player.velocity.x
abody.velocity.y = self.player.velocity.y
abody.velocity.z = self.player.velocity.z
abody.position.x = self.player.position.x
abody.position.y = self.player.position.y
abody.position.z = self.player.position.z
abody.acceleration.x += self.dX/15
abody.acceleration.y += self.dY/15
abody.acceleration.z += self.dZ/15
abody.mass =0.00000001
self.loadRoid(abody)
return
def handleRightMouseClick(self):
print "removing impactor"
self.deloadRoid()
def zoomIn(self):
self.zoom*=0.9
print self.zoom
#self.scaleDown()
return
def zoomOut(self):
self.zoom*=1.1
print self.zoom
#self.scaleUp()
if self.zoom > 60000:
self.zoomIn()
return
def updateMouse(self, abody):
if (True):
newX=self.mouseX
newY=self.mouseY
if self.mouselook and base.mouseWatcherNode.hasMouse():
newX = base.mouseWatcherNode.getMouseX()
newY = base.mouseWatcherNode.getMouseY()
deltaX = self.mouseX - newX
deltaY = self.mouseY - newY
self.mouseX = newX
self.mouseY = newY
if abody.orientation.y >360:
abody.orientation.y -=360
if abody.orientation.x >360:
abody.orientation.x -=360
if abody.orientation.y > 180:
abody.orientation.y += (360*deltaY)
else:
abody.orientation.y -= (360*deltaY)
if abody.orientation.y > 180:
abody.orientation.x -= (360*deltaX)
else:
abody.orientation.x += (360*deltaX)
self.dZ = self.zoom*math.sin((-abody.orientation.y+180)*(math.pi / 180.0))
hyp = self.zoom*math.cos((-abody.orientation.y+180)*(math.pi / 180.0))
self.dX = hyp * math.sin((-abody.orientation.x+180)*(math.pi / 180.0))
self.dY = hyp * math.cos((-abody.orientation.x+180)*(math.pi / 180.0))
base.camera.setHpr(abody.orientation.x,
abody.orientation.y,abody.orientation.z)
cpos=self.evaluator.gridSystem.getPlayerIndex()
#base.camera.printPos()
base.camera.setPos(self.evaluator.gridSystem.pos[cpos][0]-self.dX,
self.evaluator.gridSystem.pos[cpos][1]-self.dY,
self.evaluator.gridSystem.pos[cpos][2]-self.dZ)
def setAllPositions(self):
for j in self.evaluator.gridSystem.collisions:
self.scalebody(j)
self.evaluator.gridSystem.collisoins=[]
for k in self.evaluator.gridSystem.removed:
self.detachNode(k)
## abody = Body(self.evaluator.system.getDirectedPlanet())
## self.evaluator.gridSystem.insertBody(abody,k)
## self.loadSinglePlanet(abody, k)
self.evaluator.gridSystem.removed=[]
i=0
for body in self.evaluator.system.bodies:
self.set_body_position(body,
self.evaluator.gridSystem.pos[i][0],
self.evaluator.gridSystem.pos[i][1],
self.evaluator.gridSystem.pos[i][2])
i+=1
def scalebody(self, i):
body = self.evaluator.system.bodies[i]
if body.name == "player":
print "rescaling: ",i," ",body.name
raw_input()
scaleRate = ((math.sqrt(self.evaluator.gridSystem.mass[i]))/50)+.001
body.sphere.setScale(scaleRate)
self.evaluator.gridSystem.rad[i]=scaleRate
body.mass=self.evaluator.gridSystem.mass[i]
self.setTexture(body, i)
def set_body_position(self,body,x,y,z):
if body.name == "star":
#print "moving light"
self.plnp.setPos(x,y,z)
body.node.setPos(x,y,z)
body.node.setHpr(body.orientation.x, body.orientation.y, body.orientation.z)
def __init__(self,manager,xml): self.cf = CommonFilters(base.win,base.cam) self.reload(manager,xml)
