def toggleAmbientOcclusion(self, checked):
filters = CommonFilters(base.win, base.cam)
if checked == True:
filters.setAmbientOcclusion()
else:
filters.delAmbientOcclusion()
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()
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 __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 __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 __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):
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 __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)
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):
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)
# 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 toggleToonShading(self, checked):
filters = CommonFilters(base.win, base.cam)
if checked == True:
filters.setCartoonInk()
else:
filters.delCartoonInk()
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 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()
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 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 _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 __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 __init__(self):
ShowBase.__init__(self)
# Gui
#gui = GUI(self)
render.setShaderAuto()
self.game = Game(self)
filters = CommonFilters(base.win, base.cam)
filters.setBloom()
filters.setCartoonInk()
def __init__(self):
super().__init__(self)
self.var1 = 0
self.scene = loader.loadModel("models/world")
playerTexture = loader.loadTexture("models/starfoxShip.jpg")
self.player = self.scene.find("player")
self.player.setTexture(playerTexture)
base.setBackgroundColor(0.1, 0.1, 0.1, 1)
enemyTexture = loader.loadTexture("models/enemyShip.jpg")
self.enemy = self.scene.find("enemy1")
self.enemy.setTexture(enemyTexture)
self.basePlane = self.scene.find("basePlane")
self.scene.reparentTo(self.render)
self.player.setPos(50, 50, 3)
self.enemy.setPos(50, 55, 0)
self.ambient = AmbientLight("ambient")
self.ambient.color = (0.1, 0.1, 0.1, 1)
self.ambientPath = self.render.attachNewNode(self.ambient)
render.setLight(self.ambientPath)
self.dirLight = DirectionalLight("dir light")
self.dirLight.color = (1, 1, 1, 1)
self.dirLightPath = self.render.attachNewNode(self.dirLight)
self.dirLightPath.setHpr(0, -90, 0)
self.dirLight.setShadowCaster(True, 512, 512)
render.setLight(self.dirLightPath)
self.pointLight = PointLight("point light")
self.pointLight.color = (1, 1, 1, 1)
self.pointLightPath = self.render.attachNewNode(self.pointLight)
self.pointLightPath.setPos(50, 52.5, 4)
self.pointLight.attenuation = (.5, 0, 0)
self.pointLight.setShadowCaster(True, 1024, 1024)
self.render.setLight(self.pointLightPath)
self.fog = Fog("fog")
self.fog.setColor(0.1, 0.1, 0.1)
self.fog.setExpDensity(.3)
self.fog.setLinearRange(150, 300)
self.fog.setLinearFallback(45, 160, 320)
self.render.setFog(self.fog)
self.render.setShaderAuto()
self.render.setAntialias(AntialiasAttrib.MAuto)
filters = CommonFilters(base.win, base.cam)
filters.setBloom(size="large")
filters.setAmbientOcclusion(strength=0.6, falloff=0.0005, radius=0.1)
filters.setCartoonInk(separation=2, color=(0, 0, 0, 1))
self.taskMgr.add(self.update, "update")
def __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()
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__(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 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, parent):
base.win.setClearColor(VBase4(0, 0, 0, 0))
self.parent = parent
# GAMETYPE
self.type = 'DEBUG' # 'FPS' or 'DEBUG'
self.type = 'FPS' # 'FPS' or 'DEBUG'
# Creating level geometry
self.level = Level(self, LEVELS[0])
# Instance the player controller
self.player = Player(self, self.level.start_pos)
if self.type == 'FPS':
base.disableMouse()
base.camera.reparentTo(self.player.node)
base.camLens.setFov(100)
# Load aim icon
cm = CardMaker('aim_node')
cm.setFrame(-0.02, 0.02, -0.02, 0.02)
self.aim_node = aspect2d.attachNewNode(cm.generate())
self.aim_node.setTexture(loader.loadTexture('models/aim.png'))
self.aim_node.setTransparency(TransparencyAttrib.MAlpha)
elif self.type == 'DEBUG':
base.disableMouse()
self.camera = CameraManager(self)
# Create ambient light
self.alight = AmbientLight("alight")
self.alnp = render.attachNewNode(self.alight)
render.setLight(self.alnp)
# Instance collision manager
self.collision_manager = CollisionManager(self)
self.collision_manager.createLevelCollision(self.level)
self.zombies = []
self.spawnEnemy()
# Instance class for debug output
#self.debug = DebugOptions(self)
# Setup default options (which have been previously set in DebugOptions)
# If you uncomment DebugOptions, comment out two lines below
self.alight.setColor(VBase4(0.03, 0.03, 0.03, 1.0))
render.setShaderAuto()
# Instance common filters class (blur, AO, bloom)
self.filters = CommonFilters(base.win, base.cam)
def setShaderOn(self):
'''
activates all shaders
'''
# activate the shaders
self.filters = []
for i in xrange(len(self.cameras)):
if self.cameras[i] != None:
self.filters.append(CommonFilters(base.win, self.cameras[i]))
self.filters[i].setBloom(blend=(0, 0, 0, 1),
desat=-0.8,
intensity=4.0,
size="big")
else:
self.filters.append(None)
self.shaders_on = True
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())
