def doFixedFunction(self):
fishFog = Fog('fishFogNode')
fishFog.setMode(Fog.MLinear)
fishFog.setColor(FishingGlobals.waterFogColor)
fishFog.setLinearRange(0.0, 200.0)
fishFogAttrib = FogAttrib.make(fishFog)
self.objectsWithCaustics.setAttrib(fishFogAttrib)
def _initFog(self):
self.fog = Fog("MazeFog")
self.fog.setColor(VBase4(0.3, 0.3, 0.3, 1.0))
self.fog.setLinearRange(0.0, 100.0)
self._renderFog = render.getFog()
render.setFog(self.fog)
def __init__(self):
# Make some nice fog
colour = (0.3, 0.3, 0.3)
linfog = Fog("A linear-mode Fog node")
linfog.setColor(*colour)
linfog.setLinearRange(0, 320)
linfog.setLinearFallback(45, 160, 320)
# Catchables positions
catchables = []
for i in xrange(100):
pos = (i * 10 + 10, 0, 2)
catchables.append(pos)
# Rocks positions and such
rocks = []
rock1 = (0, 50, 0, 10)
rocks.append(rock1)
self.fog = linfog
self.bgcolor = colour
self.scale = (1, 1, 1)
self.map = "worlds/maps/normalmap"
self.catchables = catchables
self.rocks = rocks
def _initFog(self):
self.fog = Fog("FlyingFog")
self.fog.setColor(VBase4(0.8, 0.8, 0.8, 1.0))
self.fog.setLinearRange(100.0, 400.0)
self._renderFog = render.getFog()
render.setFog(self.fog)
def __init__(self,parent,segments,timeOfDay):
super(VisualTrackSession, self).__init__()
self.parent=parent
self.ticks=0
self.cars=[]
self.events=[]
self.timerDependentObjects=[]
self.segments=segments
self.createdNodes=[]
self.stencilReaders={}
self.stencilWriters={}
self.carShadowRefreshIndex=0
self.speed=-1
self.lapTimeSeconds=-1
self.lapTimeMilliseconds=-1
self.secondsRemaining=-1
self.topScore=-1
self.correctAspectRatio()
base.setBackgroundColor(0.262,0.615,0.054)
base.accept('aspectRatioChanged',self.correctAspectRatio )
self.carsAndSceneryNode=render.attachNewNode("CarsAndSceneryNode")
self.carsAndSceneryNode.setColorScale(1.0,1.0,1.0,1.0)
self.sunEffectsEnabled=False
if timeOfDay==TimeOfDay.dusk:
self.setBackgroundTexture('textures/mountains4x2blurredblended.png')
self.setLightSourcePosition([12000,-800,1200])
self.addSunEffects()
else:
self.setBackgroundTexture('textures/mountainsx2blurredblended.png')
self.setLightSourcePosition([-4000,-1800,2400])
m = loader.loadModel("models/newstartline")
m.reparentTo(self.carsAndSceneryNode)
m.setPos(self.segments[0].getMidPoint().getX(),self.segments[0].getMidPoint().getY(),0)
m.setH(270)
self.lights=m
self.lightsIlluminated=False
for i in range(1,5):
self.setStartingLight(i,False)
self.createdNodes.append(m)
trackGeomNodes=TrackVisualGeometry.makeTrack(self.segments)
track=render.attachNewNode(trackGeomNodes['tarmac'])
texture=loader.loadTexture("textures/track256.png")
texture.setAnisotropicDegree(4)
texture.setMagfilter(Texture.FTNearest)
texture.setMinfilter(Texture.FTLinearMipmapLinear)
texture.setWrapU(Texture.WMRepeat)
texture.setWrapV(Texture.WMRepeat)
track.setTexture(texture)
track.setTwoSided(False)
track.setDepthWrite(False)
track.setDepthTest(False)
track.setBin("background",10)
self.createdNodes.append(track)
constantTwoStencil = StencilAttrib.make(1,StencilAttrib.SCFEqual,StencilAttrib.SOZero,StencilAttrib.SOKeep,StencilAttrib.SOReplace,2,0,2)
track.node().setAttrib(constantTwoStencil)
startLine=render.attachNewNode(trackGeomNodes['startline'])
texture=loader.loadTexture("textures/startline.png")
texture.setAnisotropicDegree(4)
texture.setMagfilter(Texture.FTNearest)
texture.setMinfilter(Texture.FTLinearMipmapLinear)
texture.setWrapU(Texture.WMRepeat)
texture.setWrapV(Texture.WMRepeat)
startLine.setTexture(texture)
startLine.setTwoSided(False)
startLine.setDepthWrite(False)
startLine.setDepthTest(False)
startLine.setBin("background",11);
self.createdNodes.append(startLine)
backgroundGeomNodes=MountainsGeometry.makeMountains()
mountainsGeomNode=backgroundGeomNodes['mountains']
mountains=render.attachNewNode(mountainsGeomNode)
texture=loader.loadTexture(self.getBackgroundTexture())
texture.setAnisotropicDegree(4)
texture.setWrapU(Texture.WMRepeat)
texture.setWrapV(Texture.WMClamp)
mountains.setTexture(texture)
mountains.setTwoSided(False)
mountains.setDepthWrite(False)
mountains.setDepthTest(False)
mountains.setBin("background",10);
self.createdNodes.append(mountains)
skyGeomNode=backgroundGeomNodes['sky']
sky=render.attachNewNode(skyGeomNode)
sky.setDepthWrite(False)
sky.setDepthTest(False)
sky.setBin("background",11)
self.createdNodes.append(sky)
constantOneStencil = StencilAttrib.make(1,StencilAttrib.SCFEqual,StencilAttrib.SOZero,StencilAttrib.SOKeep,StencilAttrib.SOReplace,1,0,1)
shadowX=self.segments[0].getMidPoint().getX()
shadowY=self.segments[0].getMidPoint().getY()
lightSourceX,lightSourceY,lightSourceZ=self.getLightSourcePosition()
shadowGeomNode=ShadowGeometry.makeModelShadow("models/newstartlineshadow",shadowX,shadowY,0,lightSourceX,lightSourceY,lightSourceZ,270)
shadow=render.attachNewNode(shadowGeomNode)
shadow.setTwoSided(True)
self.createdNodes.append(shadow)
shadow.setPos(shadowX,shadowY,0)
shadow.node().setAttrib(constantOneStencil)
shadow.node().setAttrib(ColorWriteAttrib.make(0))
shadow.setBin('fixed',40)
shadow.setDepthWrite(0)
self.createdNodes.append(shadow)
stencilReader = StencilAttrib.make(1,StencilAttrib.SCFEqual,StencilAttrib.SOKeep, StencilAttrib.SOKeep,StencilAttrib.SOKeep,1,1,0)
cm2d = CardMaker('card')
cm2d.setFrameFullscreenQuad()
card = render2d.attachNewNode(cm2d.generate())
card.node().setAttrib(stencilReader)
card.setDepthTest(False)
card.setTransparency(TransparencyAttrib.MAlpha)
card.setColor(0,0,0,0.40)
self.createdNodes.append(card)
trafficLightCm=CardMaker('card')
trafficLightCm.setFrame(-0.20,0.20,0.20,-0.20)
trafficLight = render.attachNewNode(trafficLightCm.generate())
trafficLight.reparentTo(self.lights)
trafficLight.setDepthTest(True)
trafficLight.setDepthWrite(False)
trafficLight.setColor(1.0,0.0,0.0,1.0)
trafficLight.setBin("unsorted",50)
trafficLight.setBillboardAxis()
trafficLight.setTwoSided(True)
tex = loader.loadTexture('textures/roadhighlight.png')
trafficLight.setTexture(tex)
trafficLight.setTransparency(TransparencyAttrib.MAlpha)
trafficLight.hide()
self.trafficLight=trafficLight
self.createdNodes.append(trafficLight)
colour = (45.0/255.0,81.0/255.0,98.0/255.0)
expfog = Fog("Scene-wide exponential Fog object")
expfog.setColor(*colour)
expfog.setExpDensity(0.002)
self.carsAndSceneryNode.setFog(expfog)
self.qualifyingEndBlimpFlightComplete=False
self.qualifyingResultsDisplayComplete=False
self.gearIndicator=GearIndicator()
self.gearIndicator.setGear(Gearbox.low)
def __init__(self):
"""Initialise the scene."""
# Show the framerate
base.setFrameRateMeter(True)
# Initialise terrain:
# Make 4 terrain nodepath objects with different hilliness values
# and arrange them side-by-side in a 2x2 grid, giving a big terrain
# with variable hilly and flat areas.
color = (0.6, 0.8, 0.5, 1) # Bright green-ish
scale = 12
height = 18 # FIXME: For now we are raising the terrain so it
# floats above the sea to prevent lakes from
# appearing (but you still get them sometimes)
t1 = Terrain(color=color,
scale=scale,
trees=0.7,
pos=P.Point3(0, 0, height))
t1.prime.reparentTo(render)
t2 = Terrain(color=color,
scale=scale,
h=24,
pos=P.Point3(32 * scale, 0, height),
trees=0.5)
t2.prime.reparentTo(render)
t3 = Terrain(color=color,
scale=scale,
h=16,
pos=P.Point3(32 * scale, 32 * scale, height),
trees=0.3)
t3.prime.reparentTo(render)
t4 = Terrain(color=color,
scale=scale,
h=2,
pos=P.Point3(0, 32 * scale, height),
trees=0.9)
t4.prime.reparentTo(render)
#tnp1.setPos(tnp1,-32,-32,terrainHeight)
# Initialise sea
sea = Sea()
# Initialise skybox.
self.box = loader.loadModel("models/skybox/space_sky_box.x")
self.box.setScale(6)
self.box.reparentTo(render)
# Initialise characters
self.characters = []
self.player = C.Character(model='models/eve',
run='models/eve-run',
walk='models/eve-walk')
self.player.prime.setZ(100)
self.player._pos = SteerVec(32 * 12 + random.random() * 100,
32 * 12 + random.random() * 100)
self.player.maxforce = 0.4
self.player.maxspeed = 0.55
EdgeScreenTracker(self.player.prime, dist=200) # Setup camera
for i in range(0, 11):
self.characters.append(C.Character())
self.characters[i].prime.setZ(100)
self.characters[i].wander()
self.characters[i].maxforce = 0.3
self.characters[i].maxspeed = 0.2
self.characters[i]._pos = SteerVec(32 * 12 + random.random() * 100,
32 * 12 + random.random() * 100)
C.setContainer(
ContainerSquare(pos=SteerVec(32 * 12, 32 * 12), radius=31 * 12))
#C.toggleAnnotation()
# Initialise keyboard controls.
self.accept("c", C.toggleAnnotation)
self.accept("escape", sys.exit)
# Setup CollisionRay and CollisionHandlerQueue for mouse picking.
self.pickerQ = P.CollisionHandlerQueue()
self.picker = camera.attachNewNode(
P.CollisionNode('Picker CollisionNode'))
self.picker.node().addSolid(P.CollisionRay())
# We want the picker ray to collide with the floor and nothing else.
self.picker.node().setFromCollideMask(C.floorMASK)
self.picker.setCollideMask(P.BitMask32.allOff())
base.cTrav.addCollider(self.picker, self.pickerQ)
try:
handler.addCollider(self.picker, camera)
except:
pass
self.accept('mouse1', self.onClick)
# Set the far clipping plane to be far enough away that we can see the
# skybox.
base.camLens.setFar(10000)
# Initialise lighting
self.alight = AmbientLight('alight')
self.alight.setColor(VBase4(0.35, 0.35, 0.35, 1))
self.alnp = render.attachNewNode(self.alight)
render.setLight(self.alnp)
self.dlight = DirectionalLight('dlight')
self.dlight.setColor(VBase4(0.4, 0.4, 0.4, 1))
self.dlnp = render.attachNewNode(self.dlight)
self.dlnp.setHpr(45, -45, 0)
render.setLight(self.dlnp)
self.plight = PointLight('plight')
self.plight.setColor(VBase4(0.8, 0.8, 0.5, 1))
self.plnp = render.attachNewNode(self.plight)
self.plnp.setPos(160, 160, 50)
self.slight = Spotlight('slight')
self.slight.setColor(VBase4(1, 1, 1, 1))
lens = PerspectiveLens()
self.slight.setLens(lens)
self.slnp = render.attachNewNode(self.slight)
self.slnp.setPos(-20, -20, 20)
self.slnp.lookAt(50, 50, 0)
# Initialise some scene-wide exponential fog
colour = (0.5, 0.8, 0.8)
self.expfog = Fog("Scene-wide exponential Fog object")
self.expfog.setColor(*colour)
self.expfog.setExpDensity(0.0005)
render.setFog(self.expfog)
base.setBackgroundColor(*colour)
# Add a task for this Plant to the global task manager.
self.stepcount = 0
taskMgr.add(self.step, "Plant step task")
def exponential(self):
self.fog = Fog("Scene-wide exponential Fog object")
density = 1.38629436 / (MAX_VIEW_RANGE + 30)
self.fog.setExpDensity(density)
def linear(self):
self.fog = Fog("A linear-mode Fog node")
self.fog.setLinearRange(0, 320)
self.fog.setLinearFallback(5, 20, 50)
def __init__(self, world, x1, y1, x2, y2, z):
self.world = world
logging.info(('setting up water plane at z=' + str(z)))
# Water surface
maker = CardMaker('water')
maker.setFrame(x1, x2, y1, y2)
self.waterNP = render.attachNewNode(maker.generate())
self.waterNP.setHpr(0, -90, 0)
self.waterNP.setPos(0, 0, z)
self.waterNP.setTransparency(TransparencyAttrib.MAlpha)
self.waterNP.setShader(loader.loadShader('shaders/water.sha'))
self.waterNP.setShaderInput('wateranim',
Vec4(0.03, -0.015, 64.0,
0)) # vx, vy, scale, skip
# offset, strength, refraction factor (0=perfect mirror, 1=total refraction), refractivity
self.waterNP.setShaderInput('waterdistort', Vec4(0.4, 4.0, 0.25, 0.45))
self.waterNP.setShaderInput('time', 0)
# Reflection plane
self.waterPlane = Plane(Vec3(0, 0, z + 1), Point3(0, 0, z))
planeNode = PlaneNode('waterPlane')
planeNode.setPlane(self.waterPlane)
# Buffer and reflection camera
buffer = base.win.makeTextureBuffer('waterBuffer', 512, 512)
buffer.setClearColor(Vec4(0, 0, 0, 1))
cfa = CullFaceAttrib.makeReverse()
rs = RenderState.make(cfa)
self.watercamNP = base.makeCamera(buffer)
self.watercamNP.reparentTo(render)
#sa = ShaderAttrib.make()
#sa = sa.setShader(loader.loadShader('shaders/splut3Clipped.sha') )
cam = self.watercamNP.node()
cam.getLens().setFov(base.camLens.getFov())
cam.getLens().setNear(1)
cam.getLens().setFar(5000)
cam.setInitialState(rs)
cam.setTagStateKey('Clipped')
#cam.setTagState('True', RenderState.make(sa))
# ---- water textures ---------------------------------------------
# reflection texture, created in realtime by the 'water camera'
tex0 = buffer.getTexture()
tex0.setWrapU(Texture.WMClamp)
tex0.setWrapV(Texture.WMClamp)
ts0 = TextureStage('reflection')
self.waterNP.setTexture(ts0, tex0)
# distortion texture
tex1 = loader.loadTexture('textures/water.png')
ts1 = TextureStage('distortion')
self.waterNP.setTexture(ts1, tex1)
# ---- Fog --- broken
min = Point3(x1, y1, -999.0)
max = Point3(x2, y2, z)
boundry = BoundingBox(min, max)
self.waterFog = Fog('waterFog')
self.waterFog.setBounds(boundry)
colour = (0.2, 0.5, 0.8)
self.waterFog.setColor(*colour)
self.waterFog.setExpDensity(0.05)
render.attachNewNode(self.waterFog)
#render.setFog(world.waterFog)
taskMgr.add(self.update, "waterTask")
def load(self):
ToonHood.load(self)
self.fog = Fog('OZFog')
def start(self):
self.textures.load_all()
self.char = Actor("res/models/ralph",
{"run":"res/models/ralph-run",
"walk":"res/models/ralph-walk"})
self.char.pose('walk', 5)
self.char.setScale(.2)
self.char.setH(180)
self.gui.buttons.add_button(name = 'Exit', text = ("Exit", "Exit", "Exit", "disabled"),
pos = (1.23, 0, -0.95),
scale = 0.07, command=self.stop)
self.gui.screen_texts.add_text(name = 'status',
text = 'Hello! Suber was started!',
pos = (-1.3, -0.95), scale = 0.07)
#self.gui.entries.add_entry(name = 'console',text = "" ,
#pos = (-1.29, 0, -0.85),
#scale=0.07,command=self.cmd_handler.cmd_handle,
#initialText="", width = 37, numLines = 1,focus=0)
self.gui.screen_texts.add_text(name = 'help',
text = 'F5 - create world\nm - toggle map\nF1 - toggle'+\
' help\nEsc - exit\nF10 - render info\n'+\
'F2/F3 - 1st/3d person camera\n'+\
'F4 - toggle fly/terrain\n'+\
'F9 - Cam disable\n'+\
'F8 - Toggle Collisions\n'+\
'F11/F12 - toggle polygons / disable textures',
pos = (-1, 0.8), scale = 0.07)
self.gui.hotkeys.accept('f1', self.toggle_help)
self.gui.screen_images.add_image('sight',
self.textures['sight'],
scale = 0.05, pos = (0, 0, 0))
self.gui.screen_images['sight'].setTransparency(TransparencyAttrib.MAlpha)
plight = PointLight('plight')
sun = self.gui.render.attachNewNode(plight)
sun.setPos(-32768, 32768, 20000)
self.gui.render.setLight(sun)
alight = AmbientLight('alight')
alight.setColor(VBase4(0.5, 0.5, 0.5, 1))
alnp = self.gui.render.attachNewNode(alight)
self.gui.render.setLight(alnp)
color = (0.28125, 0.53125, 0.80859375)
fog = Fog("A linear-mode Fog node")
fog.setColor(*color)
fog.setLinearFallback(0,500,550)
self.gui.camera.attachNewNode(fog)
color = (0.28125, 0.53125, 0.80859375)
self.gui.render.setFog(fog)
self.gui.setBackgroundColor(*color)
self.cam_manager = CamManager(self)
self.move_avatar = MoveAvatar(self)
self.vox_config = VoxConfig()
self.coord_block = CoordBlock(self, self.vox_config)
self.vox_params = VoxParams()
self.vox_params.gui = self.gui
self.vox_params.avatar = self.cam_manager.node
self.vox_params.status = self.write
self.vox_params.root_node = self.gui.render
self.vox_params.chunks_tex = self.textures['world_blocks']
self.vox_params.get_coord_block = self.coord_block
self.vox_params.tree_tex = self.textures['tree']
self.vox_params.water_tex = self.textures['water']
self.vox_params.leafModel = self.gui.loader.loadModel("res/models/shrubbery")
self.vox_params.leafTex = self.textures['leaf']
self.vox_params.fog = fog
self.world = World(self.vox_config, self.vox_params)
self.collision_avatar = CollisionAvatar(self)
#self.vox_params.sun = sun
self.gui.taskMgr.setupTaskChain('Ticker', tickClock = True)
self.gui.taskMgr.doMethodLater(0.05, self.ticker, 'taskTicker', taskChain = 'Ticker')
self.gui.start()
