def __init__(self, root_nodepath, world):
self.world = BulletWorld()
self.world.setGravity((0, 0, -9.81))
self._timestep = 1 / world.tick_rate
# # Seems that this does not function
# on_contact_added = PythonCallbackObject(self._on_contact_added)
# self.world.set_contact_added_callback(on_contact_added)
# on_filter = PythonCallbackObject(self._filter_collision)
# self.world.set_filter_callback(on_filter)
self.listener = DirectObject()
self.listener.accept('bullet-contact-added', self._on_contact_added)
self.listener.accept('bullet-contact-destroyed', self._on_contact_removed)
self.tracked_contacts = defaultdict(int)
self.existing_collisions = set()
# Debugging info
debug_node = BulletDebugNode('Debug')
debug_node.showWireframe(True)
debug_node.showConstraints(True)
debug_node.showBoundingBoxes(False)
debug_node.showNormals(False)
# Add to world
self.debug_nodepath = root_nodepath.attachNewNode(debug_node)
self.world.set_debug_node(debug_node)
self.debug_nodepath.show()
def __init__(self):
debugNode = BulletDebugNode('DebugNode')
debugNode.showWireframe(True)
debugNode.showConstraints(True)
debugNode.showBoundingBoxes(True)
debugNode.showNormals(True)
self.debugNP = render.attachNewNode(debugNode)
def __init__(self, scene, suncgDatasetRoot=None, debug=False, objectMode='box',
agentRadius=0.1, agentHeight=1.6, agentMass=60.0, agentMode='capsule'):
super(Panda3dBulletPhysics, self).__init__()
self.__dict__.update(scene=scene, suncgDatasetRoot=suncgDatasetRoot, debug=debug, objectMode=objectMode,
agentRadius=agentRadius, agentHeight=agentHeight, agentMass=agentMass, agentMode=agentMode)
if suncgDatasetRoot is not None:
self.modelCatMapping = ModelCategoryMapping(os.path.join(
suncgDatasetRoot, "metadata", "ModelCategoryMapping.csv"))
else:
self.modelCatMapping = None
self.bulletWorld = BulletWorld()
self.bulletWorld.setGravity(Vec3(0, 0, -9.81))
if debug:
debugNode = BulletDebugNode('physic-debug')
debugNode.showWireframe(True)
debugNode.showConstraints(False)
debugNode.showBoundingBoxes(True)
debugNode.showNormals(False)
self.debugNodePath = self.scene.scene.attachNewNode(debugNode)
self.debugNodePath.show()
self.bulletWorld.setDebugNode(debugNode)
else:
self.debugNodePath = None
self._initLayoutModels()
self._initAgents()
self._initObjects()
self.scene.worlds['physics'] = self
def __init__(self):
debugNode = BulletDebugNode('DebugNode')
debugNode.showWireframe(True)
debugNode.showConstraints(True)
debugNode.showBoundingBoxes(True)
debugNode.showNormals(True)
self.debugNP = render.attachNewNode(debugNode)
def __init__(self, base, objpath, bdebug = False):
self.base = base
self.smiley = loader.loadModel(objpath)
self.smileyCount = 0
self.setupBullet()
self.addGround()
# self.addWalls()
self.partlist = []
taskMgr.doMethodLater(.1, self.addSmiley, "AddSmiley")
taskMgr.add(self.updateBlt, "UpdateBlt")
if bdebug:
debugNode = BulletDebugNode('Debug')
debugNode.showWireframe(True)
debugNode.showConstraints(True)
debugNode.showBoundingBoxes(False)
debugNode.showNormals(False)
bullcldrnp = self.base.render.attachNewNode("bulletcollider")
debugNP = bullcldrnp.attachNewNode(debugNode)
debugNP.show()
self.bltWorld.setDebugNode(debugNP.node())
def __init__(self, base, objpath, bdebug=False):
self.base = base
self.smiley = loader.loadModel(objpath)
self.smileyCount = 0
self.setupBullet()
self.addGround()
# self.addWalls()
self.partlist = []
taskMgr.doMethodLater(.1, self.addSmiley, "AddSmiley")
taskMgr.add(self.updateBlt, "UpdateBlt")
if bdebug:
debugNode = BulletDebugNode('Debug')
debugNode.showWireframe(True)
debugNode.showConstraints(True)
debugNode.showBoundingBoxes(False)
debugNode.showNormals(False)
bullcldrnp = self.base.render.attachNewNode("bulletcollider")
debugNP = bullcldrnp.attachNewNode(debugNode)
debugNP.show()
self.bltWorld.setDebugNode(debugNP.node())
def __init__(self):
self.register_signals()
self.world = BulletWorld()
self.world.setGravity((0, 0, -9.81))
# # Seems that this does not function
# on_contact_added = PythonCallbackObject(self._on_contact_added)
# self.world.set_contact_added_callback(on_contact_added)
# on_filter = PythonCallbackObject(self._filter_collision)
# self.world.set_filter_callback(on_filter)
self.listener = DirectObject()
self.listener.accept('bullet-contact-added', self._on_contact_added)
self.listener.accept('bullet-contact-destroyed', self._on_contact_removed)
debug_node = BulletDebugNode('Debug')
debug_node.showWireframe(True)
debug_node.showConstraints(True)
debug_node.showBoundingBoxes(False)
debug_node.showNormals(False)
self.debug_nodepath = render.attachNewNode(debug_node)
self.world.set_debug_node(debug_node)
self.debug_nodepath.show()
def setup_debug(self):
debug_node = BulletDebugNode('Debug')
debug_node.showWireframe(True)
debug_node.showConstraints(True)
debug_node.showBoundingBoxes(True)
debug_node.showNormals(True)
self.world.setDebugNode(debug_node)
return debug_node
def setupDebug(self):
node = BulletDebugNode("Debug")
node.showWireframe(True)
self.world.setDebugNode(node)
np = self.render.attachNewNode(node)
np.show()
def _debug_mode(self):
debugNode = BulletDebugNode('Debug')
debugNode.showWireframe(True)
debugNode.showConstraints(True)
debugNode.showBoundingBoxes(False)
debugNode.showNormals(True)
debugNP = self.render.attachNewNode(debugNode)
self.physics_world.dynamic_world.setDebugNode(debugNP.node())
self.debug_node = debugNP
def enablePhysicsDebug(self):
debugnode = BulletDebugNode('Physics-Debug')
debugnode.showWireframe(True)
debugnode.showConstraints(True)
debugNP = render.attachNewNode(debugnode)
if self.physics_world != None:
self.physics_world.setDebugNode(debugNP.node())
debugNP.show()
def setupDebug(self): debug = BulletDebugNode() debug.showWireframe(False) # Yeah, don't set this to true unless you want to emulate an 80's computer running Crysis on Ultra settings. debug.showConstraints(True) debug.showBoundingBoxes(True) # This is the main use I have for it. debug.showNormals(True) debugNP = render.attachNewNode(debug) self.worldBullet.setDebugNode(debugNP.node()) debugNP.hide() return debugNP
def __init__(self):
#self.gui = loadGui()
#init_pause_state(self.menu)
init_pause_state()
test = World()
debugNode = BulletDebugNode('Debug')
debugNode.showWireframe(True)
debugNode.showConstraints(True)
debugNode.showBoundingBoxes(False)
debugNode.showNormals(False)
debugNP = render.attachNewNode(debugNode)
debugNP.show()
self.world = BulletWorld()
self.world.setGravity(Vec3(0, 0, -9))
self.world.setDebugNode(debugNP.node())
#Add a gravity region
self.add_gravity_region(
(100, 100, 100),
(100, -400, 0),
(0, 0, 1000))
taskMgr.add(self.update_bullet, 'update_bullet')
self.bulletList = self.loadBulletList()
base.disableMouse()
self.loadLevel()
self.initClasses()
self.setCamera()
self.addWinProps()
#TODO: Fix the healthbars
#self.gui.healthBar("Player1")
#self.gui.healthBar("AI1")
#self.gui.healthBar("AI2")
#self.gui.healthBar("AI3")
self.loadStation()
self.addlight()
self.createControls()
taskMgr.add(self.updateMenus, 'MenuUpdater')
print("Instance of game class running.")
self.simmpoleXP()
self.flipsXP()
def setupDebug(self):
debug = BulletDebugNode()
debug.showWireframe(
False
) # Yeah, don't set this to true unless you want to emulate an 80's computer running Crysis on Ultra settings.
debug.showConstraints(True)
debug.showBoundingBoxes(True) # This is the main use I have for it.
debug.showNormals(True)
debugNP = render.attachNewNode(debug)
self.worldBullet.setDebugNode(debugNP.node())
debugNP.hide()
return debugNP
def showBulletDebug(self):
"""Show bullet Debug"""
# Bullet DEBUG
debugNode = BulletDebugNode('Debug')
debugNode.showWireframe(True)
debugNode.showConstraints(True)
debugNode.showBoundingBoxes(False)
debugNode.showNormals(False)
debugNP = render.attachNewNode(debugNode)
debugNP.show()
self.bulletWorld.setDebugNode(debugNP.node())
def showBulletDebug(self):
"""Show bullet Debug"""
# Bullet DEBUG
debugNode = BulletDebugNode('Debug')
debugNode.showWireframe(True)
debugNode.showConstraints(True)
debugNode.showBoundingBoxes(False)
debugNode.showNormals(False)
debugNP = render.attachNewNode(debugNode)
debugNP.show()
self.bulletWorld.setDebugNode(debugNP.node())
def drawDebugNode(self):
debugNode = BulletDebugNode('Debug')
debugNode.showWireframe(True)
debugNode.showConstraints(True)
debugNode.showBoundingBoxes(False)
debugNode.showNormals(False)
self.debugNP = render.attachNewNode(debugNode)
#print "TankWorld.drawDebugNode: debug node activated"
self.accept('9', self.debugNP.show)
self.accept('8', self.debugNP.hide)
self.__bulletWorld.setDebugNode(debugNode)
def setupBulletPhysics(self):
debugNode = BulletDebugNode('Debug')
debugNode.showWireframe(True)
debugNode.showConstraints(True)
debugNode.showBoundingBoxes(False)
debugNode.showNormals(False)
self.debugNP = render.attachNewNode(debugNode)
self.mondePhysique = BulletWorld()
self.mondePhysique.setGravity(Vec3(0, 0, -9.81))
self.mondePhysique.setDebugNode(self.debugNP.node())
taskMgr.add(self.updatePhysics, "updatePhysics")
taskMgr.add(self.updateCarte, "updateCarte")
def __init__(self, base):
self.__base = base
self.__base.world = BulletWorld()
bulletcolliderrender = self.__base.render.attachNewNode("bulletcollider")
debugNode = BulletDebugNode('Debug')
debugNode.showWireframe(True)
debugNode.showConstraints(True)
debugNode.showBoundingBoxes(False)
debugNode.showNormals(False)
self.__debugNP = bulletcolliderrender.attachNewNode(debugNode)
self.__base.world.setDebugNode(self.__debugNP.node())
self.worldrigidbodylist = []
def __init__(self):
ShowBase.__init__(self)
utilities.setApp(self)
loadPrcFileData('', 'bullet-enable-contact-events true')
self.world = World(10)
self.taskMgr.add(self.update, "update")
self.accept("a", self.world.player.moveLeft, [True])
self.accept("a-up", self.world.player.moveLeft, [False])
self.accept("d", self.world.player.moveRight, [True])
self.accept("d-up", self.world.player.moveRight, [False])
self.accept("space", self.world.player.jump, [True])
self.accept("space-up", self.world.player.jump, [False])
self.accept("c", self.world.player.crouch, [True])
self.accept("c-up", self.world.player.crouch, [False])
self.accept("mouse1", self.world.player.activate, [])
self.accept("escape", sys.exit, [])
self.accept('bullet-contact-added', self.onContactAdded)
self.accept('bullet-contact-destroyed', self.onContactDestroyed)
self.accept("h", self.showDBG, [True])
self.accept("h-up", self.showDBG, [False])
self.prevTime = 0
self.mousePos = Point2()
base.disableMouse()
self.rl = base.camLens.makeCopy()
# bullet testing
debugNode = BulletDebugNode('Debug')
debugNode.showWireframe(True)
debugNode.showConstraints(True)
debugNode.showBoundingBoxes(False)
debugNode.showNormals(False)
self.debugNP = render.attachNewNode(debugNode)
self.debugNP.show()
self.world.bw.setDebugNode(self.debugNP.node())
def setPhysicsDebug(self, _bool=False):
debugNode = BulletDebugNode('Debug')
self.debugNP = render.attachNewNode(debugNode)
if _bool:
debugNode = BulletDebugNode('Debug')
debugNode.showWireframe(True)
debugNode.showConstraints(True)
debugNode.showBoundingBoxes(False)
debugNode.showNormals(False)
self.debugNP = render.attachNewNode(debugNode)
self.physicsWorld.setDebugNode(self.debugNP.node())
self.debugNP.show()
else:
self.debugNP.hide()
def setPhysicsDebug(self, _bool=False):
debugNode = BulletDebugNode('Debug')
self.debugNP = render.attachNewNode(debugNode)
if _bool:
debugNode = BulletDebugNode('Debug')
debugNode.showWireframe(True)
debugNode.showConstraints(True)
debugNode.showBoundingBoxes(False)
debugNode.showNormals(False)
self.debugNP = render.attachNewNode(debugNode)
self.physicsWorld.setDebugNode(self.debugNP.node())
self.debugNP.show()
else:
self.debugNP.hide()
def __init__(self, toggledebug=False):
self.world = BulletWorld()
self._toggledebug = toggledebug
if self._toggledebug:
bulletcolliderrender = base.render.attachNewNode(
"bulletboxcollider")
debugNode = BulletDebugNode('Debug')
debugNode.showWireframe(True)
debugNode.showConstraints(True)
debugNode.showBoundingBoxes(False)
debugNode.showNormals(False)
self._debugNP = bulletcolliderrender.attachNewNode(debugNode)
self.world.setDebugNode(self._debugNP.node())
self.worldrigidbodylist = []
self._isupdateworldadded = False
def __init__(self, app):
self.app = app
utilities.setApp(self.app)
self.world = World(10)
self.app.taskMgr.add(self.update, "update")
self.app.accept("a", self.world.player.moveLeft, [True])
self.app.accept("a-up", self.world.player.moveLeft, [False])
self.app.accept("d", self.world.player.moveRight, [True])
self.app.accept("d-up", self.world.player.moveRight, [False])
self.app.accept("w", self.world.player.jump, [True])
self.app.accept("w-up", self.world.player.jump, [False])
self.app.accept("s", self.world.player.crouch, [True])
self.app.accept("s-up", self.world.player.crouch, [False])
self.app.accept("mouse1", self.world.player.activate, [])
self.app.accept("q", self.world.player.scrollItem, [1])
self.app.accept("1", self.world.player.selectItem, [1])
self.app.accept("2", self.world.player.selectItem, [2])
self.app.accept("escape", sys.exit, [])
self.app.mousePos = Point2()
self.app.disableMouse()
self.app.rl = base.camLens.makeCopy()
if utilities.debug:
self.app.accept("h", self.showDBG, [True])
self.app.accept("h-up", self.showDBG, [False])
#bullet debug rendering
debugNode = BulletDebugNode('Debug')
debugNode.showWireframe(True)
debugNode.showConstraints(True)
debugNode.showBoundingBoxes(False)
debugNode.showNormals(False)
self.debugNP = render.attachNewNode(debugNode)
self.debugNP.show()
self.world.bw.setDebugNode(self.debugNP.node())
def __init__(self, xml):
globalClock.setMaxDt(0.1)
#init pre and post callbacks
self.prePhysics = {}
self.postPhysics = {}
#bullet debug node
debugNode = BulletDebugNode('Debug')
debugNode.showWireframe(True)
debugNode.showConstraints(True)
debugNode.showBoundingBoxes(False)
debugNode.showNormals(True)
debugNP = render.attachNewNode(debugNode)
debugNP.show()
#create bullet world
self.bulletworld = BulletWorld()
self.bulletworld.setDebugNode(debugNP.node())
self.bulletworld.setGravity(Vec3(0, 0, 0))
#start doing physics
self.physicsTask = taskMgr.add(self.simulationTask, 'Physics Loop', sort=100)
def initBullet(self):
"""Initializes the Bullet physics engine, also adds the updatePhysicsTask to the task manager."""
self.world = BulletWorld()
self.world.setGravity(Vec3(0, 0, 0))
# add ground
node = BulletRigidBodyNode("Ground") # derived from PandaNode
node.addShape(BulletPlaneShape(Vec3(0, 0, 1), 0))
np = self.render.attachNewNode(node)
np.setPos(0, 0, 0)
self.world.attachRigidBody(node)
# add debug node
debugNode = BulletDebugNode("Debug")
debugNode.showWireframe(False)
debugNode.showConstraints(True)
debugNode.showBoundingBoxes(False)
debugNode.showNormals(True)
debugNP = self.render.attachNewNode(debugNode)
debugNP.show()
self.world.setDebugNode(debugNP.node())
self.taskMgr.add(self.updatePhysicsTask, "UpdatePhysics")
def invoke(scene, data, action):
if action == 'LOAD':
scene.phys_world = BulletWorld()
scene.phys_world.setGravity(Vec3(0, 0, -data['phys_gravity']))
if 'bullet_debug' in scene.flags and scene.flags['bullet_debug']:
# --- debug ---
debugNode = BulletDebugNode('PhysDebug')
debugNode.showWireframe(True)
debugNode.showConstraints(True)
debugNode.showBoundingBoxes(False)
debugNode.showNormals(False)
debugNP = render.attachNewNode(debugNode)
debugNP.show()
scene.phys_world.setDebugNode(debugNode)
# --- debug end ---
#taskMgr.add(update, 'physics-update', extraArgs=[scene, data['phys_step_sub'], 1.0/data['phys_fps']])
taskMgr.doMethodLater(
2,
update,
'physics-update',
extraArgs=[scene, data['phys_step_sub'], 1.0 / data['phys_fps']])
def __init__(self, xml):
globalClock.setMaxDt(0.1)
#init pre and post callbacks
self.prePhysics = {}
self.postPhysics = {}
#bullet debug node
debugNode = BulletDebugNode('Debug')
debugNode.showWireframe(True)
debugNode.showConstraints(True)
debugNode.showBoundingBoxes(False)
debugNode.showNormals(True)
debugNP = render.attachNewNode(debugNode)
debugNP.show()
#create bullet world
self.bulletworld = BulletWorld()
self.bulletworld.setDebugNode(debugNP.node())
self.bulletworld.setGravity(Vec3(0, 0, 0))
#start doing physics
self.physicsTask = taskMgr.add(self.simulationTask,
'Physics Loop',
sort=100)
def __init__(self, screen_size=84, DEBUGGING=False, human_playable=False):
ShowBase.__init__(self)
self.forward_button = KeyboardButton.ascii_key(b'w')
self.backward_button = KeyboardButton.ascii_key(b's')
self.fps = 20
self.human_playable = human_playable
self.actions = 3
self.last_frame_start_time = time.time()
self.action_buffer = [1, 1, 1]
self.last_teleport_time = 0.0
self.time_to_teleport = False
if self.human_playable is False:
winprops = WindowProperties.size(screen_size, screen_size)
fbprops = FrameBufferProperties()
fbprops.set_rgba_bits(8, 8, 8, 0)
fbprops.set_depth_bits(24)
self.pipe = GraphicsPipeSelection.get_global_ptr().make_module_pipe('pandagl')
self.imageBuffer = self.graphicsEngine.makeOutput(
self.pipe,
"image buffer",
1,
fbprops,
winprops,
GraphicsPipe.BFRefuseWindow)
self.camera = Camera('cam')
self.cam = NodePath(self.camera)
self.cam.reparentTo(self.render)
self.dr = self.imageBuffer.makeDisplayRegion()
self.dr.setCamera(self.cam)
self.render.setShaderAuto()
self.cam.setPos(0.5, 0, 6)
self.cam.lookAt(0.5, 0, 0)
# Create Ambient Light
self.ambientLight = AmbientLight('ambientLight')
self.ambientLight.setColor((0.2, 0.2, 0.2, 1))
self.ambientLightNP = self.render.attachNewNode(self.ambientLight)
self.render.setLight(self.ambientLightNP)
# Spotlight
self.light = Spotlight('light')
self.light.setColor((0.9, 0.9, 0.9, 1))
self.lightNP = self.render.attachNewNode(self.light)
self.lightNP.setPos(0, 10, 10)
self.lightNP.lookAt(0, 0, 0)
self.lightNP.node().getLens().setFov(40)
self.lightNP.node().getLens().setNearFar(10, 100)
self.lightNP.node().setShadowCaster(True, 1024, 1024)
self.render.setLight(self.lightNP)
self.world = BulletWorld()
self.world.setGravity(Vec3(0, 0, -9.81))
if DEBUGGING is True:
debugNode = BulletDebugNode('Debug')
debugNode.showWireframe(True)
debugNode.showConstraints(True)
debugNode.showBoundingBoxes(False)
debugNode.showNormals(False)
debugNP = render.attachNewNode(debugNode)
debugNP.show()
self.world.setDebugNode(debugNP.node())
self.finger_speed_mps = 0.0
self.penalty_applied = False
self.teleport_cooled_down = True
self.fps = 20
self.framecount = 0
self.reset()
def __init__(self):
"""
Creates the window, loads the scene and models and sets everything up.
"""
# Initialise panda window
ShowBase.__init__(self)
self.setBackgroundColor(.1, .1, .1)
# Setup window
wp = WindowProperties()
wp.setOrigin(0, 0)
wp.setSize(self.PANDA_WINDOW_WIDTH, self.PANDA_WINDOW_HEIGHT)
# Get drawing area and set its size
panda_drawing_area = builder.get_object("pandaDrawingArea")
panda_drawing_area.set_size_request(self.PANDA_WINDOW_WIDTH,
self.PANDA_WINDOW_HEIGHT)
# Panda should not open own top level window but use the window of the drawing area in GTK
handle = NativeWindowHandle.makeInt(
panda_drawing_area.get_property('window').get_xid())
wp.setParentWindow(handle)
# Open panda window
self.openDefaultWindow(props=wp)
def gtk_iteration(task):
"""
Handles the gtk events and lets as many GUI iterations run as needed.
"""
while Gtk.events_pending():
Gtk.main_iteration_do(False)
return task.cont
# Create task to update GUI
self.taskMgr.add(gtk_iteration, "gtk")
# Activate antialiasing (MAuto for automatic selection of AA form)
self.render.setAntialias(AntialiasAttrib.MAuto)
# Deactivate default mouse control of the camera as they are not very helpful
self.disableMouse()
# Set camera to default position and orientation
self.camera.setPos(0, -4, 2)
self.camera.lookAt(0, 0, 1)
self.camLens.setFov(90)
# Load the camera control events to control camera by keyboard
self.cam_control = CameraControl(self, handler)
# Store it as a class variable of the Handler so the controller can be called by it
Handler.cam_control = self.cam_control
# Load scene
self.scene = self.loader.loadModel("models/rooms/room_neu.egg")
self.scene.reparentTo(
self.render
) # Panda3D makes use of a scene graph, where "render" is the parent of the
# tree containing all objects to be rendered
# Add lights
# TODO: Make the lighting somewhat nicer (maybe with some ambient lights?)
for i in range(0, 3):
dlight = DirectionalLight("light")
dlnp = self.render.attachNewNode(dlight)
dlnp.setHpr((120 * i) + 1, -30, 0)
self.render.setLight(dlnp)
# Create a bullet world (physics engine)
self.world = BulletWorld()
# self.world.setGravity(LVector3f(0, 0, -9.81))
self.world.setGravity(LVector3f(
0, 0, 0)) # No gravity for now (makes forces easier to calculate)
def update_bullet(task):
"""
Invokes the physics engine to update and simulate the next step.
"""
dt = globalClock.getDt() # get elapsed time
self.world.doPhysics(dt) # actually update
return task.cont
# Create task to update physics
self.taskMgr.add(update_bullet, 'update_bullet')
# Set up the ground for the physics engine
ground_shape = BulletPlaneShape(LVector3f(0, 0, 1),
0) # create a collision shape
ground_node_bullet = BulletRigidBodyNode('Ground') # create rigid body
ground_node_bullet.addShape(ground_shape) # add shape to it
ground_node_panda = self.render.attachNewNode(
ground_node_bullet) # attach to panda scene graph
ground_node_panda.setPos(0, 0, 0) # set position
self.world.attachRigidBody(
ground_node_bullet) # attach to physics world
# Create and activate a debug node for bullet and attach it to the panda scene graph
debug_node_bullet = BulletDebugNode('Debug')
debug_node_bullet.showWireframe(True)
debug_node_bullet.showConstraints(True)
debug_node_bullet.showBoundingBoxes(True)
debug_node_bullet.showNormals(True)
debug_node_panda = self.render.attachNewNode(debug_node_bullet)
# debug_node_panda.show()
self.world.setDebugNode(debug_node_panda.node())
# Store it as a class variable of the Handler so the debug mode can be switched by it
Handler.bullet_debug_node = debug_node_panda
# Load the class to manage the drones
self.drone_manager = DroneManager(self)
# Store it as a class variable of the Handler changes can be invoked
Handler.drone_manager = self.drone_manager
s.disable_mouse()
s.accept('escape', sys.exit)
s.cam.set_pos(0, -10, 0)
# Physics
bullet_world = BulletWorld()
def run_physics(task):
bullet_world.do_physics(globalClock.getDt())
return task.cont
s.task_mgr.add(run_physics, sort=1)
# Debug visualization
debug_node = BulletDebugNode('Debug')
debug_node.showWireframe(True)
debug_node.showConstraints(True)
debug_node.showBoundingBoxes(False)
debug_node.showNormals(False)
debug_np = s.render.attach_new_node(debug_node)
bullet_world.set_debug_node(debug_node)
debug_np.show()
# The object in question
mass = BulletRigidBodyNode()
mass.set_mass(1)
mass.setLinearSleepThreshold(0)
mass.setAngularSleepThreshold(0)
shape = BulletSphereShape(1)
mass.add_shape(shape)
class Physics(DirectObject):
"""
Physics Class:
Handles the all Physics
"""
def __init__(self):
## Setup a bullet world.
# World Node (MAIN)
self.worldNP = render.attachNewNode("World")
# World
self.world = BulletWorld()
self.world.setGravity(Vec3(0, 0, worldGravity))
PHYSICS["WORLD"] = self.world
# Add the simulation method to the taskmgr
taskMgr.add(self.update, "update bullet world")
# Setup test World
self.box = ""
self.hinge = ""
self.pickTest = False
self.sensor = ""
# test the class test
self.test = MakeObject(self, "Box1", "b", 20.0)
self.test.bodyNP.setPos(0, 1, 1)
pos = 1
# for x in range(5):
# x = MakeObject(self, 'box', 'b', 5.0)
# pos += 1
# x.bodyNP.setPos(0, 0, pos)
self.accept("e", self.playerPickup)
self.accept("f1", self.showDebug)
self.setup_world()
# taskMgr.add(self.checkGhost, 'checkGhost')
def setup_world(self):
#############################################
##
## GROUND FOR TESTING
#############################################
pass
# Ground
# shape = BulletPlaneShape(Vec3(0, 0, 1), 0)
# np = self.worldNP.attachNewNode(BulletRigidBodyNode('Ground'))
# np.node().addShape(shape)
# np.setPos(0, 0, 0)
# np.setCollideMask(BitMask32.allOn())
# self.world.attachRigidBody(np.node())
##############################################
##############################################
########################
# FIXED :D - Still simple atm.
########################
def playerPickup(self):
# Write a class for pick able objects so that we instance the object in the world and if picked up we change that instance or del it then create new one, then same again when dropped
bodyA = base.camera
# Will have to make a pick up mask so that it collides with walls and floors and w/e else.. except with the player
if self.pickTest == False:
self.test.bodyNP.wrtReparentTo(PLAYER["CLASS"].picker)
# self.test.bodyNP.copyTo(bodyA)
# self.test.worldNP
# bodyB.setPos(0, 2, 0)
self.test.bodyNP.node().setMass(1.0)
# self.test.bodyNP.setScale(1)
# self.test.bodyNP.setCollideMask(BitMask32.allOn())
self.pickTest = True
elif self.pickTest == True:
self.test.bodyNP.wrtReparentTo(GAMEPLAY_NODES["ITEM"])
self.test.bodyNP.node().setMass(1.0)
# self.test.bodyNP.setCollideMask(BitMask32.allOn())
# bodyB.setPos(bodyPos)
self.pickTest = False
# Simulate Physics
def update(self, task):
dt = globalClock.getDt()
self.world.doPhysics(dt, 4, 1.0 / 270.0)
return task.cont
# Enable/Disable debug
def showDebug(self):
# To enable debug
self.debugNode = BulletDebugNode("Debug")
self.debugNode.showBoundingBoxes(True)
self.debugNode.showNormals(False)
self.debugNode.showWireframe(True)
self.debugNode.showConstraints(True)
self.debugNP = render.attachNewNode(self.debugNode)
self.debugNP.show()
# Add the debug node to the physics world
self.world.setDebugNode(self.debugNP.node())
class GameBase(ShowBase):
def __init__(self, KEY_LIST):
ShowBase.__init__(self)
#---------------------------------------------------------------
# clock
self.globalClock = ClockObject()
#---------------------------------------------------------------
# KeyHandler
self.kh = KeyHandler(KEY_LIST)
#---------------------------------------------------------------
# Bullet
self.world = BulletWorld()
self.world.setGravity(Vec3(0, 0, -12.81))
self.gravityUp = False
self.debugNode = BulletDebugNode('Debug')
self.debugNode.showWireframe(True)
self.debugNode.showConstraints(True)
self.debugNode.showBoundingBoxes(True)
self.debugNode.showNormals(True)
self.debugNP = self.render.attachNewNode(self.debugNode)
#self.debugNP.show()
self.world.setDebugNode(self.debugNode)
self._debug = False
#---------------------------------------------------------------
# Player
#---------------------------------------------------------------
# CharacterController
self.player = CharacterController(self)
self.player.setActor('models/characters/female',
{'walk': 'models/characters/female-walk.egg'},
flip=True,
pos=(0, 0, -1),
scale=1.0)
self.player.setPos(0, -5, 3)
self.player.playerModel.loop("walk")
self.playerNp = self.player.np
#---------------------------------------------------------------
# Camera
self.camHandler = CamHandler(self)
#---------------------------------------------------------------
# task
#self.taskMgr.add(self.update, "update")
#---------------------------------------------------------------
# FPS
def toggleFPS(self):
if self.frameRateMeter:
self.setFrameRateMeter(False)
else:
self.setFrameRateMeter(True)
#---------------------------------------------------------------
# Mouse cursor
def hideCursor(self):
props = WindowProperties()
props.setCursorHidden(True)
self.win.requestProperties(props)
def showCursor(self):
props = WindowProperties()
props.setCursorHidden(False)
self.win.requestProperties(props)
def getObjectHoverName(self):
if not self.mouseWatcherNode.hasMouse():
return None
pMouse = self.mouseWatcherNode.getMouse()
pFrom = Point3()
pTo = Point3()
self.camLens.extrude(pMouse, pFrom, pTo)
# Transform to global coordinates
pFrom = self.render.getRelativePoint(self.cam, pFrom)
pTo = self.render.getRelativePoint(self.cam, pTo)
result = self.world.rayTestClosest(pFrom, pTo)
if result.hasHit():
pos = result.getHitPos()
name = result.getNode().getName()
return name
else:
return None
def getObjectCenterScreen(self):
pFrom = Point3()
pTo = Point3()
self.camLens.extrude((0, 0), pFrom, pTo)
# Transform to global coordinates
pFrom = self.render.getRelativePoint(self.cam, pFrom)
pTo = self.render.getRelativePoint(self.cam, pTo)
result = self.world.rayTestClosest(pFrom, pTo)
if result.hasHit():
pos = result.getHitPos()
name = result.getNode().getName()
return name
else:
return None
#---------------------------------------------------------------
# Fog
def setFog(self):
myFog = Fog("Fog")
myFog.setColor((0, 0, 0, 1))
myFog.setExpDensity(0.025)
self.render.setFog(myFog)
self.fog = True
def clearFog(self):
self.render.clearFog()
self.fog = False
def toggleFog(self):
if self.fog:
self.clearFog()
else:
self.setFog()
#---------------------------------------------------------------
# Camera
def setFov(self, x):
self.camLens.setFov(x)
def getFov(self):
return self.camLens.getFov()[0]
def setNear(self, n):
self.camLens.setNear(n)
def setFar(self, n):
self.camLens.setFar(n)
#---------------------------------------------------------------
# Physics
def toggleGravity(self):
if self.gravityUp:
self.gravityUp = False
self.world.setGravity(Vec3(0, 0, -9.8))
else:
self.gravityUp = True
self.world.setGravity(Vec3(0, 0, 9.8))
def toggleDebug(self):
#print "Toggle debug, extraArgs = %s" % (extraArgs)
if self._debug:
self._debug = False
self.debugNP.hide()
else:
self._debug = True
self.debugNP.show()
def updatePhysics(self, dt):
#self.world.doPhysics(dt, 20, 1.0/180)
self.world.doPhysics(dt)
#cnt = self.world.contactTest(self.ground.node)
#for boxName in self.objects:
# self.objects[boxName].update(dt)
'''
cntTest = self.world.contactTest(self.objects[boxName].node)
cnt = cntTest.getContacts()
for c in cnt:
node0 = c.getNode0().getName()
node1 = c.getNode1().getName()
#print node0, " in contact with ", node1
'''
def update(self, task):
self.globalClock.tick()
t = self.globalClock.getFrameTime()
dt = self.globalClock.getDt()
self.updatePhysics(dt)
self.player.update(dt)
return task.cont
def quit(self):
self.taskMgr.stop()
def stop(self):
self.taskMgr.stop()
def start(self):
self.taskMgr.run()
class GameEngine:
def __init__(self):
base.accept('f1', self.toggleDebug)
self.debugNode = BulletDebugNode('Debug')
self.debugNode.showWireframe(True)
self.debugNode.showConstraints(True)
self.debugNode.showBoundingBoxes(False)
self.debugNode.showNormals(False)
self.debugNP = base.render.attachNewNode(self.debugNode)
# self.debugNP.show()
# World
self.world = BulletWorld()
self.world.setGravity(Vec3(0, 0, -9.81))
self.world.setDebugNode(self.debugNP.node())
# Terrain
visNP = base.loader.loadModel('models/terrain.egg')
mesh = BulletTriangleMesh()
for x in visNP.findAllMatches('**/+GeomNode'):
geom = x.node().getGeom(0)
mesh.addGeom(geom)
shape = BulletTriangleMeshShape(mesh, dynamic=True)
body = BulletRigidBodyNode('Bowl')
bodyNP = base.render.attachNewNode(body)
bodyNP.node().addShape(shape)
bodyNP.setPos(0, 0, 1)
bodyNP.setCollideMask(BitMask32.allOn())
self.world.attachRigidBody(bodyNP.node())
visNP.reparentTo(bodyNP)
shapex = BulletBoxShape(5)
bodyx = BulletRigidBodyNode('Egg')
bodyNPx = base.render.attachNewNode(bodyx)
bodyNPx.setPos(0, 0, 3)
bodyNPx.node().setMass(100.0)
bodyNPx.node().addShape(shapex)
self.world.attachRigidBody(bodyNPx.node())
# visNP.reparentTo(bodyNPx)
# Player
self.players = []
self.myId = -1
self.speed = Vec3(0, 0, 0)
self.walk_speed = 2.5
# Camera
base.disableMouse()
props = WindowProperties()
props.setCursorHidden(True)
base.win.requestProperties(props)
# SkySphere
Sky()
self.initCam()
def initCam(self):
base.cam.setHpr(0, -90, 0)
base.cam.setPos(0, 0, 170)
def deathCamTask(self, task):
angleDegrees = task.time * 20.0
angleRadians = angleDegrees * (math.pi / 180.0)
player = self.players[self.myId].playerNP
base.cam.setPos(player.getX() + 10 * math.sin(angleRadians),
player.getY() - 10.0 * math.cos(angleRadians),
player.getZ() + 5)
base.cam.lookAt(player.getPos())
return task.cont
# Debug
def toggleDebug(self):
if self.debugNP.isHidden():
self.debugNP.show()
else:
self.debugNP.hide()
def __init__(self):
ShowBase.__init__(self)
# Load the environment model.
self.scene = self.loader.loadModel("input.obj")
self.setBackgroundColor(0.0, 0.0, 0.0)
plight = PointLight('plight')
plight.setColor(VBase4(0.7, 0.7, 0.7, 1))
plnp = self.render.attachNewNode(plight)
plnp.setPos(0, 20, 0)
self.render.setLight(plnp)
ambientLight = AmbientLight('ambientLight')
ambientLight.setColor((0.1, 0.1, 0.1, 1))
ambientLightNP = render.attachNewNode(ambientLight)
self.render.setLight(ambientLightNP)
dlight = DirectionalLight('dlight')
dlight.setColor(VBase4(0.8, 0.8, 0.8, 1))
dlnp = render.attachNewNode(dlight)
dlnp.setHpr(0, 10, 0)
self.render.setLight(dlnp)
# Reparent the model to render.
shape = BulletBoxShape(Vec3(0.06, 0.12, 0.04))
node = BulletRigidBodyNode('Box')
node.setMass(0.6)
node.addShape(shape)
boxnode = self.render.attachNewNode(node)
#boxnode.setHpr(90,90,90) #or whatever you want to rotate to
#model = self.loader.loadModel('models/box.egg')
customBox = BoxMaker(0.06, 0.12, 0.04).generate()
customBox.setColor(0.97, 0.99, 0.75)
#customBox.flattenLight()
customBox.reparentTo(boxnode)
#model.reparentTo(boxnode)
boxnode.setPos(-0.1, 1.5, 0.65)
boxnode.setHpr(90, 90, 90)
#model.reparentTo(self.scene)
#model.setPos(0, 0.0, 0.0)
#boxnode.reparentTo(self.render)
bin_node = build_bullet_from_model(self.scene)
bin_shape_node = self.render.attachNewNode(bin_node)
self.scene.reparentTo(bin_shape_node)
bin_shape_node.setPos(0, 2.4, 0.2)
bin_shape_node.setHpr(90, 90, 90) #or whatever you want to rotate to
#self.scene.setPos(0, 5.5, 0.2)
#bin_node.setHpr(90,90,90) #or whatever you want to rotate to
world.attachRigidBody(bin_node)
world.attachRigidBody(node)
#shape = BulletPlaneShape(Vec3(0, 0, 1), 1)
#node = BulletRigidBodyNode('Ground')
#node.addShape(shape)
#np = self.render.attachNewNode(node)
#np.setPos(0, 7.0, 0.0)
#np.setHpr(90,90,90)
#world.attachRigidBody(node)
debugNode = BulletDebugNode('Debug')
debugNode.showWireframe(True)
debugNode.showConstraints(True)
debugNode.showBoundingBoxes(False)
debugNode.showNormals(False)
debugNP = self.render.attachNewNode(debugNode)
debugNP.show()
world.setDebugNode(debugNP.node())
#self.scene.reparentTo(self.render)
self.taskMgr.add(update, 'update')
# robotplot = nxtplot
# robot.goinitpose()
# robot.movearmfk([0.0,-20.0,-60.0,-70.0,-100.0,-30.0,0.0,0.0,0.0])
# robot.movearmfk([0.0,-20.0,60.0,70.0,-100.0,30.0,0.0,0.0,0.0], armid = 'lft')
# robotmnp = robotmesh.genmnp(robot)
# robotmnp.reparentTo(base.render)
# ur5dualmnp = ur5dualplot.genUr5dualmnp(robot, handpkg)
# ur5dualmnp.reparentTo(base.render)
pg.plotAxisSelf(base.render, Vec3(0,0,0))
cdchecker = CollisionChecker(robotmesh)
print cdchecker.isSelfCollided(robot)
bullcldrnp = base.render.attachNewNode("bulletcollider")
debugNode = BulletDebugNode('Debug')
debugNode.showWireframe(True)
debugNode.showConstraints(True)
debugNode.showBoundingBoxes(False)
debugNode.showNormals(False)
debugNP = bullcldrnp.attachNewNode(debugNode)
debugNP.show()
cdchecker.bulletworld.setDebugNode(debugNP.node())
def updateworld(world, task):
world.doPhysics(globalClock.getDt())
return task.cont
base.taskMgr.add(updateworld, "updateworld", extraArgs=[cdchecker.bulletworld], appendTask=True)
base.run()
class GameBase(ShowBase):
def __init__(self, KEY_LIST):
ShowBase.__init__(self)
#---------------------------------------------------------------
# clock
self.globalClock = ClockObject()
#---------------------------------------------------------------
# KeyHandler
self.kh = KeyHandler(KEY_LIST)
#---------------------------------------------------------------
# Bullet
self.world = BulletWorld()
self.world.setGravity(Vec3(0, 0, -12.81))
self.gravityUp = False
self.debugNode = BulletDebugNode('Debug')
self.debugNode.showWireframe(True)
self.debugNode.showConstraints(True)
self.debugNode.showBoundingBoxes(True)
self.debugNode.showNormals(True)
self.debugNP = self.render.attachNewNode(self.debugNode)
#self.debugNP.show()
self.world.setDebugNode(self.debugNode)
self._debug = False
#---------------------------------------------------------------
# Player
#---------------------------------------------------------------
# CharacterController
self.player = CharacterController(self)
self.player.setActor('models/characters/female', {
'walk' : 'models/characters/female-walk.egg'
},
flip = True,
pos = (0,0,-1),
scale = 1.0)
self.player.setPos(0, -5, 3)
self.player.playerModel.loop("walk")
self.playerNp = self.player.np
#---------------------------------------------------------------
# Camera
self.camHandler = CamHandler(self)
#---------------------------------------------------------------
# task
#self.taskMgr.add(self.update, "update")
#---------------------------------------------------------------
# FPS
def toggleFPS(self):
if self.frameRateMeter:
self.setFrameRateMeter(False)
else:
self.setFrameRateMeter(True)
#---------------------------------------------------------------
# Mouse cursor
def hideCursor(self):
props = WindowProperties()
props.setCursorHidden(True)
self.win.requestProperties(props)
def showCursor(self):
props = WindowProperties()
props.setCursorHidden(False)
self.win.requestProperties(props)
def getObjectHoverName(self):
if not self.mouseWatcherNode.hasMouse():
return None
pMouse = self.mouseWatcherNode.getMouse()
pFrom = Point3()
pTo = Point3()
self.camLens.extrude(pMouse, pFrom, pTo)
# Transform to global coordinates
pFrom = self.render.getRelativePoint(self.cam, pFrom)
pTo = self.render.getRelativePoint(self.cam, pTo)
result = self.world.rayTestClosest(pFrom, pTo)
if result.hasHit():
pos = result.getHitPos()
name = result.getNode().getName()
return name
else:
return None
def getObjectCenterScreen(self):
pFrom = Point3()
pTo = Point3()
self.camLens.extrude((0,0), pFrom, pTo)
# Transform to global coordinates
pFrom = self.render.getRelativePoint(self.cam, pFrom)
pTo = self.render.getRelativePoint(self.cam, pTo)
result = self.world.rayTestClosest(pFrom, pTo)
if result.hasHit():
pos = result.getHitPos()
name = result.getNode().getName()
return name
else:
return None
#---------------------------------------------------------------
# Fog
def setFog(self):
myFog = Fog("Fog")
myFog.setColor((0,0,0,1))
myFog.setExpDensity(0.025)
self.render.setFog(myFog)
self.fog = True
def clearFog(self):
self.render.clearFog()
self.fog = False
def toggleFog(self):
if self.fog:
self.clearFog()
else:
self.setFog()
#---------------------------------------------------------------
# Camera
def setFov(self, x):
self.camLens.setFov(x)
def getFov(self):
return self.camLens.getFov()[0]
def setNear(self, n):
self.camLens.setNear(n)
def setFar(self, n):
self.camLens.setFar(n)
#---------------------------------------------------------------
# Physics
def toggleGravity(self):
if self.gravityUp:
self.gravityUp = False
self.world.setGravity(Vec3(0,0,-9.8))
else:
self.gravityUp = True
self.world.setGravity(Vec3(0,0,9.8))
def toggleDebug(self):
#print "Toggle debug, extraArgs = %s" % (extraArgs)
if self._debug:
self._debug = False
self.debugNP.hide()
else:
self._debug = True
self.debugNP.show()
def updatePhysics(self, dt):
#self.world.doPhysics(dt, 20, 1.0/180)
self.world.doPhysics(dt)
#cnt = self.world.contactTest(self.ground.node)
#for boxName in self.objects:
# self.objects[boxName].update(dt)
'''
cntTest = self.world.contactTest(self.objects[boxName].node)
cnt = cntTest.getContacts()
for c in cnt:
node0 = c.getNode0().getName()
node1 = c.getNode1().getName()
#print node0, " in contact with ", node1
'''
def update(self, task):
self.globalClock.tick()
t = self.globalClock.getFrameTime()
dt = self.globalClock.getDt()
self.updatePhysics(dt)
self.player.update(dt)
return task.cont
def quit(self):
self.taskMgr.stop()
def stop(self):
self.taskMgr.stop()
def start(self):
self.taskMgr.run()
def __init__(self, character_list):
super().__init__(self)
self.clock = 0
for character in character_list:
character.HP = character.BaseHP
# displayHP(Character)
self.characterList = character_list
self.buttons = []
self.index = 0
# Set up the World
# The World
self.world = BulletWorld()
self.world.setGravity(Vec3(0, 0, -gravity))
# Camera
self.cam.setPos(0, -15, 2)
self.cam.lookAt(0, 0, 0)
# The Ground
np = self.render.attachNewNode(BulletRigidBodyNode('Ground'))
np.node().addShape(BulletPlaneShape(Vec3(0, 0, 1), 1))
np.setPos(0, 0, -2)
self.world.attachRigidBody(np.node())
# Characters
character_list[0].insert(self.world, self.render, -1, (-2, 0))
character_list[1].insert(self.world, self.render, 1, (2, 0))
# Debug
debug_node = BulletDebugNode('Debug')
debug_node.showWireframe(True)
debug_node.showConstraints(False)
debug_node.showBoundingBoxes(False)
debug_node.showNormals(False)
self.debugNP = self.render.attachNewNode(debug_node)
self.debugNP.show()
self.world.setDebugNode(self.debugNP.node())
debug_object = DirectObject()
debug_object.accept('f1', self.toggle_debug)
# Testing Controls
shoulder_moving_object = ShoulderMovingObject(character_list)
target_moving_object = TargetMovingObject()
self.targets = target_moving_object.set_targets(*DefaultTargetPos)
for i in range(3):
shoulder_moving_object.move_arms(i, 0)
self.taskMgr.add(self.update, 'update')
# Set up GUI
self.sharedInfo = OnscreenText(text="No information to display yet.",
pos=(0, 0.5),
scale=0.07,
align=TextNode.ACenter,
mayChange=1)
self.actionBoxes, self.infoBoxes, self.useButtons, self.healthBars = [], [], [], []
self.selectedAction, self.selection = None, None
for side in (LEFT, RIGHT):
action_box = DirectFrame(frameColor=(0, 0, 0, 1),
frameSize=(-frame_width, frame_width,
-frame_height, frame_height),
pos=(side * (window_width - frame_width),
0, -(window_height - frame_height)))
info_box = OnscreenText(text="No info available",
scale=0.07,
align=TextNode.ACenter,
mayChange=1)
info_box.reparentTo(action_box)
info_box.setPos(0, frame_height + 0.25)
use_button = DirectButton(frameSize=(-button_width, button_width,
-button_height,
button_height),
text="N/A",
text_scale=0.1,
borderWidth=(0.025, 0.025),
command=self.use_action,
state=DGG.DISABLED)
use_button.reparentTo(action_box)
use_button.setPos(frame_width - button_width, 0, 0)
hp = self.characterList[0 if side < 0 else side].HP
bar = DirectWaitBar(text="",
range=hp,
value=hp,
pos=(side * 0.5, 0, 0.75),
frameSize=(side * -0.4, side * 0.5, 0, -0.05))
self.actionBoxes.append(action_box)
self.infoBoxes.append(info_box)
self.useButtons.append(use_button)
self.healthBars.append(bar)
self.query_action()
def main():
ECSShowBase()
base.disable_mouse()
base.accept('escape', sys.exit)
base.cam.set_pos(4, -5, 2)
base.cam.look_at(0, 0, 0)
system_types = [
prototype.ManageModels,
clock.DetermineTimestep,
prototype.DeterminePhysicsTimestep,
prototype.DoPhysics,
]
for sort, system_type in enumerate(system_types):
base.add_system(system_type(), sort)
# Bullet world
bullet_world = BulletWorld()
bullet_world.set_gravity(Vec3(0, 0, -9.81))
if debug:
debugNode = BulletDebugNode('Debug')
debugNode.showWireframe(True)
debugNode.showConstraints(True)
debugNode.showBoundingBoxes(False)
debugNode.showNormals(False)
debugNP = render.attachNewNode(debugNode)
debugNP.show()
bullet_world.setDebugNode(debugNP.node())
world = base.ecs_world.create_entity(
clock.Clock(clock=clock.panda3d_clock),
prototype.PhysicsWorld(world=bullet_world, timestep=1 / 30),
)
base.ecs_world._flush_component_updates()
# Something for the models to fall on
bullet_body = BulletRigidBodyNode()
bullet_body.set_mass(0.0)
bullet_body.add_shape(
BulletBoxShape(Vec3(base_size, base_size, 0.1)),
TransformState.makePos(Point3(0, 0, 0)),
)
bullet_body.add_shape(
BulletBoxShape(Vec3(base_size, 0.1, wall_height)),
TransformState.makePos(Point3(0, -base_size, wall_height)),
)
bullet_body.add_shape(
BulletBoxShape(Vec3(base_size, 0.1, wall_height)),
TransformState.makePos(Point3(0, base_size, wall_height)),
)
bullet_body.add_shape(
BulletBoxShape(Vec3(0.1, base_size, wall_height)),
TransformState.makePos(Point3(-base_size, 0, wall_height)),
)
bullet_body.add_shape(
BulletBoxShape(Vec3(0.1, base_size, wall_height)),
TransformState.makePos(Point3(base_size, 0, wall_height)),
)
base.ecs_world.create_entity(
prototype.Model(post_attach=prototype.transform(pos=Vec3(0, 0, -1)), ),
prototype.PhysicsBody(
body=bullet_body,
world=world._uid,
),
)
# Regularly add a ball
def add_ball(task):
bullet_body = BulletRigidBodyNode()
bullet_body.set_linear_sleep_threshold(0)
bullet_body.set_angular_sleep_threshold(0)
bullet_body.set_mass(1.0)
bullet_body.add_shape(BulletSphereShape(ball_size))
func = random.choice([
add_smiley,
add_panda,
add_mr_man_static,
add_mr_man_dynamic,
])
func(world, bullet_body)
return task.again
base.do_method_later(creation_interval, add_ball, 'add ball')
# Start
base.run()
class Mecha01Client(ShowBase):
def __init__(self):
ShowBase.__init__(self)
self.taskMgr.add(self.spinCameraTask, "SpinCameraTask")
self.plight = PointLight('plight')
self.pnlp = self.camera.attachNewNode(self.plight)
render.setLight(self.pnlp)
self.debugNode = BulletDebugNode('Debug')
self.debugNode.showWireframe(True)
self.debugNode.showConstraints(True)
self.debugNode.showBoundingBoxes(False)
self.debugNode.showNormals(False)
self.debugNP = render.attachNewNode(self.debugNode)
self.debugNP.show()
self.world = BulletWorld()
self.world.setDebugNode(self.debugNode)
self.planet = Planet()
self.planet.perlin_terrain(5, 0.5)
self.planet.build_node_path(render, self.world)
shape = BulletCapsuleShape(0.25, 0.5)
node = BulletRigidBodyNode('Capsule')
node.addShape(shape)
np = render.attachNewNode(node)
np.setPos(Vec3(0, 0.8, 0.8)*self.planet.get_radius())
new_up_vector = Vec3(
np.getPos() - self.planet.get_node_path().getPos())
old_up_vector = Vec3(0, 0, 1)
q = self.__quatFromTo(old_up_vector, new_up_vector)
np.setQuat(q)
self.np01 = np
self.world.attachRigidBody(node)
#node.applyCentralImpulse(Vec3(0.4, 0.6, 1.0))
self.taskMgr.add(self.physicsUpdateTask, "PhysicsUpdateTask")
self.accept('arrow_up', self.test01, ["shalala"])
def test01(self, x):
print x
def gravity(self, position):
down_vector = Vec3(0, 0, 0) - position
down_vector.normalize()
gravity = LVector3f(down_vector*9.81)
def physicsUpdateTask(self, task):
dt = globalClock.getDt()
# simulating spherical gravity
node = self.np01.getNode(0)
pos = self.np01.getPos()
gravity = self.gravity(pos)
#self.np01.setQuat(Quat(0, 1.1, 1.1, 0))
self.world.doPhysics(dt)
return Task.cont
def spinCameraTask(self, task):
# angleDegrees = task.time * 6.0
# angleRadians = angleDegrees * (pi / 180.0)
# self.camera.setPos(
# 100.0 * sin(angleRadians),
# -100.0 * cos(angleRadians), 0.0)
# self.camera.setHpr(angleDegrees, 0, 0)
self.camera.setPos(self.np01.getPos()*5.0)
self.camera.lookAt(self.np01)
return Task.cont
def __quatFromTo(self, v0, v1):
print (v0, v1)
q = Quat(
sqrt(v0.length()**2 * v1.length()**2) + v0.dot(v1),
v0.cross(v1))
q.normalize()
return q
def __init__(self,
cam_pos=np.array([2.0, 0.5, 2.0]),
lookat_pos=np.array([0, 0, 0.25]),
up=np.array([0, 0, 1]),
fov=40,
w=1920,
h=1080,
lens_type="perspective",
toggle_debug=False,
auto_cam_rotate=False):
"""
:param cam_pos:
:param lookat_pos:
:param fov:
:param w: width of window
:param h: height of window
author: weiwei
date: 2015?, 20201115
"""
# the taskMgr, loader, render2d, etc. are added to builtin after initializing the showbase parental class
super().__init__()
# set up window
winprops = WindowProperties(base.win.getProperties())
winprops.setTitle("WRS Robot Planning and Control System")
base.win.requestProperties(winprops)
self.disableAllAudio()
self.setBackgroundColor(1, 1, 1)
# set up lens
lens = PerspectiveLens()
lens.setFov(fov)
lens.setNearFar(0.001, 5000.0)
if lens_type == "orthographic":
lens = OrthographicLens()
lens.setFilmSize(640, 480)
# disable the default mouse control
self.disableMouse()
self.cam.setPos(cam_pos[0], cam_pos[1], cam_pos[2])
self.cam.lookAt(Point3(lookat_pos[0], lookat_pos[1], lookat_pos[2]),
Vec3(up[0], up[1], up[2]))
self.cam.node().setLens(lens)
# set up slight
## ambient light
ablight = AmbientLight("ambientlight")
ablight.setColor(Vec4(0.2, 0.2, 0.2, 1))
self.ablightnode = self.cam.attachNewNode(ablight)
self.render.setLight(self.ablightnode)
## point light 1
ptlight0 = PointLight("pointlight0")
ptlight0.setColor(Vec4(1, 1, 1, 1))
self._ptlightnode0 = self.cam.attachNewNode(ptlight0)
self._ptlightnode0.setPos(0, 0, 0)
self.render.setLight(self._ptlightnode0)
## point light 2
ptlight1 = PointLight("pointlight1")
ptlight1.setColor(Vec4(.4, .4, .4, 1))
self._ptlightnode1 = self.cam.attachNewNode(ptlight1)
self._ptlightnode1.setPos(self.cam.getPos().length(), 0,
self.cam.getPos().length())
self.render.setLight(self._ptlightnode1)
## point light 3
ptlight2 = PointLight("pointlight2")
ptlight2.setColor(Vec4(.3, .3, .3, 1))
self._ptlightnode2 = self.cam.attachNewNode(ptlight2)
self._ptlightnode2.setPos(-self.cam.getPos().length(), 0,
self.cam.getPos().length())
self.render.setLight(self._ptlightnode2)
# helpers
self.p3dh = p3dh
# self.o3dh = o3dh
self.rbtmath = rm
# set up inputmanager
self.lookatpos = lookat_pos
self.inputmgr = im.InputManager(self, self.lookatpos)
taskMgr.add(self._interaction_update, "interaction", appendTask=True)
# set up rotational cam
if auto_cam_rotate:
taskMgr.doMethodLater(.1, self._rotatecam_update, "rotate cam")
# set window size
props = WindowProperties()
props.setSize(w, h)
self.win.requestProperties(props)
# outline edge shader
# self.set_outlineshader()
# set up cartoon effect
self._separation = 1
self.filter = flt.Filter(self.win, self.cam)
self.filter.setCartoonInk(separation=self._separation)
# self.filter.setViewGlow()
# set up physics world
self.physics_scale = 1e3
self.physicsworld = BulletWorld()
self.physicsworld.setGravity(Vec3(0, 0, -9.81 * self.physics_scale))
taskMgr.add(self._physics_update, "physics", appendTask=True)
globalbprrender = base.render.attachNewNode("globalbpcollider")
debugNode = BulletDebugNode('Debug')
debugNode.showWireframe(True)
debugNode.showConstraints(True)
debugNode.showBoundingBoxes(False)
debugNode.showNormals(True)
self._debugNP = globalbprrender.attachNewNode(debugNode)
self._debugNP.show()
self.toggledebug = toggle_debug
if toggle_debug:
self.physicsworld.setDebugNode(self._debugNP.node())
self.physicsbodylist = []
# set up render update (TODO, only for dynamics?)
self._internal_update_obj_list = [
] # the nodepath, collision model, or bullet dynamics model to be drawn
self._internal_update_robot_list = []
taskMgr.add(self._internal_update, "internal_update", appendTask=True)
# for remote visualization
self._external_update_objinfo_list = [] # see anime_info.py
self._external_update_robotinfo_list = []
taskMgr.add(self._external_update, "external_update", appendTask=True)
# for stationary models
self._noupdate_model_list = []
class Game(GameBase, FSM):
def __init__(self):
GameBase.__init__(self, KEY_LIST)
FSM.__init__(self, 'Game')
self.setBackgroundColor(0,0,0)
self.accept("space", self.toggleFPS)
self.accept("escape", self.taskMgr.stop)
'''
self.shape = BulletPlaneShape(Vec3(0, 0, 1), 1)
self.node = BulletRigidBodyNode('Ground')
self.node.addShape(self.shape)
self.np = self.render.attachNewNode(self.node)
self.np.setPos(0, 0, 0)
self.world.attachRigidBody(self.node)
'''
self.debugNode = BulletDebugNode('Debug')
self.debugNode.showWireframe(True)
self.debugNode.showConstraints(True)
self.debugNode.showBoundingBoxes(True)
self.debugNode.showNormals(True)
self.debugNP = self.render.attachNewNode(self.debugNode)
self.debugNP.show()
self.bulletbox = BulletBoxShape(Vec3(0.5, 0.5, 0.5))
self.bulletboxnode = BulletRigidBodyNode('Box')
self.bulletboxnode.setMass(1.0)
self.bulletboxnode.addShape(self.bulletbox)
self.bulletboxnp = self.render.attachNewNode(self.bulletboxnode)
#self.bulletboxnp = NodePath(self.bulletboxnode)
#self.bulletboxnp.reparentTo(self.render)
self.bulletboxnp.setPos(0, 0, 15)
self.bulletboxnp.setScale(5,3,0.5)
self.world.attachRigidBody(self.bulletboxnode)
self.model = self.loader.loadModel("models/props/crate.egg")
self.model.reparentTo(self.bulletboxnp)
#---------------------------------------------------------------
# Ground (StaticTerrain)
self.ground = StaticTerrain(self, 'models/terrain.jpg', 50)
self.ground.setTexture(self.loader.loadTexture("models/ground.jpg"))
self.sky = SkyBox(self)
self.sky.set("teal1")
self.cursor = MouseCursor(self)
self.cursor.addCursor("cursor2")
self.hideCursor()
self.lightManager = LightManager(self)
self.lightManager.addAmbientLight(Vec4(.5,.5,.5,1))
self.lightManager.addPointLight(Vec4(1.0,1.0,1.0,1.0), Point3(2,-4,5))
self.taskMgr.add(self.update, "update")
print self.getAspectRatio()
self.camHandler = CamHandler(self)
self.accept(K_DRAG, self.camHandler.startDrag)
self.accept(K_DRAG+"-up", self.camHandler.stopDrag)
def update(self, task):
self.globalClock.tick()
t = self.globalClock.getFrameTime()
dt = self.globalClock.getDt()
self.updatePhysics(dt)
self.player.update(dt,
self.kh.getKey(K_RIGHT) - self.kh.getKey(K_LEFT),
self.kh.getKey(K_FORWARD) - self.kh.getKey(K_BACKWARD),
self.kh.getKey(K_JUMP),
self.kh.getKey(K_CROUCH),
self.kh.getKey(K_TURN_LEFT) - self.kh.getKey(K_TURN_RIGHT))
self.camHandler.update()
return task.cont
class HLevel():
def __init__(self, showbase, physicsDebug=True):
"""
:type self.Base: direct.showbase.ShowBase.ShowBase
:type showbase: direct.showbase.ShowBase.ShowBase
:type physicsDebug: bool
"""
print "Creating level"
self.Base = showbase
self.debugDrawing = physicsDebug
self.pause = False
self.bulletSubstep = 0.008
self.activeLog = False
def loadAssets(self):
print "Loading Assets"
def renderAssets(self):
print "Rendering assets"
def setCamera(self):
print "Setting camera"
def setLights(self):
print "Setting lights"
def destroy(self):
print "Destroying level"
def loadEgg(self, egg):
"""
:type egg: str
:rtype : panda3d.core.NodePath
"""
return self.Base.loader.loadModel(egg)
def renderModel(self, model):
"""
:type model: str
"""
model.reparentTo(self.Base.render)
def renderEgg(self, egg):
"""
:type egg: str
:return pada3d.core.NodePath
"""
m = self.loadEgg(egg)
self.renderModel(m)
return m
def setPhysics(self):
print "Setting physics"
self.world = BulletWorld()
self.world.setGravity(Vec3(0, 0, -10))
self.Base.taskMgr.add(self.physicsUpdate, "physicsUpdate", priority=0)
if self.debugDrawing:
print "Debug drawing"
self.debug = BulletDebugNode("debug")
self.debug.showWireframe(True)
self.debug.showBoundingBoxes(False)
self.debug.showNormals(True)
self.debugNP = self.Base.render.attachNewNode(self.debug)
self.debugNP.show()
self.world.setDebugNode(self.debug)
def physicsUpdate(self, task):
if not self.pause:
dt = globalClock.getDt()
self.world.doPhysics(dt, 2, self.bulletSubstep) # #0.009-0.008
# print "Physics step"
return task.cont
def cameraShake(self, amplitud=0.01, frecuencia=5):
"""
:type amplitud: float
:type frecuencia: float
"""
self.Base.camera.setZ(
self.Base.camera,
sin(globalClock.getRealTime() * frecuencia) * amplitud)
def eggToStatic(self, egg, parent, margin=0.01, name="static"):
"""
:type egg: str
:type parent: panda3d.core.NodePath
:type margin: float
:type name: str
:return: tuple(pada3d.bullet.BulletRigidBodyNode,panda3d.core.NodePath)
"""
m = self.Base.loader.loadModel(egg)
sTuple = modelToShape(m)
sTuple[0].setMargin(margin)
static = BulletRigidBodyNode(name) # H
static.addShape(sTuple[0], sTuple[1])
np = parent.attachNewNode(egg)
self.world.attachRigidBody(static)
return static, np
def togglePause(self):
"""
"""
if self.pause:
self.pause = False
else:
self.pause = True
print "Toggle pause", self.pause
def activateLog(self):
self.activeLog = True
self.logText = OnscreenText("NO LOG",
scale=0.07,
fg=(1, 0, 0, 0.8),
bg=(0, 0, 1, 0.2),
frame=(0, 1, 0, 0.2),
pos=(-1.05, .9),
mayChange=True,
align=0)
self.__logTextLenght = 0
self.__logAbsoluteLenght = 0
self.__logText = ""
self.logText.reparentTo(self.Base.aspect2d)
def log(self, *args):
if self.activeLog is False:
return None
s = str(self.__logAbsoluteLenght) + ":"
for a in args:
s += str(a) + " "
if self.__logTextLenght < 10:
self.logText.appendText("\n" + s)
else:
self.__logTextLenght = 0
self.logText.clearText()
self.logText.setText(s)
self.__logTextLenght += 1
self.__logAbsoluteLenght += 1
self.__logText.join(s)
def loadFont(self, string):
return self.Base.loader.loadFont(string)
def drawLine(self,
fromP,
toP,
thickness=2,
color=(1, 0, 0, 1),
autoClear=True):
if autoClear:
try:
self.debugLineNP.removeNode()
except:
pass
self.debugLine = LineSegs("DebugLine")
self.debugLine.reset()
self.debugLine.setThickness(thickness)
self.debugLine.setColor(color)
self.debugLine.moveTo(fromP)
self.debugLine.drawTo(toP)
self.debugLineNode = self.debugLine.create()
self.debugLineNP = NodePath(self.debugLineNode)
self.debugLineNP.reparentTo(self.Base.render)
return self.debugLineNP
class Mecha01Client(ShowBase):
def __init__(self):
ShowBase.__init__(self)
self.taskMgr.add(self.spinCameraTask, "SpinCameraTask")
self.plight = PointLight('plight')
self.pnlp = self.camera.attachNewNode(self.plight)
render.setLight(self.pnlp)
self.debugNode = BulletDebugNode('Debug')
self.debugNode.showWireframe(True)
self.debugNode.showConstraints(True)
self.debugNode.showBoundingBoxes(False)
self.debugNode.showNormals(False)
self.debugNP = render.attachNewNode(self.debugNode)
self.debugNP.show()
self.world = BulletWorld()
self.world.setDebugNode(self.debugNode)
self.planet = Planet()
self.planet.perlin_terrain(5, 0.5)
self.planet.build_node_path(render, self.world)
shape = BulletCapsuleShape(0.25, 0.5)
node = BulletRigidBodyNode('Capsule')
node.addShape(shape)
np = render.attachNewNode(node)
np.setPos(Vec3(0, 0.8, 0.8) * self.planet.get_radius())
new_up_vector = Vec3(np.getPos() -
self.planet.get_node_path().getPos())
old_up_vector = Vec3(0, 0, 1)
q = self.__quatFromTo(old_up_vector, new_up_vector)
np.setQuat(q)
self.np01 = np
self.world.attachRigidBody(node)
#node.applyCentralImpulse(Vec3(0.4, 0.6, 1.0))
self.taskMgr.add(self.physicsUpdateTask, "PhysicsUpdateTask")
self.accept('arrow_up', self.test01, ["shalala"])
def test01(self, x):
print(x)
def gravity(self, position):
down_vector = Vec3(0, 0, 0) - position
down_vector.normalize()
gravity = LVector3f(down_vector * 9.81)
def physicsUpdateTask(self, task):
dt = globalClock.getDt()
# simulating spherical gravity
node = self.np01.getNode(0)
pos = self.np01.getPos()
gravity = self.gravity(pos)
#self.np01.setQuat(Quat(0, 1.1, 1.1, 0))
self.world.doPhysics(dt)
return Task.cont
def spinCameraTask(self, task):
# angleDegrees = task.time * 6.0
# angleRadians = angleDegrees * (pi / 180.0)
# self.camera.setPos(
# 100.0 * sin(angleRadians),
# -100.0 * cos(angleRadians), 0.0)
# self.camera.setHpr(angleDegrees, 0, 0)
self.camera.setPos(self.np01.getPos() * 5.0)
self.camera.lookAt(self.np01)
return Task.cont
def __quatFromTo(self, v0, v1):
print(v0, v1)
q = Quat(
sqrt(v0.length()**2 * v1.length()**2) + v0.dot(v1), v0.cross(v1))
q.normalize()
return q
s.cam.set_pos(0, -10, 0)
# Physics
bullet_world = BulletWorld()
def run_physics(task):
bullet_world.do_physics(globalClock.getDt())
return task.cont
s.task_mgr.add(run_physics, sort=1)
# Debug visualization
debug_node = BulletDebugNode('Debug')
debug_node.showWireframe(True)
debug_node.showConstraints(True)
debug_node.showBoundingBoxes(False)
debug_node.showNormals(False)
debug_np = s.render.attach_new_node(debug_node)
bullet_world.set_debug_node(debug_node)
debug_np.show()
# The object in question
mass = BulletRigidBodyNode()
mass.set_mass(1)
mass.setLinearSleepThreshold(0)
mass.setAngularSleepThreshold(0)
shape = BulletSphereShape(1)
mass.add_shape(shape)
mass_node = s.render.attach_new_node(mass)
class initGame():
def __init__(self, windowProps, user, connection):
self.user = user
self.connection = connection
render.setShaderAuto()
self.wp = windowProps
# keeps the game running the same on all systems (kinda sorta barely)#
FPS = 60
globalClock = ClockObject.getGlobalClock()
globalClock.setMode(ClockObject.MLimited)
globalClock.setFrameRate(FPS)
globalClock.setMaxDt(1)
self.world = BulletWorld()
self.fakeNode = render.attachNewNode("fakeNode")
self.initFakeGui()
self.playIntroLevelMusic()
self.initBullet()
self.initScore()
self.initCollisions()
self.loadPlayer()
self.createCamera(self.player.np)
self.parseLevelFile("Home")
self.getLevelBounds()
self.startTime()
self.createLight()
self.loadSkyBox()
self.loadControls()
#self.parseStory()
colour = (0.5,0.8,0.8)
expfog = Fog("Scene-wide exponential Fog object")
expfog.setColor(*colour)
expfog.setExpDensity(0.0005)
render.setFog(expfog)
base.setBackgroundColor(*colour)
base.camLens.setFar(1000)
def playIntroLevelMusic(self):
self.music = Music("play","./sounds/batfeet.mp3", .1, True)
def getLevelBounds(self):
self.levelNodeBounds = render.find("renderDummy").getBounds()
def parseStory(self):
self.story = StoryParser("./stories/Story.txt")
def searchDirectories(self):
for root, dirs, files in os.walk("./"):
for name in files:
if name.endswith((".txt")):
print(name)
for name in dirs:
if name == "textures":
for root, dirs, files in os.walk(name):
for name in files:
if name.endswith(".jpg"):
print(name)
def initFakeGui(self):
self.menuBar = OnscreenImage(image = './graphics/MenuBar.png', pos = (0,0,-.94))
self.userText = OnscreenText(text = self.user, pos = (-1.05, -.9625), scale = 0.1)
self.menuBar.setScale(1.625, 1, .0625)
def initScore(self):
self.scoreHandler = ScoreHandler()
def initCollisions(self):
self.collisions = pCollisions(self.scoreHandler, self.music)
def parseLevelFile(self, arg):
if arg == "Home":
self.parsedLevel = LevelParser("./levels/HomeLevel.txt", self.collisions, self.player.np, self.world, self.scoreHandler)
def startTime(self):
self.time = KeepTime()
def initBullet(self):
self.world.setGravity(Vec3(0, 0, -9.81))
self.debugNode = BulletDebugNode('Debug')
self.debugNode.showWireframe(True)
self.debugNode.showConstraints(True)
self.debugNode.showBoundingBoxes(False)
self.debugNode.showNormals(False)
self.debugNP = render.attachNewNode(self.debugNode)
self.world.setDebugNode(self.debugNP.node())
def loadSkyBox(self):
self.skyBox = SkyBox("Box")
def createCamera(self, nodePath):
self.camera = gameCamera(nodePath, self.world, self.collisions)
def loadControls(self):
#args order = bullet update loop, bullet debug node, camera, windowProps, player class, spotLightNode, windowProps, timerTask, bulletWorld, collisions#
self.controlHandler = ControlHandler(self.update, self.debugNP, self.camera, self.wp, self.player, self.time.timerTask, self.world, self.collisions, self.music)
def loadPlayer(self):
self.player = Player(self.collisions, "sphere", self.world, self.music, self.scoreHandler)
#self.player = Player("sphere", self.world, 0, 0, 16)
def createLight(self):
self.lightSource = GameLight(self.player.np)
def update(self, task):
##############################################
# #BULLET UPDATE# #
##############################################
dt = globalClock.getDt()
#self.dtTimer()
self.world.doPhysics(dt*2, 7)
#############################################
# #CAMERA UPDATE# #
#############################################
self.camera.cn.setPos(self.player.np.getPos())
#self.fakeNode.setPos(self.player.np.getPos())
self.camera.hNode.setPos(self.player.np.getPos())
self.camera.pNode.setPos(self.player.np.getPos())
self.camera.cn.setP(self.camera.pNode.getP())
self.camera.cn.setH(self.camera.hNode.getH())
pointer = base.win.getPointer(0)
pointerX = pointer.getX()
pointerY = pointer.getY()
if base.win.movePointer(0, base.win.getXSize()/2, base.win.getYSize ()/2):
if self.camera.inverted == "yes":
Pitch = -((pointerY - base.win.getYSize()/2)*.1)
else:
Pitch = ((pointerY - base.win.getYSize()/2)*.1)
Heading = -((pointerX - base.win.getXSize()/2)*.1)
#endValue = 0
#endValue += Pitch
self.camera.pNode.setP(self.camera.pNode, Pitch)
self.camera.hNode.setH(self.camera.hNode, Heading)
#self.fakeNode.setH(self.fakeNode, Heading)
#############################################
# #PLAYER UPDATE# #
#############################################
force = Vec3(0, 0, 0)
if inputState.isSet('up'):
force.setY(10.0)
if inputState.isSet('down'):
force.setY(-10.0)
if inputState.isSet('left'):
force.setX(-10.0)
if inputState.isSet('right'):
force.setX(10.0)
#force *= 10
force = render.getRelativeVector(self.camera.cn, force)
self.player.np.node().setActive(True)
self.player.np.node().applyCentralForce(force)
#self.player.np.setColor(random.random(), random.random(), random.random(), random.random())
if self.player.np.getZ() < 0 - (self.levelNodeBounds.getRadius() * 6):
self.player.np.setPos(self.collisions.level.spawn)
self.player.np.node().setLinearVelocity(Vec3(0,0,0))
return task.cont
def __init__(self, screen_size=84, DEBUGGING=False):
ShowBase.__init__(self)
self.render_stuff = True
self.actions = 3
self.render.setShaderAuto()
self.cam.setPos(0, 0, 7)
self.cam.lookAt(0, 0, 0)
wp = WindowProperties()
window_size = screen_size
wp.setSize(window_size, window_size)
self.win.requestProperties(wp)
# Create Ambient Light
self.ambientLight = AmbientLight('ambientLight')
self.ambientLight.setColor((0.2, 0.2, 0.2, 1))
self.ambientLightNP = self.render.attachNewNode(self.ambientLight)
self.render.setLight(self.ambientLightNP)
# Spotlight
self.light = Spotlight('light')
self.light.setColor((0.9, 0.9, 0.9, 1))
self.lightNP = self.render.attachNewNode(self.light)
self.lightNP.setPos(0, 10, 10)
self.lightNP.lookAt(0, 0, 0)
self.lightNP.node().getLens().setFov(40)
self.lightNP.node().getLens().setNearFar(10, 100)
self.lightNP.node().setShadowCaster(True, 1024, 1024)
self.render.setLight(self.lightNP)
self.world = BulletWorld()
self.world.setGravity(Vec3(0, 0, -9.81))
if DEBUGGING is True:
debugNode = BulletDebugNode('Debug')
debugNode.showWireframe(True)
debugNode.showConstraints(True)
debugNode.showBoundingBoxes(False)
debugNode.showNormals(False)
debugNP = render.attachNewNode(debugNode)
debugNP.show()
self.world.setDebugNode(debugNP.node())
# Reward zone
self.rzone_shape = BulletBoxShape(Vec3(.8, 1, 0.5))
self.rzone_ghost = BulletGhostNode('Reward Zone')
self.rzone_ghost.addShape(self.rzone_shape)
self.rzone_ghostNP = self.render.attachNewNode(self.rzone_ghost)
self.rzone_ghostNP.setPos(2.2, 0.0, 0.86)
self.rzone_ghostNP.setCollideMask(BitMask32(0x0f))
self.world.attachGhost(self.rzone_ghost)
# Needed for camera image
self.dr = self.camNode.getDisplayRegion(0)
# Needed for camera depth image
winprops = WindowProperties.size(self.win.getXSize(),
self.win.getYSize())
fbprops = FrameBufferProperties()
fbprops.setDepthBits(1)
self.depthBuffer = self.graphicsEngine.makeOutput(
self.pipe, "depth buffer", -2, fbprops, winprops,
GraphicsPipe.BFRefuseWindow, self.win.getGsg(), self.win)
self.depthTex = Texture()
self.depthTex.setFormat(Texture.FDepthComponent)
self.depthBuffer.addRenderTexture(self.depthTex,
GraphicsOutput.RTMCopyRam,
GraphicsOutput.RTPDepth)
lens = self.cam.node().getLens()
# the near and far clipping distances can be changed if desired
# lens.setNear(5.0)
# lens.setFar(500.0)
self.depthCam = self.makeCamera(self.depthBuffer,
lens=lens,
scene=render)
self.depthCam.reparentTo(self.cam)
