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")
