def makePerspective(parent): v = Viewport('persp', parent) v.camPos = Point3(-19, -19, 19) v.camLookAt = Point3(0, 0, 0) v.grid = DirectGrid(parent=render) collPlane = CollisionNode('PerspGridCol') collPlane.addSolid(CollisionPlane(Plane(0, 0, 1, 0))) #oldBitmask = collPlane.getIntoCollideMask() #collPlane.setIntoCollideMask(BitMask32.bit(21)|oldBitmask) collPlane.setIntoCollideMask(BitMask32.bit(21)) v.collPlane = NodePath(collPlane) v.collPlane.reparentTo(v.grid) collPlane2 = CollisionNode('PerspGridCol2') collPlane2.addSolid(CollisionPlane(Plane(0, 0, -1, 0))) #oldBitmask = collPlane2.getIntoCollideMask() #collPlane2.setIntoCollideMask(BitMask32.bit(21)|oldBitmask) collPlane2.setIntoCollideMask(BitMask32.bit(21)) v.collPlane2 = NodePath(collPlane2) v.collPlane2.reparentTo(v.grid) #v.grid.gridBack.findAllMatches("**/+GeomNode")[0].setName("_perspViewGridBack") LE_showInOneCam(v.grid, 'persp') return v
def create_instance(self): self.create_buffer() # Water surface maker = CardMaker('water') maker.setFrame(self.x1, self.x2, self.y1, self.y2) self.waterNP = self.parent.instance.attachNewNode(maker.generate()) self.waterNP.setHpr(0, -90, 0) self.waterNP.setPos(0, 0, self.z) self.waterNP.setTransparency(TransparencyAttrib.MAlpha) self.waterNP.setShader(Shader.load(Shader.SL_GLSL, vertex=defaultDirContext.find_shader('water-vertex.glsl'), fragment=defaultDirContext.find_shader('water-fragment.glsl'))) self.waterNP.setShaderInput('wateranim', Vec4(0.03, -0.015, self.scale, 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, self.z + 1), Point3(0, 0, self.z)) planeNode = PlaneNode('waterPlane') planeNode.setPlane(self.waterPlane) # reflection texture, created in realtime by the 'water camera' tex0 = self.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) self.task = taskMgr.add(self.update, "waterTask")
def makeOrthographic(parent, name, campos): v = Viewport(name, parent) v.lens = OrthographicLens() v.lens.setFilmSize(30) v.camPos = campos v.camLookAt = Point3(0, 0, 0) v.grid = DirectGrid(parent=render) if name == 'left': v.grid.setHpr(0, 0, 90) collPlane = CollisionNode('LeftGridCol') collPlane.addSolid(CollisionPlane(Plane(1, 0, 0, 0))) collPlane.setIntoCollideMask(BitMask32.bit(21)) v.collPlane = NodePath(collPlane) v.collPlane.wrtReparentTo(v.grid) #v.grid.gridBack.findAllMatches("**/+GeomNode")[0].setName("_leftViewGridBack") LE_showInOneCam(v.grid, name) elif name == 'front': v.grid.setHpr(90, 0, 90) collPlane = CollisionNode('FrontGridCol') collPlane.addSolid(CollisionPlane(Plane(0, -1, 0, 0))) collPlane.setIntoCollideMask(BitMask32.bit(21)) v.collPlane = NodePath(collPlane) v.collPlane.wrtReparentTo(v.grid) #v.grid.gridBack.findAllMatches("**/+GeomNode")[0].setName("_frontViewGridBack") LE_showInOneCam(v.grid, name) else: collPlane = CollisionNode('TopGridCol') collPlane.addSolid(CollisionPlane(Plane(0, 0, 1, 0))) collPlane.setIntoCollideMask(BitMask32.bit(21)) v.collPlane = NodePath(collPlane) v.collPlane.reparentTo(v.grid) #v.grid.gridBack.findAllMatches("**/+GeomNode")[0].setName("_topViewGridBack") LE_showInOneCam(v.grid, name) return v
def __init__(self): ShowBase.__init__(self) self.disableMouse() self.camera.setPos(campos[0], campos[1], campos[2]) self.camera.lookAt(bcenter[0], bcenter[1], bcenter[2]) self.plane = Plane(Vec3(pvector[0], pvector[1], pvector[2]), Point3(bcenter[0], bcenter[1], bcenter[2])) taskMgr.add(self.__getMousePos, "_YourClass__getMousePos")
def __init__(self,manager,xml): self.surface = getWaterSurface(manager) self.surface.reparentTo(render) self.surface.hide(BitMask32.bit(1)) # Invisible to reflection camera (speedup) self.surface.hide(BitMask32.bit(2)) # Invisible to volumetric lighting camera (speedup) self.surface.hide(BitMask32.bit(3)) # Invisible to shadow cameras (speedup) self.surface.setShader(loader.loadShader(manager.get('paths').getConfig().find('shaders').get('path')+'/water.cg')) self.surface.setShaderInput('time', 0.0, 0.0, 0.0, 0.0) ntex = loader.loadTexture(manager.get('paths').getConfig().find('textures').get('path')+'/water-normal.png') ntex.setMinfilter(Texture.FTLinearMipmapLinear) self.surface.setShaderInput('normal', ntex) self.surface.setShaderInput('camera', base.cam) self.surface.setTransparency(TransparencyAttrib.MDual, 10) self.surface.setTwoSided(True) self.surface.setShaderInput('waveInfo', Vec4(0.4, 0.4, 0.4, 0)) self.surface.setShaderInput('param2', Vec4(-0.015,0.005, 0.05, 0.05)) self.surface.setShaderInput('param3', Vec4(0.7, 0.3, 0, 0)) self.surface.setShaderInput('param4', Vec4(2.0, 0.5, 0.5, 0.0)) #self.surface.setShaderInput('speed', Vec4(-.8, -.4, -.9, .3)) self.surface.setShaderInput('speed', Vec4(0.2, -1.2, -0.2, -0.7)) self.surface.setShaderInput('deepcolor', Vec4(0.0,0.3,0.5,1.0)) self.surface.setShaderInput('shallowcolor', Vec4(0.0,1.0,1.0,1.0)) self.surface.setShaderInput('reflectioncolor', Vec4(0.95,1.0,1.0,1.0)) self.surface.hide() self.wbuffer = base.win.makeTextureBuffer('water', 512, 512) self.wbuffer.setClearColorActive(True) self.wbuffer.setClearColor(base.win.getClearColor()) self.wcamera = base.makeCamera(self.wbuffer) if manager.get('sky') != None and manager.get('sky').model != None: self.sky = manager.get('sky').model.copyTo(self.wcamera) self.sky.setTwoSided(True) self.sky.setSz(self.sky, -1) self.sky.setClipPlaneOff(1) self.sky.show() self.sky.hide(BitMask32.bit(0)) # Hide for normal camera self.sky.hide(BitMask32.bit(2)) # Hide for volumetric lighting camera self.sky.hide(BitMask32.bit(3)) # Hide for shadow camera(s), if any else: self.sky = None self.wcamera.reparentTo(render) self.wcamera.node().setLens(base.camLens) self.wcamera.node().setCameraMask(BitMask32.bit(1)) self.surface.hide(BitMask32.bit(1)) wtexture = self.wbuffer.getTexture() wtexture.setWrapU(Texture.WMClamp) wtexture.setWrapV(Texture.WMClamp) wtexture.setMinfilter(Texture.FTLinearMipmapLinear) self.surface.setShaderInput('reflection', wtexture) self.wplane = Plane(Vec3(0, 0, 1), Point3(0, 0, 0)) self.wplanenp = render.attachNewNode(PlaneNode('water', self.wplane)) tmpnp = NodePath('StateInitializer') tmpnp.setClipPlane(self.wplanenp) tmpnp.setAttrib(CullFaceAttrib.makeReverse()) self.wcamera.node().setInitialState(tmpnp.getState()) #self.fog = Fog('UnderwaterFog') #self.fog.setColor(0.0,0.3,0.5) self.fogEnabled = False
def __init__(self): GameObject.__init__(self, Vec3(0, 0, 0), "Models/PandaChan/act_p3d_chan", { "stand" : "Models/PandaChan/a_p3d_chan_idle", "walk" : "Models/PandaChan/a_p3d_chan_run" }, 5, 10, "player") self.actor.getChild(0).setH(180) mask = BitMask32() mask.setBit(1) self.collider.node().setIntoCollideMask(mask) mask = BitMask32() mask.setBit(1) self.collider.node().setFromCollideMask(mask) base.pusher.addCollider(self.collider, self.actor) base.cTrav.addCollider(self.collider, base.pusher) self.lastMousePos = Vec2(0, 0) self.groundPlane = Plane(Vec3(0, 0, 1), Vec3(0, 0, 0)) self.ray = CollisionRay(0, 0, 0, 0, 1, 0) rayNode = CollisionNode("playerRay") rayNode.addSolid(self.ray) mask = BitMask32() mask.setBit(2) rayNode.setFromCollideMask(mask) mask = BitMask32() rayNode.setIntoCollideMask(mask) self.rayNodePath = render.attachNewNode(rayNode) self.rayQueue = CollisionHandlerQueue() base.cTrav.addCollider(self.rayNodePath, self.rayQueue) self.beamModel = loader.loadModel("Models/Misc/bambooLaser") self.beamModel.reparentTo(self.actor) self.beamModel.setZ(1.5) self.beamModel.setLightOff() self.beamModel.hide() self.damagePerSecond = -5.0 self.yVector = Vec2(0, 1) self.actor.loop("stand")
def makePlane(self, height): if not self.enabled: return self.clearPlane() # Reflection plane self.waterPlane = Plane(Vec3(0, 0, height), Point3(0, 0, height)) planeNode = PlaneNode('waterPlane') planeNode.setPlane(self.waterPlane) self.waterPlaneNP = render.attachNewNode(planeNode)
def getMousePlaneIntersect(self, mPos3Dref, normVec): mPos = base.mouseWatcherNode.getMouse() plane = Plane(normVec, self.grabModelNP.getPos()) nearPoint = Point3() farPoint = Point3() base.camLens.extrude(mPos, nearPoint, farPoint) if plane.intersectsLine(mPos3Dref, render.getRelativePoint(camera, nearPoint), render.getRelativePoint(camera, farPoint)): return True return False
def update(cls, task): # Reflection plane if settings.camera_at_origin: camera_offset = -cls.observer._local_position[2] + cls.z else: camera_offset = cls.z waterPlane = Plane(Vec3(0, 0, camera_offset + 1), Point3(0, 0, camera_offset)) # update matrix of the reflection camera if not settings.debug_lod_freeze and cls.watercamNP is not None: mc = base.camera.getMat() mf = waterPlane.getReflectionMat() cls.watercamNP.setMat(mc * mf) return task.cont
def __init__(self, cr): DistributedObject.__init__(self, cr) #self.model = loader.loadModel('environment') #self.model.setZ(0) #self.builder = Builder(self, "map.txt", "development") plane = CollisionPlane(Plane(Vec3(0, 0, 1), Point3(0, 0, 0))) cnode = CollisionNode('cnode') cnode.setIntoCollideMask(BitMask32.bit(1)) cnode.setFromCollideMask(BitMask32.bit(1)) cnode.addSolid(plane) self.planeNP = self.model.attachNewNode(cnode) self.planeNP.show() # Setup a traverser for the picking collisions self.picker = CollisionTraverser() # Setup mouse ray self.pq = CollisionHandlerQueue() # Create a collision Node pickerNode = CollisionNode('MouseRay') # set the nodes collision bitmask pickerNode.setFromCollideMask(BitMask32.bit(1)) # create a collision ray self.pickerRay = CollisionRay() # add the ray as a solid to the picker node pickerNode.addSolid(self.pickerRay) # create a nodepath with the camera to the picker node self.pickerNP = base.camera.attachNewNode(pickerNode) # add the nodepath to the base traverser self.picker.addCollider(self.pickerNP, self.pq) print "model loaded" #TODO: check how to load multiple levels and set players in specific levels! self.accept("mouse1", self.mouseClick)
class YourClass(ShowBase): def __init__(self): ShowBase.__init__(self) self.disableMouse() self.camera.setPos(campos[0], campos[1], campos[2]) self.camera.lookAt(bcenter[0], bcenter[1], bcenter[2]) self.plane = Plane(Vec3(pvector[0], pvector[1], pvector[2]), Point3(bcenter[0], bcenter[1], bcenter[2])) taskMgr.add(self.__getMousePos, "_YourClass__getMousePos") def __getMousePos(self, task): poslst = [] for mpos in (LPoint2f(-1, -1), LPoint2f(1, -1), LPoint2f(1, 1), LPoint2f(-1, 1)): pos3d = Point3() nearPoint = Point3() farPoint = Point3() base.camLens.extrude(mpos, nearPoint, farPoint) if self.plane.intersectsLine( pos3d, render.getRelativePoint(camera, nearPoint), render.getRelativePoint(camera, farPoint)): pass poslst.append(pos3d) global count count = count + 1 if count > 9: print_message(poslst) exit() else: return task.again
def update_trackplane(self): self.trackplane_cn.setSolid( 0, CollisionPlane( Plane( Point3(-self.base.cam.getMat().getRow3(1)), Point3(self.lookatpos_pdv3[0], self.lookatpos_pdv3[1], 0.0))))
def _initCollisions(self): self.collPlane = CollisionPlane(Plane(Vec3(0, 0, 1.0), Point3(0, 0, 10))) self.collPlane.setTangible(0) self.collNode = CollisionNode('fogPlane') self.collNode.setIntoCollideMask(OTPGlobals.FloorBitmask) self.collNode.addSolid(self.collPlane) self.collNodePath = self.root.attachNewNode(self.collNode) self.collNodePath.hide()
def __init__(self, name, spritesheet=None, sprite_size=None, hitbox_size=None, collision_mask=None, position=None, animations_speed=None): collision_mask = PLAYER_COLLISION_MASK super().__init__(name, spritesheet, sprite_size, hitbox_size, collision_mask, position, animations_speed) base.task_mgr.add(self.controls_handler, "controls handler") #the thing to track mouse position relatively to map. See attack handling #It probably could be better to move this thing to map func/class instead? #TODO self.ground_plane = Plane((0, 0, 1), (0, 0, 0))
def create_wall_collider(self, render, x_angle, y_angle, angle): wallSolid = CollisionPlane(Plane(Vec3(0, 0, 1), Point3(0, 0, 0))) wallNode = CollisionNode("wall") wallNode.addSolid(wallSolid) wall = render.attachNewNode(wallNode) wall.setX(x_angle * self.size / 2) wall.setY(y_angle * self.size / 2) wall.setHpr(angle, -90, 0)
def setup_interactiongeometries(self): """ set up collision rays, spheres, and planes for mouse manipulation :return: None author: weiwei date: 20161110 """ # create a trackball ray and set its bitmask to 8 # the trackball ray must be a subnode of cam since we will # transform the clicked point (in the view of the cam) to the world coordinate system # using the ray self.tracker_cn = CollisionNode("tracker") self.tracker_ray = CollisionRay() self.tracker_cn.addSolid(self.tracker_ray) self.tracker_cn.setFromCollideMask(BitMask32.bit(8)) self.tracker_cn.setIntoCollideMask(BitMask32.allOff()) self.tracker_np = self.base.cam.attachNewNode(self.tracker_cn) # create an inverted collision sphere and puts it into a collision node # its bitmask is set to 8, and it will be the only collidable object at bit 8 self.trackball_cn = CollisionNode("trackball") self.trackball_cn.addSolid( CollisionSphere(self.lookatpos_pdv3[0], self.lookatpos_pdv3[1], self.lookatpos_pdv3[2], self.camdist)) self.trackball_cn.setFromCollideMask(BitMask32.allOff()) self.trackball_cn.setIntoCollideMask(BitMask32.bit(8)) self.trackball_np = self.base.render.attachNewNode(self.trackball_cn) # self.trackball_np.show() # This creates a collision plane for mouse track self.trackplane_cn = CollisionNode("trackplane") self.trackplane_cn.addSolid( CollisionPlane( Plane( Point3(-self.base.cam.getMat().getRow3(1)), Point3(self.lookatpos_pdv3[0], self.lookatpos_pdv3[1], 0.0)))) self.trackplane_cn.setFromCollideMask(BitMask32.allOff()) self.trackplane_cn.setIntoCollideMask(BitMask32.bit(8)) self.trackplane_np = self.base.render.attachNewNode(self.trackplane_cn) # self.trackplane_np.show() # creates a traverser to do collision testing self.ctrav = CollisionTraverser() # creates a queue type handler to receive the collision event info self.chandler = CollisionHandlerQueue() # register the ray as a collider with the traverser, # and register the handler queue as the handler to be used for the collisions. self.ctrav.addCollider(self.tracker_np, self.chandler) # create a pickerray self.picker_cn = CollisionNode('picker') self.picker_ray = CollisionRay() self.picker_cn.addSolid(self.picker_ray) self.picker_cn.setFromCollideMask(BitMask32.bit(7)) self.picker_cn.setIntoCollideMask(BitMask32.allOff()) self.picker_np = self.base.cam.attachNewNode(self.picker_cn) self.ctrav.addCollider(self.picker_np, self.chandler)
def __init__(self, root, loader, show_base): ''' Main scene class @param root: root node for the scene @param loader: models loader @param show_base: link to the ShowBase exemplar, i.e. base or app, which inherited from ShowBase @param path_dict: dictionary with pathes to search resources (sounds, meshes, images, shaders) type:path ''' self.root = root self.loader = loader self.show_base = show_base self.path_dict = { 'sounds': 'res', 'meshes': 'res', 'images': 'res', 'materials': 'res' } # Raw data, which should loaded from JSON file self.data_dict = { 'objects': {}, 'assets': {}, 'scene': {}, 'materials': {} } # Data after passing through import extension strored in # variables below this comment self.objects = {} self.lights = {} self.sounds = {} self.cameras = {} self.textures = {} self.meshes = {} # Container for different options which can be used by extensions self.flags = {} # Builtin variables self._current_cam_number = 0 self._level_plane = Plane(Vec3(0, 0, 1), Point3(0, 0, 0))
def enterDeploy(self): self.parent.sgm = SceneGraph(self.parent) self.parent.sgm.loadLevel(self.parent.level) self.parent.sgm.initLights() self.parent.camera = AppCamera(self.parent, 20, 20) self.parent.deploy_dict = {} for idx, l in enumerate(self.parent.level._deploy): for idy, val in enumerate(l): if str(val) == self.parent.player_id: self.parent.deploy_dict[(idx, idy)] = None self.parent.sgm.showDeployTiles() self.parent.plane = Plane(Vec3(0, 0, 1), Point3(0, 0, utils.GROUND_LEVEL)) self.parent.accept('mouse1', self.parent.deployUnit) self.parent.accept('g', self.parent.endDeploy) self.parent.deploySquadScreen()
def add_border_walls(self): '''Attaching invisible walls to map's borders, to avoid falling off map''' log.debug("Adding invisible walls to collide with on map's borders") wall_coordinates = [ ((self.map_size[0], 0, 0), (self.map_size[1], 0, 0)), ((-self.map_size[0], 0, 0), (-self.map_size[1], 0, 0)), ((0, self.map_size[2], 0), (0, self.map_size[3], 0)), ((0, -self.map_size[2], 0), (0, -self.map_size[3], 0)) ] for sizes in wall_coordinates: wall_node = CollisionNode("wall") #it looks like without adding node to pusher (we dont need that there), #masks wont work. Thus for now I wont use them, as defaults seem to work #wall_node.set_collide_mask(BitMask32(shared.WALLS_COLLISION_MASK)) wall_node.add_solid(CollisionPlane(Plane(*sizes))) wall = render.attach_new_node(wall_node)
def load(self): backgroundGui = loader.loadModel( 'phase_5/models/cogdominium/tt_m_gui_csa_flyThru.bam') self.bg = backgroundGui.find('**/background') self.chatBubble = backgroundGui.find('**/chatBubble') self.chatBubble.setScale(6.5, 6.5, 7.3) self.chatBubble.setPos(0.32, 0, -0.78) self.chatBubble.reparentTo(aspect2d) self.frame = DirectFrame(geom=self.bg, relief=None, pos=(0.2, 0, -0.6667)) self.gameTitleText = DirectLabel( parent=self.frame, text=TheGloriousGameLocalizer.ArenaGameTitle, scale=1, text_align=TextNode.ACenter, text_fg=(1.0, 0.33, 0.33, 1.0), pos=DialogueTitleTextPos, relief=None) self.chatBubble.wrtReparentTo(self.frame) self.frame.hide() self.FlippyToon = ToonDNA.ToonDNA('flippy') self.FlippyToon.createFlippy() Toon.loadModels() ToonHead.preloadToonHeads() self.toonHead = Toon.Toon() #self.toonHead.preloadToonHeads() self.toonHead.generateToon() #self.makeSuit('bw') self.toonHead.getGeomNode().setDepthWrite(1) self.toonHead.getGeomNode().setDepthTest(1) self.toonHead.loop('neutral') self.toonHead.setPosHprScale(-0.73, 0, -1.27, 180, 0, 0, 0.18, 0.18, 0.18) self.toonHead.reparentTo(hidden) self.toonHead.startBlink() self.clipPlane = self.toonHead.attachNewNode(PlaneNode('clip')) self.clipPlane.node().setPlane(Plane(0, 0, 1, 0)) self.clipPlane.setPos(0, 0, 2.45) self._toonDialogueSfx = loader.loadSfx( 'phase_3.5/audio/dial/AV_dog_long.ogg') self._camHelperNode = NodePath('CamHelperNode') self._camHelperNode.reparentTo(render)
def createGuiObjects(self): self.dayButton = DirectButton(parent=self.dayButtonLocator, image=self.selectedFrame, relief=None, command=self.__clickedOnDay, pressEffect=1, rolloverSound=None, clickSound=None) self.numberWidget = DirectLabel(parent=self.numberLocator, relief=None, text=str(self.myDate.day), text_scale=0.04, text_align=TextNode.ACenter, text_font=ToontownGlobals.getInterfaceFont(), text_fg=Vec4(110 / 255.0, 126 / 255.0, 255 / 255.0, 1)) self.attachMarker(self.numberLocator) self.listXorigin = 0 self.listFrameSizeX = self.scrollBottomRightLocator.getX() - self.scrollLocator.getX() self.scrollHeight = self.scrollLocator.getZ() - self.scrollBottomRightLocator.getZ() self.listZorigin = self.scrollBottomRightLocator.getZ() self.listFrameSizeZ = self.scrollLocator.getZ() - self.scrollBottomRightLocator.getZ() self.arrowButtonXScale = 1 self.arrowButtonZScale = 1 self.itemFrameXorigin = 0 self.itemFrameZorigin = 0 self.buttonXstart = self.itemFrameXorigin + 0.21 self.gui = loader.loadModel('phase_3.5/models/gui/friendslist_gui') buttonOffSet = -0.01 incButtonPos = (0.0, 0, 0) decButtonPos = (0.0, 0, 0) itemFrameMinZ = self.listZorigin itemFrameMaxZ = self.listZorigin + self.listFrameSizeZ arrowUp = self.find('**/downScroll_up') arrowDown = self.find('**/downScroll_down') arrowHover = self.find('**/downScroll_hover') self.scrollList = DirectScrolledList(parent=self.scrollLocator, relief=None, pos=(0, 0, 0), incButton_image=(arrowUp, arrowDown, arrowHover, arrowUp), incButton_relief=None, incButton_scale=(self.arrowButtonXScale, 1, self.arrowButtonZScale), incButton_pos=incButtonPos, incButton_image3_color=Vec4(1, 1, 1, 0.2), decButton_image=(arrowUp, arrowDown, arrowHover, arrowUp), decButton_relief=None, decButton_scale=(self.arrowButtonXScale, 1, -self.arrowButtonZScale), decButton_pos=decButtonPos, decButton_image3_color=Vec4(1, 1, 1, 0.2), itemFrame_pos=(self.itemFrameXorigin, 0, -0.03), numItemsVisible=4, incButtonCallback=self.scrollButtonPressed, decButtonCallback=self.scrollButtonPressed) itemFrameParent = self.scrollList.itemFrame.getParent() self.scrollList.incButton.reparentTo(self.scrollDownLocator) self.scrollList.decButton.reparentTo(self.scrollUpLocator) arrowUp.removeNode() arrowDown.removeNode() arrowHover.removeNode() clipper = PlaneNode('clipper') clipper.setPlane(Plane(Vec3(-1, 0, 0), Point3(0.23, 0, 0))) clipNP = self.scrollList.component('itemFrame').attachNewNode(clipper) self.scrollList.component('itemFrame').setClipPlane(clipNP) return
def __init__(self, world, app): self.world = world self.app = app self.picker = app.loader.loadModel('media/models/picked.egg') self.picker.reparentTo(app.render) # shader = Shader.load(Shader.SLGLSL, 'media/shaders/vertex.glsl', 'media/shaders/flat.glsl') # self.picker.setShader(shader) self.picker.setShaderInput('color', Vec4(0.3, 0.3, 1.0, 0.5)) self.picking_planes = [ Plane(Vec3(0, 0, 1), Point3(0, 0, z + 1)) for z in self.world.zlevels() ] self.picked = None self.mouse = app.mouseWatcherNode self.constraint = BlockPicker.SURFACE self.slice = None self.addTask(self.pick_block, "Pick block") self.accept('slice-changed', self.slice_changed)
def add_borders(self): """Attach invisible walls to map's borders, to avoid falling off map""" log.debug("Adding invisible walls to collide with on map's borders") wall_coordinates = [ ((self.map_size[0], 0, 0), (self.map_size[1], 0, 0)), ((-self.map_size[0], 0, 0), (-self.map_size[1], 0, 0)), ((0, self.map_size[2], 0), (0, self.map_size[3], 0)), ((0, -self.map_size[2], 0), (0, -self.map_size[3], 0)), ] for sizes in wall_coordinates: wall_node = CollisionNode(shared.game_data.border_category) # it looks like without adding node to pusher (we dont need that there), # masks wont work. Thus for now I wont use them, as defaults seem to work # wall_node.set_collide_mask(BitMask32(shared.WALLS_COLLISION_MASK)) wall_node.add_solid(CollisionPlane(Plane(*sizes))) wall = self.scene.attach_new_node(wall_node) # adding tag with wall's coordinations, so it will be possible to # push entities back if these collide with wall # because calling .get_pos() will return LPoint3f(0,0,0) wall_node.set_python_tag("position", sizes)
class YourClass(ShowBase): def __init__(self): ShowBase.__init__(self) self.disableMouse() self.camera.setPos(campos[0], campos[1], campos[2]) self.camera.lookAt(bcenter[0], bcenter[1], bcenter[2]) self.plane = Plane(Vec3(pvector[0], pvector[1], pvector[2]), Point3(bcenter[0], bcenter[1], bcenter[2])) taskMgr.add(self.__getMousePos, "_YourClass__getMousePos") def __getMousePos(self, task): coords = [] for pixel in pixels: mpos = LPoint2f((pixel[0]-250)/250, (250-pixel[1])/250) pos3d = Point3() nearPoint = Point3() farPoint = Point3() base.camLens.extrude(mpos, nearPoint, farPoint) if self.plane.intersectsLine(pos3d, render.getRelativePoint(camera, nearPoint), render.getRelativePoint(camera, farPoint)): pass coords.append([pos3d[0], pos3d[1], pos3d[2]]) coordls['coord'] = coords with open(filename, "w") as lujs: json.dump(coordls, lujs) exit()
class WaterManager: def __init__(self): self.enabled = True sMgr = CIGlobals.getSettingsMgr() reso = sMgr.ReflectionQuality[sMgr.getSetting("refl").getValue()] if reso == 0: self.enabled = False return self.waterPlaneNP = None self.waterNodes = [] # Buffer and reflection camera buffer = base.win.makeTextureBuffer('waterBuffer', reso, reso) buffer.setClearColor(Vec4(0, 0, 0, 1)) cfa = CullFaceAttrib.makeReverse() rs = RenderState.make(cfa) self.watercamNP = base.makeCamera(buffer) self.watercamNP.reparentTo(render) self.makePlane(0.0) cam = self.watercamNP.node() cam.getLens().setFov(base.camLens.getFov()) cam.getLens().setNear(1) cam.getLens().setFar(5000) cam.setInitialState(rs) cam.setTagStateKey('Clipped') self.ts0 = TextureStage("tex_0") self.tex0 = buffer.getTexture() self.tex0.setWrapU(Texture.WMClamp) self.tex0.setWrapV(Texture.WMClamp) self.ts1 = TextureStage("tex_1") self.waterTex = loader.loadTexture('phase_3/maps/water_distort.png') self.waterQuad = None self.waterStage = TextureStage("waterStage") image0 = OnscreenImage(image=self.tex0, scale=0.3, pos=(-0.5, 0, 0.7)) image1 = OnscreenImage(image=waterTex, scale=0.3, pos=(0.5, 0, 0.7)) taskMgr.add(self.update, "waterTask") def makePlane(self, height): if not self.enabled: return self.clearPlane() # Reflection plane self.waterPlane = Plane(Vec3(0, 0, height), Point3(0, 0, height)) planeNode = PlaneNode('waterPlane') planeNode.setPlane(self.waterPlane) self.waterPlaneNP = render.attachNewNode(planeNode) def clearPlane(self): if not self.enabled: return if self.waterPlaneNP: self.waterPlaneNP.removeNode() self.waterPlaneNP = None def addWaterNode(self, node, height): if not self.enabled: return self.waterNodes.append(node) node.setTransparency(TransparencyAttrib.MAlpha) node.setTexture(ts0, self.tex0) node.setTexture(ts1, self.waterTex) node.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 node.setShaderInput('waterdistort', Vec4(0.4, 4.0, 0.25, 0.45)) node.setShaderInput('time', 0) node.setShader(loader.loadShader("phase_3/models/shaders/water.sha")) node.projectTexture(self.waterStage, self.tex0, self.watercamNP) self.makePlane(height) def clearWaterNodes(self): if not self.enabled: return for node in self.waterNodes: if not node.isEmpty(): node.setShaderOff(1) node.setTextureOff(1) self.waterNodes = [] self.clearPlane() def update(self, task): if not self.enabled: return # update matrix of the reflection camera mc = base.camera.getMat() mf = self.waterPlane.getReflectionMat() self.watercamNP.setMat(mc * mf) for node in self.waterNodes: if not node.isEmpty(): node.setShaderInput("time", task.time) return task.cont
def __init__(self): # Level model self.level = loader.loadModel("Level") self.key = loader.loadModel("Key") self.artifact = loader.loadModel("Artifact") """Logic connections INFO Switch.000 opens door Wooden_Door_Basic Switch.001-4 in correct order open Boulder_Door Key opens Boulder_Door.001 Switch.005 opens Boulder_Door.002 Defeating Golem opens Wooden_Door_Basic.001 """ random.seed() self.switchLogic = { "Switch.000":"Wooden_Door_Basic", "Switch.001":"ORDER1", "Switch.002":"ORDER1", "Switch.003":"ORDER1", "Switch.004":"ORDER1", "ORDER1":"Boulder_Door", "Switch.005":"Boulder_Door.002"} self.switchOrderLogic = {} # possible switch activation orders self.switchOrders = [ [_("First the highest, the second highest comes third and the lowest before the last."),[4,1,3,2]], [_("The second lowest is the first then lower, highest and finally the remaining."),[2,1,4,3]], [_("Before the last comes the second lowest, the first is the second highest followed by the lowest."),[3,1,2,4]] ] self.enemyLogic = {"Golem":"Wooden_Door_Basic.001"} self.KeyDoorLogic = ["Boulder_Door.001"] self.chestLogic = { "Box_long_looseLid.000":"GET_Key", "Box_long_looseLid.001":"GET_Artifact"} self.activeSwitch = None self.activePostsign = None self.activeBox = None self.activeDoor = None self.numKeys = 0 # Set up all the little details if base.particleMgrEnabled: self.initTorchParticles() self.initSwitches() self.initSwitchSigns() self.initPostsigns() self.initDoors() self.initKeyDoors() self.initChests() self.initHearts() plane = self.level.find("**/Deathplane") deathplane = CollisionPlane(Plane((0, 0, 1), (0,0,-1))) deathplane.setTangible(False) self.deathplaneColNP = render.attachNewNode(CollisionNode('deathplane')) self.deathplaneColNP.node().addSolid(deathplane) self.accept("playerCollision-in-deathplane", lambda args: base.messenger.send("player-die"))
def __init__(self,base,Golog, folder_path = None, parent = None): # Set up basic attributes self.base = base self.golog = Golog self.bools = {'textboxes':True} self.buttons = dict() self.window_tasks = dict() self.bt = None self.mw = None self.listener = DirectObject() self.folder_path = folder_path #absolute path of golog folder '/path/to/golog/folder' if self.folder_path: self.file_path = os.path.abspath(self.folder_path + '/' + self.golog.label+ '.golog') autosave = True self.has_window = False self.parent = parent #for autosaving up to original golog self.reset = self.basic_reset self.garbage = [] #list of deleted math_data/graphics_data etc. #create a 2d rende self.render2d = NodePath('2d render') self.camera2D = self.render2d.attachNewNode(Camera('2d Camera')) self.camera2D.setDepthTest(False) self.camera2D.setDepthWrite(False) lens = OrthographicLens() lens.setFilmSize(2, 2) lens.setNearFar(-1000, 1000) self.camera2D.node().setLens(lens) # make a dictionary of mode_heads in the underlying golog if hasattr(self.golog,'mode_heads'): m = 0 while m in self.golog.mode_heads.keys(): m+=1 #get smallest unused mode_head index self.index = m self.label = self.golog.label+"_mode_head_"+str(self.index) self.golog.mode_heads[self.index] = self else: self.golog.mode_heads = dict() self.index = 0 self.label = self.golog.label+"_mode_head_"+ str(self.index) self.golog.mode_heads[self.index] = self ########## ### set up collision handling ### self.queue = CollisionHandlerQueue() ### set up selection tools self.create_list = [[],[]] #select nodes and add to create_list in order to create higher simplecies self.bools = {'selecter':False,'textboxes':True,'shift_clicked':False} #some bools that will be usefull self.dict = {'shift_pt':[None,None]} # set up mouse picker self.pickerNode = CollisionNode('mouseRay') self.pickerNP = self.golog.camera.attachNewNode(self.pickerNode) #attach collision node to camera self.pickerRay = CollisionRay() self.pickerNode.addSolid(self.pickerRay) self.pickerNode.set_into_collide_mask(0) #so that collision rays don't collide into each other if there are two mode_heads self.golog.cTrav.addCollider(self.pickerNP,self.queue) #send collisions to self.queue # set up plane for picking self.planeNode = self.golog.render.attachNewNode("plane") self.planeNode.setTag("mode_head",self.label) # tag to say it belongs to this mode_head self.planeNode.setTag("mode_node", 'plane') self.planeFromObject = self.planeNode.attachNewNode(CollisionNode("planeColNode")) self.planeFromObject.node().addSolid(CollisionPlane(Plane(Vec3(0,-1,0),Point3(0,0,0)))) self.plane = self.planeFromObject.node().getSolid(0) ### # set up preview text self.textNP = self.render2d.attachNewNode(TextNode('text node')) self.textNP.setScale(.2) self.textNP.setPos(-1,0,0) self.textNP.show() #set up dragging info self.grabbed_dict = dict() self.drag_dict = dict() #a mapping from selected nodes to their original positions for dragging self.mouse_down_loc = (0,0,0) self.lowest_level = 3
def generateWater(self, style): print "Generate Water:", self.waterXMin, self.waterXMax, self.waterYMin, self.waterYMax '''Generates water style 0: blue card style 1: reflective card style 2: reflective card with shaders ''' self.waterHeight = 22.0 if self.water: self.water.removeNode() if style is 0: cm = CardMaker("water") #cm.setFrame(-1, 1, -1, 1) cm.setFrame(self.waterXMin, self.waterXMax, self.waterYMin, self.waterYMax) cm.setColor(0, 0, 1, 0.9) self.water = render.attachNewNode(cm.generate()) if self.waterYMax > self.waterXMax: size = self.waterYMax else: size = self.waterXMax self.water.lookAt(0, 0, -1) self.water.setZ(self.waterHeight) messenger.send('makePickable', [self.water]) elif style is 1: # From Prosoft's super awesome terrain demo cm = CardMaker("water") #cm.setFrame(-1, 1, -1, 1) cm.setFrame(self.waterXMin, self.waterXMax, self.waterYMin, self.waterYMax) self.water = render.attachNewNode(cm.generate()) if self.waterYMax > self.waterXMax: size = self.waterYMax else: size = self.waterXMax #self.water.setScale(size) self.water.lookAt(0, 0, -1) self.water.setZ(self.waterHeight) self.water.setShaderOff(1) self.water.setLightOff(1) self.water.setAlphaScale(0.5) self.water.setTransparency(TransparencyAttrib.MAlpha) wbuffer = base.win.makeTextureBuffer("water", 512, 512) wbuffer.setClearColorActive(True) wbuffer.setClearColor(base.win.getClearColor()) self.wcamera = base.makeCamera(wbuffer) self.wcamera.reparentTo(render) self.wcamera.node().setLens(base.camLens) self.wcamera.node().setCameraMask(BitMask32.bit(1)) self.water.hide(BitMask32.bit(1)) wtexture = wbuffer.getTexture() wtexture.setWrapU(Texture.WMClamp) wtexture.setWrapV(Texture.WMClamp) wtexture.setMinfilter(Texture.FTLinearMipmapLinear) self.wplane = Plane(Vec3(0, 0, 1), Point3(0, 0, self.water.getZ())) wplanenp = render.attachNewNode(PlaneNode("water", self.wplane)) tmpnp = NodePath("StateInitializer") tmpnp.setClipPlane(wplanenp) tmpnp.setAttrib(CullFaceAttrib.makeReverse()) self.wcamera.node().setInitialState(tmpnp.getState()) self.water.projectTexture(TextureStage("reflection"), wtexture, self.wcamera) messenger.send('makePickable', [self.water]) elif style is 2: # From Clcheung just as super awesome demomaster self.water_level = Vec4(0.0, 0.0, self.waterHeight, 1.0) self.water = water.WaterNode(self.waterXMin, self.waterYMin, self.waterXMax, self.waterYMax, self.water_level.getZ()) self.water.setStandardControl() self.water.changeParams(None) wl = self.water_level wl.setZ(wl.getZ() - 0.05) #root.setShaderInput('waterlevel', self.water_level) render.setShaderInput('time', 0) messenger.send('makePickable', [self.water.waterNP])
def __init__(self): # Create a traverser that Panda3D will automatically use every frame. base.cTrav = CollisionTraverser() # Create a handler for the events. self.collHandler = CollisionHandlerQueue() # Define a few bitmasks for use. # Teaching the concepts of bitmasks is out of the scope of this sample. # This just shows a practical application of bitmasks. goodMask = BitMask32(0x1) badMask = BitMask32(0x2) floorMask = BitMask32(0x4) # Make a list of different combinations of the masks for later use. # We will switch between these masks later on. self.maskList = [["floor", floorMask], ["smiley", goodMask], ["frowney", badMask], ["characters", goodMask | badMask], ["smiley and floor", goodMask | floorMask], ["frowney and floor", badMask | floorMask], ["all", floorMask | goodMask | badMask]] # This keeps track of where we are in the dictionary. self.maskPos = 0 # First we create a floor collision plane. floorNode = base.render.attachNewNode("Floor NodePath") # Create a collision plane solid. collPlane = CollisionPlane(Plane(Vec3(0, 0, 1), Point3(0, 0, 0))) # Call our function that creates a nodepath with a collision node. floorCollisionNP = self.makeCollisionNodePath(floorNode, collPlane) # Get the collision node the Nodepath is referring to. floorCollisionNode = floorCollisionNP.node() # The floor is only an into object, so just need to set its into mask. floorCollisionNode.setIntoCollideMask(floorMask) # Create a collision sphere. Since the models we'll be colliding # are basically the same we can get away with just creating one # collision solid and adding the same solid to both collision nodes. collSphere = CollisionSphere(0, 0, 0, 1.5) # Make a smiley. smiley = base.loader.loadModel('smiley') smiley.reparentTo(base.render) smiley.setPos(-3, 3, 3) smiley.setName("Smiley") smileyCollisionNP = self.makeCollisionNodePath(smiley, collSphere) # Like with the floor plane we need to set the into mask. # Here we shortcut getting the actual collision node. smileyCollisionNP.node().setIntoCollideMask(goodMask) # Make a frowney. frowney = base.loader.loadModel('frowney') frowney.reparentTo(base.render) frowney.setPos(-3, 3, 7) frowney.setName("Frowney") frowneyCollisionNP = self.makeCollisionNodePath(frowney, collSphere) # Use the the Nodepath.setCollideMask() function to set the into mask. # setCollideMask() sets the into mask of all child nodes to the given # mask. frowneyCollisionNP.setCollideMask(badMask) # Note that we don't call setCollideMask() from frowney because this # will turn the frowney mesh into a collision mesh which is unwanted. # Note that we didn't set a from collide mask for previous objects # since we're not adding them to the traverser as from objects. # Make a collision ray that passes through all of the objects. self.pointerNode = base.render.attachNewNode("Main Collider") self.pointerNode.setPos(-3, 3, 10) # Create a ray collision solid that points downwards. raySolid = CollisionRay(0, 0, 0, 0, 0, -1) mainColNP = self.makeCollisionNodePath(self.pointerNode, raySolid) self.mainColNode = mainColNP.node() # Set a from collide mask for this ray so that we can selectively # collide against the other objects. self.mainColNode.setFromCollideMask(self.maskList[self.maskPos][1]) base.cTrav.addCollider(mainColNP, self.collHandler) # Set up the camera. base.disableMouse() base.camera.setPos(20, -20, 5) base.camera.lookAt(0, 0, 5) # Debug mode for collision traversers; shows collisions visually. base.cTrav.showCollisions(base.render) # Setup the title text. collideText = self.maskList[self.maskPos][0] self.title = OnscreenText(text="Colliding with %s" % (collideText), mayChange=True, pos=(0.3, 0), align=TextNode.ALeft, fg=(1, 1, 1, 1)) OnscreenText(text="Press space to change collision mask", pos=(0, 0.8), fg=(1, 1, 1, 1)) # Set space to change the from collision mask of the collision ray. base.accept("space", self.switchCollisionMask)
def __init__(self, x1, y1, x2, y2, z, scale, parent): # Water surface maker = CardMaker('water') maker.setFrame(x1, x2, y1, y2) self.waterNP = parent.instance.attachNewNode(maker.generate()) self.waterNP.setHpr(0, -90, 0) self.waterNP.setPos(0, 0, z) self.waterNP.setTransparency(TransparencyAttrib.MAlpha) self.waterNP.setShader( Shader.load( Shader.SL_GLSL, vertex=defaultDirContext.find_shader('water-vertex.glsl'), fragment=defaultDirContext.find_shader('water-fragment.glsl'))) self.waterNP.setShaderInput('wateranim', Vec4(0.03, -0.015, scale, 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) if self.watercamNP is None: # Buffer and reflection camera WaterNode.buffer = base.win.makeTextureBuffer( 'waterBuffer', 512, 512) self.buffer.setClearColor(Vec4(0, 0, 0, 1)) cfa = CullFaceAttrib.makeReverse() rs = RenderState.make(cfa) WaterNode.watercamNP = base.makeCamera(self.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 = self.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) self.task = taskMgr.add(self.update, "waterTask")
def __init__(self, name, size=10000, resolution=1024): """Arguments: size -- Edge length of the water square. resolution -- Texture size of the rendered reflection buffer. """ # Uncomment to see the output of the refclection buffer. base.bufferViewer.toggleEnable() AssetBase.__init__(self) self.name = name self.cm = CardMaker("water surface") self.cm.setFrame(-0.5 * size, 0.5 * size, -0.5 * size, 0.5 * size) self.cm.setHasUvs(True) self.node = NodePath(self.cm.generate()) self.node.setP(self.node, -90) self.node.flattenLight() self.node.hide(BitMask32.bit(1)) #self.node.setTwoSided(True) self.node.setShaderOff() # size of one texture tile in meters self.tex_size = 100.0 diffuse = TexturePool.loadTexture("textures/water.diffuse.png") diffuse.setWrapU(Texture.WMRepeat) diffuse.setWrapV(Texture.WMRepeat) diffuse.setMinfilter(Texture.FTLinearMipmapLinear) diffuse.setMagfilter(Texture.FTLinearMipmapLinear) self.diffuse_stage = TextureStage("diffuse") self.diffuse_stage.setSort(2) self.node.setTexture(self.diffuse_stage, diffuse) self.node.setTexScale(self.diffuse_stage, size / self.tex_size, size / self.tex_size) # Reflection camera renders to 'buffer' which is projected onto the # water surface. buffer = base.win.makeTextureBuffer("water reflection", resolution, resolution) buffer.setClearColor(Vec4(0, 0, 0, 1)) self.refl_cam = base.makeCamera(buffer) self.refl_cam.reparentTo(self.node) self.refl_cam.node().setCameraMask(BitMask32.bit(1)) self.refl_cam.node().getLens().setFov(base.camLens.getFov()) self.refl_cam.node().getLens().setNearFar(1, 100000) plane = PlaneNode("water culling plane", Plane(Vec3(0, 0, 1), Point3(0, 0, 0))) cfa = CullFaceAttrib.makeReverse() cpa = ClipPlaneAttrib.make(PlaneNode.CEVisible, plane) rs = RenderState.make(cfa, cpa) self.refl_cam.node().setInitialState(rs) reflection = buffer.getTexture() reflection.setMinfilter(Texture.FTLinear) reflection.setMagfilter(Texture.FTLinear) self.refl_stage = TextureStage("reflection") self.refl_stage.setSort(1) self.node.projectTexture(self.refl_stage, reflection, base.cam) self.node.setTexture(self.refl_stage, reflection) # Blend between diffuse and reflection. self.diffuse_stage.setColor(VBase4(1, 1, 1, 0.2)) # opacity of 20% self.diffuse_stage.setCombineRgb( TextureStage.CMInterpolate, TextureStage.CSTexture, TextureStage.COSrcColor, TextureStage.CSPrevious, TextureStage.COSrcColor, TextureStage.CSConstant, TextureStage.COSrcAlpha) self.addTask(self.update, name="water update", sort=1, taskChain="world")