API tools faq
paste
Wallace543

Main.py threads

Wallace543
Oct 2nd, 2013
137
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
Python 12.81 KB | None | 0 0
raw download clone embed print report
  1. import direct.directbase.DirectStart
  2. from direct.showbase.DirectObject import DirectObject
  3. from pandac.PandaModules import *
  4. loadPrcFileData("", "fullscreen 1")
  5. loadPrcFileData("","win-size 1024 768")
  6. from direct.interval.IntervalGlobal import LerpFunc
  7. import sys
  8. from chunk import *
  9.  
  10. from direct.stdpy import thread # Threading stuff
  11.  
  12. PStatClient.connect()
  13.  
  14. base.setFrameRateMeter(True)
  15.  
  16. lastPos = base.cam.getPos()
  17. updateDistanceSquared = 64*64
  18.  
  19. skybox = loader.loadModel("skybox")
  20. skybox.setScale(256)
  21. skybox.setBin('background', 1)
  22. skybox.setDepthWrite(0)
  23. skybox.setLightOff()
  24. skybox.reparentTo(render)
  25.  
  26. taskMgr.setupTaskChain('custom task chain', numThreads = 1, tickClock = None,     #Task chain for separate thread
  27.                        threadPriority = TP_normal, frameBudget = -1,
  28.                        frameSync = False, timeslicePriority = None)
  29.  
  30. class FPS(object,DirectObject):
  31.     chunks2 = []
  32.     coords = []
  33.     positionX = 0
  34.     positionY = 0
  35.     chunksToMake = []
  36.     def __init__(self):
  37.         global c,chunks,chunks1
  38. ##        self.initChunks()
  39.         self.makeChunksAroundX(self.positionX,self.positionY)
  40.         self.winXhalf = base.win.getXSize()/2
  41.         self.winYhalf = base.win.getYSize()/2
  42. ##        self.makeTrees()
  43.         self.initCollision()
  44. ##        self.initShadows()
  45.         c = 0.0
  46.         self.initPlayer()
  47.         self.initWater()
  48. ##    def initChunks(self):
  49. ##        #make a chunk
  50. ##        start = chunk(0,0,0,0)
  51. ##        start.makeChunk()
  52. ##        start.done = True
  53. ##        self.currentChunk = start
  54. ##        chunks2.append(start)
  55. ##        #make chunks around it - east
  56. ##        c = chunk(self.currentChunk.x+chunksize,self.currentChunk.y,self.currentChunk.offsetx+chunksize-1,self.currentChunk.offsety)
  57. ##        c.makeChunk()
  58. ##        self.currentChunk.east = True
  59. ##        self.currentChunk.East = c
  60. ##        c.done = True
  61. ##        c.West = self.currentChunk
  62. ##        chunks2.append(c)
  63. ##        # - west
  64. ##        c = chunk(self.currentChunk.x-chunksize,self.currentChunk.y,self.currentChunk.offsetx-chunksize+1,self.currentChunk.offsety)
  65. ##        c.makeChunk()
  66. ##        self.currentChunk.west = True
  67. ##        self.currentChunk.West = c
  68. ##        c.done = True
  69. ##        c.East = self.currentChunk
  70. ##        chunks2.append(c)
  71. ##        # - north
  72. ##        c = chunk(self.currentChunk.x,self.currentChunk.y+chunksize,self.currentChunk.offsetx,self.currentChunk.offsety+chunksize-1)
  73. ##        c.makeChunk()
  74. ##        self.currentChunk.north = True
  75. ##        self.currentChunk.North = c
  76. ##        c.done = True
  77. ##        c.South = self.currentChunk
  78. ##        chunks2.append(c)
  79. ##        # - south
  80. ##        c = chunk(self.currentChunk.x,self.currentChunk.y-chunksize,self.currentChunk.offsetx,self.currentChunk.offsety-chunksize+1)
  81. ##        c.makeChunk()
  82. ##        self.currentChunk.south = True
  83. ##        self.currentChunk.South = c
  84. ##        c.done = True
  85. ##        c.North = self.currentChunk
  86. ##        chunks2.append(c)
  87.     def makeChunksAroundX(self,X,Y):
  88.         #initial chunk
  89. ##        start = chunk(0,0,0,0)
  90. ##        self.currentChunk = start
  91. ##        self.chunks2.append(start)
  92.         offsetx =X -(chunksize*3)
  93.         offsety =Y -(chunksize*3)
  94.         for y in xrange(7):
  95.             for x in xrange(7):
  96.                 if [offsetx,offsety] not in self.coords:
  97.                     c = chunk(offsetx,offsety)
  98.                     self.chunksToMake.append(c)
  99.                     self.chunks2.append(c)
  100.                     offsetx += chunksize
  101.                     if offsetx == 0 and offsety == 0:
  102.                         self.currentChunk = c
  103.                     self.coords.append([c.x,c.y])
  104.                 else:
  105.                     pass
  106.             offsety += chunksize
  107.             offsetx =X -(chunksize*3)
  108.         taskMgr.add(self.extendChunkGrid,'update-chunks')
  109.         taskMgr.add(self.checkForChunks, 'Check chunks to be loaded', taskChain = 'custom task chain') #Task in separate thread
  110.     def extendChunkGrid(self,task):
  111.         if self.man.getX() > self.positionX+(chunksize*4): #East
  112.             self.positionX+=chunksize*7
  113.             self.makeChunksAroundX(self.positionX,self.positionY)
  114.         elif self.man.getX() < self.positionX-(chunksize*3): #West
  115.             self.positionX-=chunksize*7
  116.             self.makeChunksAroundX(self.positionX,self.positionY)
  117.         if self.man.getY() > self.positionY+(chunksize*4): #North
  118.             self.positionY+=chunksize*7
  119.             self.makeChunksAroundX(self.positionX,self.positionY)
  120.         elif self.man.getY() < self.positionY-(chunksize*3): #South
  121.             self.positionY-=chunksize*7
  122.             self.makeChunksAroundX(self.positionX,self.positionY)
  123.         return task.cont
  124.     def checkForChunks(self,task): #Check chunksToMake list and make the chunks 1 per frame so program doesn't lagspike
  125.         if len(self.chunksToMake) != 0: #This function is cause of frame rate problems according to pstats :/
  126.             self.chunksToMake[0].makeChunk()
  127.             self.chunksToMake.remove(self.chunksToMake[0])
  128.         return task.cont
  129.     def makeTrees(self):
  130.         self.trees = []
  131.         self.tree = loader.loadModel("trees/treeHighA")
  132.         self.tree.setScale(0.2)
  133.         self.trees.append(self.tree)
  134.         self.tree1 = loader.loadModel("trees/treeHighB")
  135.         self.tree1.setScale(0.2)
  136.         self.trees.append(self.tree1)
  137.         self.tree2 = loader.loadModel("trees/treeHighC")
  138.         self.tree2.setScale(0.2)
  139.         self.trees.append(self.tree2)
  140.         self.tree3 = loader.loadModel("trees/treeLowA")
  141.         self.tree3.setScale(0.2)
  142.         self.trees.append(self.tree3)
  143.         self.tree4 = loader.loadModel("trees/treeLowB")
  144.         self.tree4.setScale(0.2)
  145.         self.trees.append(self.tree4)
  146.         self.tree5 = loader.loadModel("trees/treeLowC")
  147.         self.tree5.setScale(0.2)
  148.         self.trees.append(self.tree5)
  149.     def initCollision(self):
  150.         #initialize traverser
  151.         base.cTrav = CollisionTraverser()
  152.         base.cTrav.setRespectPrevTransform(True)
  153.         #         base.cTrav.showCollisions(render)
  154.         #initialize pusher
  155.         self.pusher = CollisionHandlerPusher()
  156.         # collision bits
  157.         self.groundCollBit = BitMask32.bit(0)
  158.         self.collBitOff = BitMask32.allOff()
  159.     def initPlayer(self):
  160.         #load man
  161.         self.man = render.attachNewNode('man') # keep this node scaled to identity
  162.         self.man.setPos(chunksize/2,chunksize/2,25)
  163.         # should be avatar model
  164.         #         model = loader.loadModel('teapot')
  165.         #         model.reparentTo(self.man)
  166.         #         model.setScale(.05)
  167.         # camera
  168.         base.camera.reparentTo(self.man)
  169.         base.camera.setPos(0,0,8.7)#8.7 #2.7 #1.7
  170.         base.camLens.setNearFar(1.0,450) #originally at .1,1000
  171.         base.disableMouse()
  172.         props = WindowProperties()
  173.         props.setCursorHidden(True)
  174.         base.win.requestProperties(props)
  175.         #create a collsion solid around the man
  176.         manC = self.man.attachCollisionSphere('manSphere', 0,0,1, .4, self.groundCollBit,self.collBitOff)
  177.         self.pusher.addCollider(manC,self.man)
  178.         base.cTrav.addCollider(manC,self.pusher)
  179.  
  180.         speed = 20
  181.         Forward = Vec3(0,speed*2,0)
  182.         Back = Vec3(0,-speed,0)
  183.         Left = Vec3(-speed,0,0)
  184.         Right = Vec3(speed,0,0)
  185.         Stop = Vec3(0)
  186.         self.walk = Stop
  187.         self.strafe = Stop
  188.         self.jump = 0
  189.         taskMgr.add(self.move, 'move-task')
  190.         self.jumping = LerpFunc( Functor(self.__setattr__,"jump"),
  191.                               duration=1.5, fromData=.25, toData=0)
  192.         self.accept( "escape",sys.exit )
  193.         self.accept( "space" , self.startJump)
  194.         self.accept( "s" , self.__setattr__,["walk",Back] )
  195.         self.accept( "w" , self.__setattr__,["walk",Forward])
  196.         self.accept( "s-up" , self.__setattr__,["walk",Stop] )
  197.         self.accept( "w-up" , self.__setattr__,["walk",Stop] )
  198.         self.accept( "a" , self.__setattr__,["strafe",Left])
  199.         self.accept( "d" , self.__setattr__,["strafe",Right] )
  200.         self.accept( "a-up" , self.__setattr__,["strafe",Stop] )
  201.         self.accept( "d-up" , self.__setattr__,["strafe",Stop] )
  202.  
  203.         self.manGroundColNp = self.man.attachCollisionRay( 'manRay',
  204.                                                         0,0,.6, 0,0,-1,
  205.                                                         self.groundCollBit,self.collBitOff)
  206.         self.manGroundHandler = CollisionHandlerGravity()
  207.         self.manGroundHandler.addCollider(self.manGroundColNp,self.man)
  208.         base.cTrav.addCollider(self.manGroundColNp, self.manGroundHandler)
  209.  
  210.     def startJump(self):
  211.         if self.manGroundHandler.isOnGround():
  212.             self.jumping.start()
  213.  
  214.     def move(self,task):
  215.         dt=globalClock.getDt()
  216.         # mouse
  217.         md = base.win.getPointer(0)
  218.         x = md.getX()
  219.         y = md.getY()
  220.         if base.win.movePointer(0, self.winXhalf, self.winYhalf):
  221.             self.man.setH(self.man, (x - self.winXhalf)*-0.1)
  222.             base.camera.setP( clampScalar(-90,90, base.camera.getP() - (y - self.winYhalf)*0.1) )
  223.         # move where the keys set it
  224.         moveVec=(self.walk+self.strafe)*dt # horisontal
  225.         moveVec.setZ( self.jump )          # vertical
  226.         self.man.setFluidPos(self.man,moveVec)
  227.         # jump damping
  228.         if self.jump>0:
  229.             self.jump = clampScalar( 0,1, self.jump*.9)
  230.         skybox.setPos(base.camera,0,0,0)
  231. ##        water.setPos(base.camera,-50,-50,10)
  232.         return task.cont
  233.     def moveGuy(self,task):
  234.         global xpos
  235.         self.m.setX(xpos)
  236.         xpos+=0.5
  237.         return task.cont
  238.     def initWally(self):
  239.         self.wally = loader.loadModel("wally")
  240.         self.wally.reparentTo(render)
  241.         self.wally.setPos(0,0,4)
  242.     def initShadows(self):
  243.         # Add a light to the scene.
  244.         self.lightpivot = render.attachNewNode("lightpivot")
  245.         self.lightpivot.setPos(0,0,25)
  246.         self.plight = PointLight('plight')
  247.         self.plight.setColor(Vec4(1, 1, 1, 1))
  248.         self.plight.setAttenuation(Vec3(0.001,0.001,0))#0.7,0.05,0))
  249.         self.plnp = self.lightpivot.attachNewNode(self.plight)
  250.         self.plnp.setPos(45, 45, 400)
  251.  
  252.         # Add an ambient light
  253.         self.alight = AmbientLight('alight')
  254.         self.alight.setColor(Vec4(0.2, 0.2, 0.2, 1))
  255.         self.alnp = render.attachNewNode(self.alight)
  256.  
  257.         # create a sphere to denote the light
  258.         sphere = loader.loadModel("sphere")
  259.         sphere.setScale(40)
  260.         self.shaderenable = 1
  261.     def initWater(self):
  262.         cm = CardMaker("water")
  263.         cm.setFrame(-1, 1, -1, 1)
  264.         self.water = render.attachNewNode(cm.generate())
  265.         self.water.setScale(4096)
  266.         self.water.lookAt(0, 0, -1)
  267.         self.water.setZ(15)#62.365)
  268.         self.water.setShaderOff(1)
  269.         self.water.setLightOff(1)
  270.         self.water.setAlphaScale(0.6)#0.5)
  271.         self.water.setTransparency(TransparencyAttrib.MAlpha)
  272.         wbuffer = base.win.makeTextureBuffer("water", 512, 512)
  273.         wbuffer.setClearColorActive(True)
  274.         wbuffer.setClearColor(base.win.getClearColor())
  275.         self.wcamera = base.makeCamera(wbuffer)
  276.         self.wcamera.reparentTo(render)
  277.         self.wcamera.node().setLens(base.camLens)
  278.         self.wcamera.node().setCameraMask(BitMask32.bit(1))
  279.         self.water.hide(BitMask32.bit(1))
  280. ##        fir.hide(BitMask32.bit(1))
  281.         wtexture = wbuffer.getTexture()
  282.         wtexture.setWrapU(Texture.WMClamp)
  283.         wtexture.setWrapV(Texture.WMClamp)
  284.         wtexture.setMinfilter(Texture.FTLinearMipmapLinear)
  285.         self.wplane = Plane(Vec3(0, 0, 1), Point3(0, 0, self.water.getZ()))
  286.         self.wplanenp = render.attachNewNode(PlaneNode("water", self.wplane))
  287.         tmpnp = NodePath("StateInitializer")
  288.         tmpnp.setClipPlane(self.wplanenp)
  289.         tmpnp.setAttrib(CullFaceAttrib.makeReverse())
  290.         self.wcamera.node().setInitialState(tmpnp.getState())
  291.         self.water.projectTexture(TextureStage("reflection"), wtexture, self.wcamera)
  292. ##        base.bufferViewer.toggleEnable()
  293.         taskMgr.add(self.update_camera, 'update-water', sort=45)
  294.     def update_camera(self, task):
  295.         mat = base.cam.getMat(self.wplanenp)
  296.         mat *= self.wplane.getReflectionMat()
  297.         self.wcamera.setMat(mat)
  298.         return task.cont
  299.    
  300. # Add a task to keep updating the terrain
  301. def updateTask(task):
  302.      global lastPos
  303.      pos = base.cam.getPos()
  304.      distSq = (pos - lastPos).lengthSquared()
  305.      for i in chunks:
  306.          i.getRoot().setCollideMask(BitMask32.bit(0))
  307.      if distSq > updateDistanceSquared:
  308.          lastPos = pos
  309.          for i in chunks:
  310.              i.update()
  311.      return task.cont
  312. taskMgr.add(updateTask, "update")
  313.  
  314.  
  315. FPS()
  316. render.setShaderAuto()
  317. run()
Advertisement
Add Comment
Please, Sign In to add comment
Public Pastes
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!