Пример #1
0
class HLodDynamicObject(NodePath):
    def __init__(self, name, scene, visibleLODsDict={"eggfileName":("maxFar","minNear")}, collisionEgg=None, x0=0, y0=0, z0=0, parent=None, margin=0.02, mass=0,
                 directRender=True, convex=True):
        self.name = name
        self.scene = scene
        NodePath.__init__(self,LODNode(name+"_LODNode"))
        ###LOD###
        for k in visibleLODsDict.keys():
            v=base.loader.loadModel(k)
            v.reparentTo(self)
            self.node().addSwitch(visibleLODsDict[k][0],visibleLODsDict[k][1])
        #########
        self.body = BulletRigidBodyNode(self.name + "_RigidBody")
        self.attachNewNode(self.body)
        if collisionEgg != None:
            m = self.scene.Base.loader.loadModel(collisionEgg)
            if convex:
                sTuple = modelToConvex(m)
            else:
                sTuple = modelToShape(m)
            sTuple[0].setMargin(margin)
            self.body.addShape(sTuple[0], sTuple[1])
            self.body.setMass(mass)
            self.body.setPythonTag("name", self.name + "_RigidBody")
            self.scene.world.attachRigidBody(self.body)
        self.setPos(x0, y0, z0)
        if directRender:
            self.reparentTo(self.scene.Base.render)
        elif parent != None:
            self.reparentTo(parent)
Пример #2
0
class Modulo(object):
    def __init__(self, world, x, y, w, h, parent_node):
        self._model = None
        self._initPhysics(world, x, y, w, h, parent_node)
        self._loadModel(x, y, h)

    def remove(self):
        if self._model is not None:
            self._model.remove()

    def _loadModel(self, x, y, h):
        self._model = loader.loadModel("../data/models/modulo.egg")
        self._model.setPos(0, 0, 0)
        self._model.reparentTo(self._modulo_node)

    def _initPhysics(self, world, x, y, w, h, parent_node):
        shape = BulletBoxShape(Vec3(w * 0.5, w * 0.5, h * 0.5))
        self._rb_node = BulletRigidBodyNode('Box')
        self._rb_node.setMass(0)
        self._rb_node.addShape(shape)
        #self._rb_node.setAngularFactor(Vec3(0,0,0))
        #self._rb_node.setDeactivationEnabled(False, True)
        world.attachRigidBody(self._rb_node)

        self._modulo_node = parent_node.attachNewNode(self._rb_node)
        self._modulo_node.setPos(x, y, h / 2.0)
Пример #3
0
 def genHand(self, handz=100.0):
     # fgr0
     boxx = 5.0
     boxy = 2.0
     boxz = 20.0
     boxpx = 0.0
     boxpy = 10.0
     boxpz = handz
     shape = BulletBoxShape(Vec3(boxx, boxy, boxz))  # the parameters are half extends
     node = BulletRigidBodyNode('fgr0')
     node.addShape(shape)
     node.setTransform(TransformState.makePos(VBase3(boxpx, boxpy, boxpz)))
     self.bltWorld.attachRigidBody(node)
     base.pggen.plotBox(self.base.render, pos=[boxpx, boxpy, boxpz], x=boxx * 2.0, y=boxy * 2.0, z=boxz * 2.0, rgba=None)
     # fgr1
     boxx = 5.0
     boxy = 2.0
     boxz = 20.0
     boxpx = 0.0
     boxpy = -10.0
     boxpz = handz
     shape = BulletBoxShape(Vec3(boxx, boxy, boxz))  # the parameters are half extends
     node = BulletRigidBodyNode('fgr1')
     node.addShape(shape)
     node.setTransform(TransformState.makePos(VBase3(boxpx, boxpy, boxpz)))
     self.bltWorld.attachRigidBody(node)
     base.pggen.plotBox(self.base.render, pos=[boxpx, boxpy, boxpz], x=boxx * 2.0, y=boxy * 2.0, z=boxz * 2.0, rgba=None)
Пример #4
0
class Ball(object):
  def __init__(self, render, world, loader, player):
    self.render = render
    self.world = world
    self.loader = loader
    self.player = player
    self.dropHeight = 5
    self.createItem()
  
  def createItem(self):
    self.collisionShape = BulletSphereShape(0.5)
    self.actor = BulletRigidBodyNode('Ball')
    self.actor.setMass(5.0)
    self.actor.addShape(self.collisionShape)
    self.np = self.render.attachNewNode(self.actor)
    self.np.setCollideMask(BitMask32.allOff())
    
    self.x = self.player.getCharacterNP().getX()
    self.y = self.player.getCharacterNP().getY()
    self.z = self.player.getCharacterNP().getZ() + self.dropHeight
    
    self.np.setPos(self.x, self.y, self.z)
    self.world.attachRigidBody(self.actor)
    
    self.actorModelNP = self.loader.loadModel('models/sphere/ball.egg')
    self.actorModelNP.reparentTo(self.np)
    self.actorModelNP.setScale(0.5)
    self.actorModelNP.setPos(0, 0, 0)

  def getActor(self):
    return self.actor
  
  def getNP(self):
    return self.np
Пример #5
0
 def genHand(self, handz=100.0):
     # fgr0
     boxx = 5.0
     boxy = 2.0
     boxz = 20.0
     boxpx = 0.0
     boxpy = 10.0
     boxpz = handz
     shape = BulletBoxShape(Vec3(boxx, boxy, boxz))  # the parameters are half extends
     node = BulletRigidBodyNode('fgr0')
     node.addShape(shape)
     node.setTransform(TransformState.makePos(VBase3(boxpx, boxpy, boxpz)))
     self.bltWorld.attachRigidBody(node)
     pg.plotBox(self.base.render, pos=[boxpx, boxpy, boxpz], x=boxx * 2.0, y=boxy * 2.0, z=boxz * 2.0, rgba=None)
     # fgr1
     boxx = 5.0
     boxy = 2.0
     boxz = 20.0
     boxpx = 0.0
     boxpy = -10.0
     boxpz = handz
     shape = BulletBoxShape(Vec3(boxx, boxy, boxz))  # the parameters are half extends
     node = BulletRigidBodyNode('fgr1')
     node.addShape(shape)
     node.setTransform(TransformState.makePos(VBase3(boxpx, boxpy, boxpz)))
     self.bltWorld.attachRigidBody(node)
     pg.plotBox(self.base.render, pos=[boxpx, boxpy, boxpz], x=boxx * 2.0, y=boxy * 2.0, z=boxz * 2.0, rgba=None)
Пример #6
0
def rayHit(pfrom, pto, geom):
    """
    NOTE: this function is quite slow
    find the nearest collision point between vec(pto-pfrom) and the mesh of nodepath

    :param pfrom: starting point of the ray, Point3
    :param pto: ending point of the ray, Point3
    :param geom: meshmodel, a panda3d datatype
    :return: None or Point3

    author: weiwei
    date: 20161201
    """

    bulletworld = BulletWorld()
    facetmesh = BulletTriangleMesh()
    facetmesh.addGeom(geom)
    facetmeshnode = BulletRigidBodyNode('facet')
    bullettmshape = BulletTriangleMeshShape(facetmesh, dynamic=True)
    bullettmshape.setMargin(0)
    facetmeshnode.addShape(bullettmshape)
    bulletworld.attachRigidBody(facetmeshnode)
    result = bulletworld.rayTestClosest(pfrom, pto)

    if result.hasHit():
        return result.getHitPos()
    else:
        return None
Пример #7
0
def genCollisionMeshNp(nodepath, basenodepath=None, name='autogen'):
    """
    generate the collision mesh of a nodepath using nodepath
    this function suppose the nodepath is a single model with one geomnode

    :param nodepath: the panda3d nodepath of the object
    :param basenodepath: the nodepath to compute relative transform, identity if none
    :param name: the name of the rigidbody
    :return: bulletrigidbody

    author: weiwei
    date: 20161212, tsukuba
    """

    geomnodepath = nodepath.find("**/+GeomNode")
    geombullnode = BulletRigidBodyNode(name)
    geom = geomnodepath.node().getGeom(0)
    geomtf = nodepath.getTransform(base.render)
    if basenodepath is not None:
        geomtf = nodepath.getTransform(basenodepath)
    geombullmesh = BulletTriangleMesh()
    geombullmesh.addGeom(geom)
    bullettmshape = BulletTriangleMeshShape(geombullmesh, dynamic=True)
    bullettmshape.setMargin(0)
    geombullnode.addShape(bullettmshape, geomtf)
    return geombullnode
Пример #8
0
def genCollisionMeshMultiNp(nodepath, basenodepath=None, name='autogen'):
    """
    generate the collision mesh of a nodepath using nodepath
    this function suppose the nodepath has multiple models with many geomnodes

    use genCollisionMeshMultiNp instead of genCollisionMeshNp for generality

    :param nodepath: the panda3d nodepath of the object
    :param basenodepath: the nodepath to compute relative transform, identity if none
    :param name: the name of the rigidbody
    :return: bulletrigidbody

    author: weiwei
    date: 20161212, tsukuba
    """

    gndcollection = nodepath.findAllMatches("**/+GeomNode")
    geombullnode = BulletRigidBodyNode(name)
    for gnd in gndcollection:
        geom = gnd.node().getGeom(0)
        geomtf = gnd.getTransform(base.render)
        if basenodepath is not None:
            geomtf = gnd.getTransform(basenodepath)
        geombullmesh = BulletTriangleMesh()
        geombullmesh.addGeom(geom)
        bullettmshape = BulletTriangleMeshShape(geombullmesh, dynamic=True)
        bullettmshape.setMargin(0)
        geombullnode.addShape(bullettmshape, geomtf)
    return geombullnode
    def demoContinue(self):
        if self.newObjects < self.NrObjectToDrop:

            node = BulletRigidBodyNode('Box')
            node.setMass(1.0)
            node.addShape(self.shape)
            np = self.rbcnp.attachNewNode(node)
            np.setPos(self.spawnNP.getPos(render))
            np.setHpr(randint(-45, 45), randint(-45, 45), randint(-45, 45))
            self.world.attachRigidBody(node)

            bNP = self.model.copyTo(np)
            #bNP.setPos(self.spawnNP.getPos())
            #bNP.setColor(random(), random(), random(), 1)
            #bNP.setHpr(randint(-45, 45), randint(-45, 45), randint(-45, 45))
            #self.setUntextured(bNP)
            #bNP.setTexureOff()
            #np.setScale(10)
            np.flattenStrong()

            self.objects.append(np)
            self.newObjects += 1
            self.rbcnp.node().collect()

        if self.newObjects < self.NrObjectToDrop:
            return False
        else:
            self.running = False
            return True
    def __init__(self):
        PhysicsNodePath.__init__(self, 'can')

        self.shapeGroup = BitMask32.allOn()

        sph = BulletBoxShape(Vec3(2, 2, 2))
        rbnode = BulletRigidBodyNode('can_body')
        rbnode.setMass(100.0)
        rbnode.addShape(sph, TransformState.makePos(Point3(0, 0, 1)))
        rbnode.setCcdMotionThreshold(1e-7)
        rbnode.setCcdSweptSphereRadius(0.5)

        self.mdl = loader.loadModel("phase_5/models/props/safe-mod.bam")
        self.mdl.setScale(6)
        self.mdl.setZ(-1)
        self.mdl.reparentTo(self)
        self.mdl.showThrough(CIGlobals.ShadowCameraBitmask)

        self.setupPhysics(rbnode)

        #self.makeShadow(0.2)

        self.reparentTo(render)
        self.setPos(base.localAvatar.getPos(render) + (0, 0, 20))
        self.setQuat(base.localAvatar.getQuat(render))
    def __init__(self):
        PhysicsNodePath.__init__(self, 'can')

        self.shapeGroup = BitMask32.allOn()

        sph = BulletCylinderShape(0.5, 1.2, ZUp)
        rbnode = BulletRigidBodyNode('can_body')
        rbnode.setMass(10.0)
        rbnode.addShape(sph)
        rbnode.setCcdMotionThreshold(1e-7)
        rbnode.setCcdSweptSphereRadius(0.5)

        self.mdl = loader.loadModel("phase_5/models/props/can.bam")
        self.mdl.setScale(11.0)
        self.mdl.setZ(-0.55)
        self.mdl.reparentTo(self)
        self.mdl.showThrough(CIGlobals.ShadowCameraBitmask)

        self.setupPhysics(rbnode)

        #self.makeShadow(0.2)

        self.reparentTo(render)
        self.setPos(base.localAvatar.getPos(render))
        self.setQuat(base.localAvatar.getQuat(render))

        dir = self.getQuat(render).xform(Vec3.forward())
        amp = 10
        self.node().setLinearVelocity(dir * amp)
Пример #12
0
class RocketPhys(Phys):
    def __init__(self, mdt, parent):
        Phys.__init__(self, mdt)
        self.parent = parent

    def fire(self):
        self.node = BulletRigidBodyNode('Box')
        self.node.setMass(10000)
        self.node.addShape(BulletSphereShape(.5))
        self.np = self.parent.attachNewNode(self.node)
        self.np.setPos(0, 0, 1.5)
        eng.attach_rigid_body(self.node)
        self.mdt.gfx.gfx_np.reparentTo(self.np)
        self.mdt.gfx.gfx_np.setPos(0, 0, 0)
        rot_mat = Mat4()
        rot_mat.setRotateMat(self.parent.get_h(), (0, 0, 1))
        self.node.setLinearVelocity(rot_mat.xformVec((0, 30, 0)))
        # continue to apply after firing

    def destroy(self):
        if hasattr(self, 'node'):  # has not been fired
            eng.remove_rigid_body(self.node)
            self.np = self.np.remove_node()
        self.parent = None
        Phys.destroy(self)
Пример #13
0
class DynamicNp(DynamicObject):
	def __init__(self, name, model, game, pos):
		self.name = name
		self.game = game
		
		self.model = model
		self.geomNode = self.model.node()
		self.geom = self.geomNode.getGeom(0)
		
		# with triangle mesh it crashes
		#mesh = BulletTriangleMesh()
		#mesh.addGeom(self.geom)
		#self.shape = BulletTriangleMeshShape(mesh, dynamic=True)
		
		# with convex hull
		self.shape = BulletConvexHullShape()
		self.shape.addGeom(self.geom)
		
		self.node = BulletRigidBodyNode(self.name)
		self.node.setMass(10.0)
		self.node.addShape(self.shape)
		
		self.np = self.game.render.attachNewNode(self.node)
		self.np.setPos(pos)
		self.game.world.attachRigidBody(self.node)
		
		self.model.reparentTo(self.np)
		
		self.node.setCcdMotionThreshold(1e-7)
		self.node.setCcdSweptSphereRadius(0.5)
		self.slice_able = True
Пример #14
0
    def init_objects(self):

        # Make Playfer Box
        shape = BulletBoxShape(Vec3(0.25, 0.25, 0.25))
        node = BulletRigidBodyNode('Playfer Box')
        node.setMass(110.0)
        node.setFriction(1.0)
        node.addShape(shape)
        node.setAngularDamping(0.0)
        np = render.attachNewNode(node)
        np.setPos(-1.4, 1.7, -1.7)
        self.world.attachRigidBody(node)
        playferboxmodel = loader.loadModel('../data/mod/playferbox.egg')
        playferboxmodel.reparentTo(np)

        # Make Pendlepot
        shape = BulletBoxShape(Vec3(0.2, 0.15, 0.1))
        node = BulletRigidBodyNode('Pendlepot')
        node.setMass(5.0)
        node.setFriction(1.0)
        node.addShape(shape)
        node.setAngularDamping(0.0)
        np = render.attachNewNode(node)
        np.setPos(-1.4, 1.7, -1.5)
        self.world.attachRigidBody(node)
        pendlepotmodel = loader.loadModel('../data/mod/pendlepot.egg')
        pendlepotmodel.reparentTo(np)
Пример #15
0
class DynamicModel(DynamicObject):
	def __init__(self, name, modelPath, game, pos):
		self.name = name
		self.modelPath = modelPath
		self.game = game
		
		self.model = self.game.loader.loadModel(self.modelPath)
		geomNodes = self.model.findAllMatches('**/+GeomNode')
		self.geomNode = geomNodes.getPath(0).node()
		self.geom = self.geomNode.getGeom(0)
		self.shape = BulletConvexHullShape()
		self.shape.addGeom(self.geom)
		
		self.node = BulletRigidBodyNode(self.name)
		self.node.setMass(10.0)
		self.node.addShape(self.shape)
		
		self.np = self.game.render.attachNewNode(self.node)
		self.np.setPos(pos)
		self.game.world.attachRigidBody(self.node)
		
		self.model.reparentTo(self.np)
		
		self.node.setCcdMotionThreshold(1e-7)
		self.node.setCcdSweptSphereRadius(0.5)
		self.slice_able = True
Пример #16
0
    def createBody(self, _count, _type, _pos=(0, 0, 0)):
        radius = 0.4
        shape = BulletSphereShape(radius)

        name = _type + "Dude" + str(_count)

        node = BulletRigidBodyNode(name)
        node.setMass(2.0)
        node.addShape(shape)
        #node.setDeactivationEnabled(False)
        np = render.attachNewNode(node)
        np.setCollideMask(BitMask32.allOn())

        self.parent.physics_world.attachRigidBody(node)

        np.setPos(_pos)

        #model = loader.loadModel("assets/dude")
        #model.reparentTo(np)
        #model.setScale(0.4)

        dudeID = [1, 2, 3]
        tex = loader.loadTexture("dudes/dude{}_good.png".format(
            choice(dudeID)))
        cm = CardMaker('spritesMaker')
        sprite = NodePath(cm.generate())
        sprite.setTexture(tex)
        sprite.reparentTo(np)
        sprite.setPos(-0.4, 0, -0.4)
        sprite.setCompass(render)
        sprite.setTransparency(1)
        sprite.setScale(0.8)

        return name, np
Пример #17
0
def genBulletCDMeshList(objcmlist, basenodepath=None, name='autogen'):
    """
    generate the collision mesh of a nodepath using nodepathlist
    this function suppose the nodepathlist is a list of models with many geomnodes
    "Multi" means each nodepath in the nodepath list may have multiple nps (parent-child relations)

    use genCollisionMeshMultiNp instead if the meshes have parent-child relations

    :param nodepathlist: panda3d nodepathlist
    :param basenodepath: the nodepath to compute relative transform, identity if none
    :param name: the name of the rigidbody
    :return: bulletrigidbody

    author: weiwei
    date: 20190514
    """

    geombullnode = BulletRigidBodyNode(name)
    for objcm in objcmlist:
        gndcollection = objcm.objnp.findAllMatches("+GeomNode")
        for gnd in gndcollection:
            geom = copy.deepcopy(gnd.node().getGeom(0))
            geomtf = gnd.getTransform(base.render)
            if basenodepath is not None:
                geomtf = gnd.getTransform(basenodepath)
            geombullmesh = BulletTriangleMesh()
            geombullmesh.addGeom(geom)
            bullettmshape = BulletTriangleMeshShape(geombullmesh, dynamic=True)
            bullettmshape.setMargin(0)
            geombullnode.addShape(bullettmshape, geomtf)
    return geombullnode
Пример #18
0
class DynamicPlatform(DynamicObject):
	def __init__(self, name, game, x, y, z, pos):
		self.name = name
		self.game = game
		self.shape = BulletBoxShape(Vec3(x, y, z))
		self.node = BulletRigidBodyNode(self.name)
		self.node.addShape(self.shape)
		
		self.np = self.game.render.attachNewNode(self.node)
		self.np.setPos(pos)
		self.game.world.attachRigidBody(self.node)
		#self.model = self.game.loader.loadModel("models/crate.egg")
		#self.model.reparentTo(self.np)
		
		self.node.setCcdMotionThreshold(1e-7)
		self.node.setCcdSweptSphereRadius(0.5)
		#self.node.setFriction(5)
		#self.debugOff()
		self.speedVec = Vec3(0,0,0)
		self.lastPos = Vec3(self.getPos())
		self.slice_able = False
		#self.node.setCcdMotionThreshold(1e-7)
		#self.node.setCcdSweptSphereRadius(0.5)
		
	def update(self, dt):
		return
Пример #19
0
def genBulletBoxes(env,world):
    boxes = list()
    for np in listNodes(env,"Collision_box_"):
        geom = np.node().getGeom(0)
        # get the minimum and maximum points
        vdata = geom.getVertexData()
        vertices = GeomVertexReader(vdata,'vertex')
        vmin = LPoint3()
        vmax = LPoint3()
        np.calcTightBounds(vmin,vmax)
        #Create the bullet box with center at (0,0)
        norm = vmax-vmin
        hnorm = LVecBase3(norm[0]*.5,norm[1]*.5,norm[2]*.5)
        shape = BulletBoxShape(hnorm)
        # create the surrounding nodes
        node = BulletRigidBodyNode('env')
        node.addShape(shape)
        enp = env.attachNewNode(node)
        enp.setPos(vmin+hnorm)
        # attach it to the world and save it for later
        world.attachRigidBody(node)
        boxes.append(enp.node())
        # clean up the environment higherarchy
        np.removeNode()
    return boxes
Пример #20
0
    def setupPhysics(self, radius=None, height=None):
        if not radius:
            radius = self.getWidth()
        if not height:
            height = self.getHeight()
        self.notify.debug("setupPhysics(r{0}, h{1}) hitboxData: {2}".format(
            radius, height, self.hitboxData))

        # When the height is passed into BulletCapsuleShape, it's
        # talking about the height only of the cylinder part.
        # But what we want is the height of the entire capsule.
        #height -= (radius * 2)
        # The middle of the capsule is the origin by default. Push the capsule shape up
        # so the very bottom of the capsule is the origin.
        zOfs = (height / 2.0) + radius

        capsule = BulletCapsuleShape(radius, height)
        bodyNode = BulletRigidBodyNode('avatarBodyNode')
        bodyNode.addShape(capsule, TransformState.makePos(Point3(0, 0, zOfs)))
        bodyNode.setKinematic(True)
        bodyNode.setPythonTag("avatar", self)

        BasePhysicsObject.setupPhysics(self, bodyNode, True)

        self.stopWaterCheck()
Пример #21
0
class StaticTerrain(BulletObject):
    def __init__(self, game, imgPath, height):
        self.game = game
        self.img = PNMImage(Filename(imgPath))
        self.shape = BulletHeightfieldShape(self.img, height, 2)
        self.node = BulletRigidBodyNode('Ground')
        self.node.addShape(self.shape)

        self.np = self.game.render.attachNewNode(self.node)
        self.np.setPos(0, 0, 0)
        self.np.setScale(1, 1, 1)
        self.game.world.attachRigidBody(self.node)

        self.terrain = GeoMipTerrain('terrain')
        self.terrain.setHeightfield(self.img)
        self.terrain.generate()
        self.terrainNP = self.terrain.getRoot()
        self.offset = self.img.getXSize() / 2.0 - 0.5
        self.terrainNP.setSz(height)
        self.terrainNP.setPos(-self.offset, -self.offset, -height / 2.0)
        #self.terrainNP.flattenStrong()
        self.terrainNP.reparentTo(self.np)

        self.terrainNP.show()
        self.debugOff()
        self.slice_able = False

        self.terrain.setBlockSize(32)
        self.terrain.setNear(100)
        self.terrain.setFar(400)
        self.terrain.setFocalPoint(self.game.playerNp)

    def update(self, dt=0.1):
        self.terrain.update()
Пример #22
0
    def __init__(self):
        ShowBase.__init__(self)
        loadPrcFileData('', 'bullet-enable-contact-events true')

        world = BulletWorld()
        self.world = world
        world.setGravity(Vec3(0, 0, -9.81))
        base.cam.setPos(0,-50,1)

        # Cameras
        base.camNode.setActive(0)
        self.cam1 = base.makeCamera(base.win, displayRegion=(0,.5,0.5,1))
        self.cam2 = base.makeCamera(base.win, displayRegion=(.5,1,0.5,1))
        self.cam1.setPos(-10,-50,1)
        self.cam2.setPos(10,-50,1)
        # base.camList[0].setPos(0,-100, 1)

        # Plane
        shape = BulletPlaneShape(Vec3(0, 0, 1), 1)
        node = BulletRigidBodyNode('Ground')
        node.addShape(shape)
        np = render.attachNewNode(node)
        np.setPos(0, 0, 0)
        self.world.attachRigidBody(node)
        scene = loader.loadModel('Ground2/Ground2')
        scene.reparentTo(render)
        self.newGame()

        taskMgr.add(self.update, 'update')
Пример #23
0
class DynamicModel(DynamicObject):
    def __init__(self, name, modelPath, game, pos):
        self.name = name
        self.modelPath = modelPath
        self.game = game

        self.model = self.game.loader.loadModel(self.modelPath)
        geomNodes = self.model.findAllMatches('**/+GeomNode')
        self.geomNode = geomNodes.getPath(0).node()
        self.geom = self.geomNode.getGeom(0)
        self.shape = BulletConvexHullShape()
        self.shape.addGeom(self.geom)

        self.node = BulletRigidBodyNode(self.name)
        self.node.setMass(10.0)
        self.node.addShape(self.shape)

        self.np = self.game.render.attachNewNode(self.node)
        self.np.setPos(pos)
        self.game.world.attachRigidBody(self.node)

        self.model.reparentTo(self.np)

        self.node.setCcdMotionThreshold(1e-7)
        self.node.setCcdSweptSphereRadius(0.5)
        self.slice_able = True
Пример #24
0
class DynamicNp(DynamicObject):
    def __init__(self, name, model, game, pos):
        self.name = name
        self.game = game

        self.model = model
        self.geomNode = self.model.node()
        self.geom = self.geomNode.getGeom(0)

        # with triangle mesh it crashes
        #mesh = BulletTriangleMesh()
        #mesh.addGeom(self.geom)
        #self.shape = BulletTriangleMeshShape(mesh, dynamic=True)

        # with convex hull
        self.shape = BulletConvexHullShape()
        self.shape.addGeom(self.geom)

        self.node = BulletRigidBodyNode(self.name)
        self.node.setMass(10.0)
        self.node.addShape(self.shape)

        self.np = self.game.render.attachNewNode(self.node)
        self.np.setPos(pos)
        self.game.world.attachRigidBody(self.node)

        self.model.reparentTo(self.np)

        self.node.setCcdMotionThreshold(1e-7)
        self.node.setCcdSweptSphereRadius(0.5)
        self.slice_able = True
Пример #25
0
 def load_world(self):
     stairwell = loader.loadModel('../data/mod/jcmbstairs.egg')
     stairwell.reparentTo(render)
     stairwell_shape = self.egg_to_BulletTriangleMeshShape(stairwell)
     stairwellnode = BulletRigidBodyNode('stairwell')
     stairwellnode.addShape(stairwell_shape)
     self.world.attachRigidBody(stairwellnode)
Пример #26
0
    def newGame(self):

        # Instantiates dabba in the world.
        # Makes it rigid too.
        boxmodel = loader.loadModel("models/misc/rgbCube.egg")
        boxmodel.setPos(-0.5, -0.5, -0.5)
        boxmodel.flattenLight()
        shape3 = BulletBoxShape(Vec3(0.5,0.5,0.5))
        playerNode = BulletRigidBodyNode('Player')
        playerNode.addShape(shape3)
        playerNode.setMass(1.0)
        playerNP = render.attachNewNode(playerNode)
        playerNP.setPos(0, 0, 10)
        playerNP.node().notifyCollisions(True)
        self.playerNP = playerNP
        self.world.attachRigidBody(playerNP.node())
        self.playerNode = playerNode
        boxmodel.copyTo(playerNP)


        # Connects cam to dabba
        self.cam1.reparentTo(playerNP)
        self.cam2.reparentTo(playerNP)
        self.cam1.setPos(1-0.7,-12,0)
        self.cam2.setPos( 1+0.7,-12,0)

        base.accept('u',self.up)
        base.accept('j',self.down)
        base.accept('w',self.forward)
        base.accept('s',self.back)
        base.accept('a',self.rotLeft)
        base.accept('d',self.rotRight)
        base.accept('t',self.rotUp)
        base.accept('g',self.rotDown)
        base.acceptOnce('bullet-contact-added', self.onContactAdded)
	def setupPlayer(self, x, y, z):
		yetiHeight = 7
		yetiRadius = 2
		yetiShape = BulletCapsuleShape(yetiRadius, yetiHeight - 2 * yetiRadius, ZUp)
		
		modelPrefix = "../res/models/yeti_"
		self.yetiModel = Actor("../res/models/yeti.egg", {"idle":"../res/models/yeti_idle.egg", "walk":"../res/models/yeti_walking.egg"})
		self.yetiModel.setH(90)
		self.yetiModel.setPos(0, 0, SNOW_HEIGHT)

		playerNode = BulletRigidBodyNode("Player")
		playerNode.setMass(MASS)
		playerNode.addShape(yetiShape)
		
		# Without this set to 0,0,0, the Yeti would wobble like a Weeble but not fall down.
		playerNode.setAngularFactor(Vec3(0,0,0))

		# Without this disabled, things will weld together after a certain amount of time. It's really annoying.
		playerNode.setDeactivationEnabled(False)
		
		playerNP = self.worldNP.attachNewNode(playerNode)
		playerNP.setPos(x, y, z)
		playerNP.setH(270)
		
		self.yetiModel.reparentTo(playerNP)
		
		self.bulletWorld.attachRigidBody(playerNP.node())
		
		# Hopefully Brandon will get those animation files to me so I can convert them.
		# self.setAnimation('idle')
		
		return playerNP
Пример #28
0
    def construirePlancher(self):
        #Optimisation... on attache les objets statiques au même noeud et on utiliser
        #la méthode flattenStrong() pour améliorer les performances.
        self.noeudOptimisation = NodePath('NoeudOptimisation')
        self.noeudOptimisation.reparentTo(render)

        #Construction du plancher
        # On charge les tuiles qui vont former le plancher
        for i in range(0, self.map_nb_tuile_x):
            for j in range(0, self.map_nb_tuile_y):
                modele = loader.loadModel("../asset/Floor/Floor")
                # Reparentage du modèle à la racine de la scène
                modele.reparentTo(self.noeudOptimisation)
                self.placerSurGrille(modele, i, j)

        #Construction du plancher si on tombe
        #Un plan devrait marche mais j'ai un bug de collision en continu...
        shape = BulletBoxShape(Vec3(50, 50, 5))
        node = BulletRigidBodyNode('Frontfiere sol')
        node.addShape(shape)
        np = render.attachNewNode(node)
        np.setTag("EntiteTankem", "LimiteJeu")
        np.setPos(Vec3(0, 0, -9.0))
        self.mondePhysique.attachRigidBody(node)

        #Construction de l'aire de jeu sur laquelle on joue
        shape = BulletBoxShape(
            Vec3(-self.position_depart_x, -self.position_depart_y, 2))
        node = BulletRigidBodyNode('Plancher')
        node.addShape(shape)
        np = render.attachNewNode(node)
        np.setTag("EntiteTankem", "Plancher")
        HACK_VALUE = 0.02  #Optimisation de collision, les masques ne marchent pas
        np.setZ(-2.00 - HACK_VALUE)
        self.mondePhysique.attachRigidBody(node)
Пример #29
0
class StaticModel(BulletObject):
    def __init__(self, name, modelPath, displayModelPath, game, pos):
        self.name = name
        self.modelPath = modelPath
        self.game = game

        self.model = self.game.loader.loadModel(self.modelPath)
        geomNodes = self.model.findAllMatches('**/+GeomNode')
        self.geomNode = geomNodes.getPath(0).node()
        self.geom = self.geomNode.getGeom(0)

        #self.shape = BulletConvexHullShape()
        #self.shape.addGeom(self.geom)

        mesh = BulletTriangleMesh()
        mesh.addGeom(self.geom)
        self.shape = BulletTriangleMeshShape(mesh, dynamic=False)

        self.node = BulletRigidBodyNode(self.name)
        self.node.addShape(self.shape)

        self.np = self.game.render.attachNewNode(self.node)
        self.np.setPos(pos)
        self.game.world.attachRigidBody(self.node)

        #self.model.reparentTo(self.np)

        self.displayModel = self.game.loader.loadModel(displayModelPath)
        self.displayModel.reparentTo(self.np)
        self.displayModel.setTwoSided(True)
        self.slice_able = False
Пример #30
0
    def newGame(self):
        boxmodel = loader.loadModel("models/box.egg")
        boxmodel.setPos(-0.5, -0.5, -0.5)
        boxmodel.flattenLight()
        shape3 = BulletBoxShape(Vec3(0.5,0.5,0.5))
        playerNode = BulletRigidBodyNode('Player')
        playerNode.addShape(shape3)
        playerNode.setMass(1.0)
        playerNP = render.attachNewNode(playerNode)
        playerNP.setPos(0, 0, 10)
        playerNP.node().notifyCollisions(True)
        self.playerNP = playerNP
        self.world.attachRigidBody(playerNP.node())
        self.playerNode = playerNode
        boxmodel.copyTo(playerNP)

        # self.base.cam.reparentTo(playerNP)
        # base.cam.setPos(0,-10,0)
        self.cam1.reparentTo(playerNP)
        self.cam2.reparentTo(playerNP)

        self.cam1.setPos(-1,-10,0)
        self.cam2.setPos( 1,-10,0)


        base.accept('u',self.up)
        base.accept('w',self.forward)
        base.accept('s',self.back)
        base.accept('a',self.rotLeft)
        base.accept('d',self.rotRight)
        base.accept('t',self.rotUp)
        base.accept('g',self.rotDown)
        base.acceptOnce('bullet-contact-added', self.onContactAdded)
Пример #31
0
class DynamicPlatform(DynamicObject):
    def __init__(self, name, game, x, y, z, pos):
        self.name = name
        self.game = game
        self.shape = BulletBoxShape(Vec3(x, y, z))
        self.node = BulletRigidBodyNode(self.name)
        self.node.addShape(self.shape)

        self.np = self.game.render.attachNewNode(self.node)
        self.np.setPos(pos)
        self.game.world.attachRigidBody(self.node)
        #self.model = self.game.loader.loadModel("models/crate.egg")
        #self.model.reparentTo(self.np)

        self.node.setCcdMotionThreshold(1e-7)
        self.node.setCcdSweptSphereRadius(0.5)
        #self.node.setFriction(5)
        #self.debugOff()
        self.speedVec = Vec3(0, 0, 0)
        self.lastPos = Vec3(self.getPos())
        self.slice_able = False
        #self.node.setCcdMotionThreshold(1e-7)
        #self.node.setCcdSweptSphereRadius(0.5)

    def update(self, dt):
        return
Пример #32
0
def genBulletCDMeshMultiNp(nodepath, basenodepath=None, name='autogen'):
    """
    generate the BulletCD mesh of a nodepath using nodepath
    this function suppose the nodepath has multiple models with many geomnodes

    use genBulletCDMeshMultiNp instead of genBulletCDMeshNp for generality

    :param nodepath: the panda3d nodepath of the object
    :param basenodepath: the nodepath to compute relative transform, identity if none
    :param name: the name of the rigidbody
    :return: bulletrigidbody

    author: weiwei
    date: 20161212, tsukuba
    """

    gndcollection = nodepath.findAllMatches("**/+GeomNode")
    geombullnode = BulletRigidBodyNode(name)
    for gnd in gndcollection:
        geom = gnd.node().getGeom(0)
        geomtf = gnd.getTransform(base.render)
        if basenodepath is not None:
            geomtf = gnd.getTransform(basenodepath)
        geombullmesh = BulletTriangleMesh()
        geombullmesh.addGeom(geom)
        bullettmshape = BulletTriangleMeshShape(geombullmesh, dynamic=True)
        bullettmshape.setMargin(0)
        geombullnode.addShape(bullettmshape, geomtf)
    return geombullnode
Пример #33
0
class StaticTerrain(BulletObject):
	def __init__(self, game, imgPath, height):
		self.game = game
		self.img = PNMImage(Filename(imgPath))
		self.shape = BulletHeightfieldShape(self.img, height, 2)
		self.node = BulletRigidBodyNode('Ground')
		self.node.addShape(self.shape)
		
		self.np = self.game.render.attachNewNode(self.node)
		self.np.setPos(0, 0, 0)
		self.np.setScale(1, 1, 1)
		self.game.world.attachRigidBody(self.node)
		
		self.terrain = GeoMipTerrain('terrain')
		self.terrain.setHeightfield(self.img)
		self.terrain.generate()
		self.terrainNP = self.terrain.getRoot()
		self.offset = self.img.getXSize() / 2.0 - 0.5
		self.terrainNP.setSz(height)
		self.terrainNP.setPos(-self.offset,-self.offset,-height/2.0)
		#self.terrainNP.flattenStrong()
		self.terrainNP.reparentTo(self.np)
		
		self.terrainNP.show()
		self.debugOff()
		self.slice_able = False
		
		self.terrain.setBlockSize(32)
		self.terrain.setNear(100)
		self.terrain.setFar(400)
		self.terrain.setFocalPoint(self.game.playerNp)
	
	def update(self, dt=0.1):
		self.terrain.update()
Пример #34
0
    def getPhysBody(self):
        from panda3d.bullet import BulletRigidBodyNode, BulletBoxShape
        from panda3d.core import TransformState

        bnode = BulletRigidBodyNode('entity-phys')
        bnode.setMass(self.mass)

        bnode.setCcdMotionThreshold(1e-7)
        bnode.setCcdSweptSphereRadius(0.5)

        if self.solidType == self.SOLID_MESH:
            convexHull = PhysicsUtils.makeBulletConvexHullFromCollisionSolids(
                self.model.find("**/+CollisionNode").node())
            bnode.addShape(convexHull)
        elif self.solidType == self.SOLID_BBOX:
            mins = Point3()
            maxs = Point3()
            self.calcTightBounds(mins, maxs)
            extents = PhysicsUtils.extentsFromMinMax(mins, maxs)
            tsCenter = TransformState.makePos(
                PhysicsUtils.centerFromMinMax(mins, maxs))
            shape = BulletBoxShape(extents)
            bnode.addShape(shape, tsCenter)

        return bnode
Пример #35
0
    def build_node_path(self, parent_node_path, bullet_world):
        land_geom = self.__build_land_mesh()
        ocean_geom = self.__build_ocean_mesh()
        land_mesh = BulletTriangleMesh()
        land_mesh.addGeom(land_geom)
        land_shape = BulletTriangleMeshShape(land_mesh, dynamic=False)
        ocean_shape = BulletSphereShape(self.__radius)

        land_bullet_node = BulletRigidBodyNode('land collider')
        land_bullet_node.addShape(land_shape)
        bullet_world.attachRigidBody(land_bullet_node)
        land_bullet_node_path = parent_node_path.attachNewNode(
            land_bullet_node)

        ocean_bullet_node = BulletGhostNode('ocean collider')
        ocean_bullet_node.addShape(ocean_shape)
        bullet_world.attachGhost(ocean_bullet_node)
        ocean_bullet_node_path = land_bullet_node_path.attachNewNode(
            ocean_bullet_node)

        land_node = GeomNode('land')
        land_node.addGeom(land_geom)
        land_node_path = land_bullet_node_path.attachNewNode(land_node)
        ocean_node = GeomNode('ocean')
        ocean_node.addGeom(ocean_geom)
        ocean_node_path = ocean_bullet_node_path.attachNewNode(ocean_node)
        ocean_node_path.setTransparency(TransparencyAttrib.MAlpha)

        self.__node_path = land_bullet_node_path
        land_bullet_node.setPythonTag('planet', self)
        return land_bullet_node_path
Пример #36
0
    def isRayHitMeshAll(self, pfrom, pto, objcm):
        """

        :param pfrom:
        :param pto:
        :param objcm:
        :return:

        author: weiwei
        date: 20190805
        """

        geom = base.pg.packpandageom_fn(objcm.trimesh.vertices,
                                        objcm.trimesh.face_normals,
                                        objcm.trimesh.faces)
        targetobjmesh = BulletTriangleMesh()
        targetobjmesh.addGeom(geom)
        bullettmshape = BulletTriangleMeshShape(targetobjmesh, dynamic=True)
        bullettmshape.setMargin(1e-6)
        targetobjmeshnode = BulletRigidBodyNode('facet')
        targetobjmeshnode.addShape(bullettmshape)
        self.world.attach(targetobjmeshnode)
        result = self.world.rayTestAll(base.pg.npToV3(pfrom),
                                       base.pg.npToV3(pto))
        self.world.removeRigidBody(targetobjmeshnode)
        if result.hasHits():
            allhits = []
            for hit in result.getHits():
                allhits.append([hit.getHitPos(), -hit.getHitNormal()])
            return allhits
        else:
            return []
Пример #37
0
    def _add_side_walk2bullet(self, lane_start, lane_end, middle, radius=0.0, direction=0):
        length = norm(lane_end[0] - lane_start[0], lane_end[1] - lane_start[1])
        body_node = BulletRigidBodyNode(BodyName.Side_walk)
        body_node.setActive(False)
        body_node.setKinematic(False)
        body_node.setStatic(True)
        side_np = self.side_walk_node_path.attachNewNode(body_node)
        shape = BulletBoxShape(Vec3(1 / 2, 1 / 2, 1 / 2))
        body_node.addShape(shape)
        body_node.setIntoCollideMask(BitMask32.bit(Block.LANE_LINE_COLLISION_MASK))
        self.dynamic_nodes.append(body_node)

        if radius == 0:
            factor = 1
        else:
            if direction == 1:
                factor = (1 - self.SIDE_WALK_LINE_DIST / radius)
            else:
                factor = (1 + self.SIDE_WALK_WIDTH / radius) * (1 + self.SIDE_WALK_LINE_DIST / radius)
        direction_v = lane_end - lane_start
        vertical_v = (-direction_v[1], direction_v[0]) / numpy.linalg.norm(direction_v)
        middle += vertical_v * (self.SIDE_WALK_WIDTH / 2 + self.SIDE_WALK_LINE_DIST)
        side_np.setPos(panda_position(middle, 0))
        theta = -numpy.arctan2(direction_v[1], direction_v[0])
        side_np.setQuat(LQuaternionf(numpy.cos(theta / 2), 0, 0, numpy.sin(theta / 2)))
        side_np.setScale(
            length * factor, self.SIDE_WALK_WIDTH, self.SIDE_WALK_THICKNESS * (1 + 0.1 * numpy.random.rand())
        )
        if self.render:
            side_np.setTexture(self.ts_color, self.side_texture)
            self.side_walk.instanceTo(side_np)
Пример #38
0
def bulletRayHit(pfrom, pto, geom):
    """
    NOTE: this function is quite slow
    find the nearest collision point between vec(pto-pfrom) and the mesh of nodepath

    :param pfrom: starting point of the ray, Point3
    :param pto: ending point of the ray, Point3
    :param geom: meshmodel, a panda3d datatype
    :return: None or Point3

    author: weiwei
    date: 20161201
    """

    bulletworld = BulletWorld()
    facetmesh = BulletTriangleMesh()
    facetmesh.addGeom(geom)
    facetmeshnode = BulletRigidBodyNode('facet')
    bullettmshape = BulletTriangleMeshShape(facetmesh, dynamic=True)
    bullettmshape.setMargin(1e-6)
    facetmeshnode.addShape(bullettmshape)
    bulletworld.attach(facetmeshnode)
    result = bulletworld.rayTestClosest(pfrom, pto)

    if result.hasHit():
        return result.getHitPos()
    else:
        return None
Пример #39
0
    def fire(self, shooterPosition, targetPosition):
        print("fire balls")
        # create bullet rigid body node
        sphereBRBN = BulletRigidBodyNode('Ball')
        # set physics properties
        sphereBRBN.setMass(1.0)
        sphereBRBN.addShape(BulletSphereShape(0.2))
        # attach to render and get a nodePath in render hierarchic
        sphere = self.render.attachNewNode(sphereBRBN)

        # set starting position of fire ball
        pos = shooterPosition
        pos.setZ(pos.getZ() + 1)
        sphere.setPos(pos)
        # load texture of fireball and set size then add to nodePath
        smileyFace = self.loader.loadModel("models/smiley")
        smileyFace.setScale(0.2)
        smileyFace.reparentTo(sphere)

        # add rigid body to physics world
        self.world.attachRigidBody(sphereBRBN)
        # apply the force so it moves
        shootingDirection = targetPosition - pos
        shootingDirection.normalize()
        sphereBRBN.applyCentralForce(shootingDirection * 1000)
        self.fireballs.append(sphereBRBN)
        self.cleanUp()
Пример #40
0
class StaticModel(BulletObject):
	def __init__(self, name, modelPath, displayModelPath, game, pos):
		self.name = name
		self.modelPath = modelPath
		self.game = game
		
		self.model = self.game.loader.loadModel(self.modelPath)
		geomNodes = self.model.findAllMatches('**/+GeomNode')
		self.geomNode = geomNodes.getPath(0).node()
		self.geom = self.geomNode.getGeom(0)
		
		#self.shape = BulletConvexHullShape()
		#self.shape.addGeom(self.geom)
		
		mesh = BulletTriangleMesh()
		mesh.addGeom(self.geom)
		self.shape = BulletTriangleMeshShape(mesh, dynamic=False)
		
		self.node = BulletRigidBodyNode(self.name)
		self.node.addShape(self.shape)
		
		self.np = self.game.render.attachNewNode(self.node)
		self.np.setPos(pos)
		self.game.world.attachRigidBody(self.node)
		
		#self.model.reparentTo(self.np)
		
		self.displayModel = self.game.loader.loadModel(displayModelPath)
		self.displayModel.reparentTo(self.np)
		self.displayModel.setTwoSided(True)
		self.slice_able = False
Пример #41
0
    def create_object(self):
        from panda3d.core import Filename, NodePath, BitMask32
        from direct.actor.Actor import Actor
        from panda3d.bullet import BulletRigidBodyNode, BulletCapsuleShape

        from game_system.resources import ResourceManager
        f = Filename.fromOsSpecific(ResourceManager.get_absolute_path(ResourceManager["TestAI"]["lp_char_bs.egg"]))
        model = Actor(f)

        bullet_node = BulletRigidBodyNode("TestAIBulletNode")
        bullet_nodepath = NodePath(bullet_node)

        bullet_node.set_angular_factor((0, 0, 1))

        shape = BulletCapsuleShape(0.3, 1.4, 2)
        bullet_node.addShape(shape)
        bullet_node.setMass(1.0)

        model.reparentTo(bullet_nodepath)
        model.set_hpr(180, 0, 0)
        model.set_pos(0, 0, -1)

        bullet_nodepath.set_collide_mask(BitMask32.bit(0))
        bullet_nodepath.set_python_tag("actor", model)

        return bullet_nodepath
Пример #42
0
    def __init__(self,mainReference):
        
        super(Player, self).__init__(mainReference)
        
        # setting player HP
        self.healthPoints = 100
        
        # fine tuning the camera properties
        self.mainRef.camLens.setFov(50)
        self.mainRef.camLens.setNear(0.02)
        self.mainRef.camLens.setFar(80.0)
        
        self.currentRegionID = 1

        # dummy nodepath for our player; we will attach everything to it
        
        # player bullet node - NOTE: for detecting collision with attacks, only
        playerNode = BulletRigidBodyNode('Player_NP') 
        playerNode.addShape( BulletCapsuleShape(0.3, 1, ZUp) ) # adicionar node no lugar da string
        self.mainRef.world.attachRigidBody(playerNode)
        
        self.playerNP = self.mainRef.render.attachNewNode(playerNode)
        # this collision mask will only avoid CharacterBody collision on itself
        self.playerNP.setCollideMask(BitMask32(0x7FFFFFFF))
        # notify collision contacts
        self.playerNP.node().notifyCollisions(True)
        
        
        self.playerHeadNP = NodePath("empty") # This node is intended to be a placeholder for the camera (maintainability only)
        
        self.playerHeadNP.reparentTo( self.playerNP )
        self.playerHeadNP.setPos(0, 0, 1.35)
                
#        self.mainRef.camera.setPos(0, -4, 0)
        self.mainRef.camera.reparentTo( self.playerHeadNP )
        
        
        # NodePath position
        self.playerNP.setPos(0,0,1.0)
        
        # setting player's character body
        self.playerBody = CharacterBody(self.mainRef, self.playerNP.getPos(), 0.38, 0.5)
        self.playerBody.charBodyNP.reparentTo(self.playerNP) 
        
        # setting our movementHandler
        self.movementHandler = MovementHandler(self.mainRef)
        self.movementHandler.registerFPSMovementInput()
        
        # attach default weapon
        self.activeWeapon = Glock(self.mainRef.camera)
            
        # adding the shoot event
        self.mainRef.accept("mouse1", self.shootBullet)
        
        # adding the reload event
        self.mainRef.accept("mouse3", self.reloadWeapon)
        
        # player boolean to authorize player HP decrease when zombie contact happens
        self.canLoseHP = True
Пример #43
0
	def setupDeathzone(self, height):
		planeShape = BulletPlaneShape(Vec3(0, 0, 1), 1)
		planeNode = BulletRigidBodyNode('DeathZone')
		planeNode.addShape(planeShape)
		planeNP = render.attachNewNode(planeNode)
		planeNP.setPos(0, 0, height)
		self.worldBullet.attachRigidBody(planeNode)
		return planeNP
Пример #44
0
 def addGround(self):
     boxx = 500.0
     boxy = 500.0
     boxz = 1.0
     shape = BulletBoxShape(Vec3(boxx, boxy, boxz)) # the parameters are half extends
     node = BulletRigidBodyNode('Ground')
     node.addShape(shape)
     self.bltWorld.attachRigidBody(node)
     pg.plotBox(self.base.render, pos = [0,0,-1.0], x = boxx*2.0, y = boxy*2.0, z = boxz*2.0, rgba=None)
Пример #45
0
 def initBullet(self):
     self.world = BulletWorld()
     #self.world.setGravity(Vec3(0, 0, -9.81))
     self.world.setGravity(Vec3(0, 0, -1.62))
     
     groundShape = BulletPlaneShape(Vec3(0, 0, 1), 0)
     groundNode = BulletRigidBodyNode('Ground')
     groundNode.addShape(groundShape)
     self.world.attachRigidBody(groundNode)
Пример #46
0
    def createGround(self, terrainData):
        """Create ground using a heightmap"""

        # Create heightfield for physics
        heightRange = terrainData["heightRange"]

        # Image needs to have dimensions that are a power of 2 + 1
        heightMap = PNMImage(self.basePath + terrainData["elevation"])
        xdim = heightMap.getXSize()
        ydim = heightMap.getYSize()
        shape = BulletHeightfieldShape(heightMap, heightRange, ZUp)
        shape.setUseDiamondSubdivision(True)

        np = self.outsideWorldRender.attachNewNode(BulletRigidBodyNode("terrain"))
        np.node().addShape(shape)
        np.setPos(0, 0, 0)
        self.physicsWorld.attachRigidBody(np.node())

        # Create graphical terrain from same height map
        terrain = GeoMipTerrain("terrain")
        terrain.setHeightfield(heightMap)

        terrain.setBlockSize(32)
        terrain.setBruteforce(True)
        rootNP = terrain.getRoot()
        rootNP.reparentTo(self.worldRender)
        rootNP.setSz(heightRange)

        offset = xdim / 2.0 - 0.5
        rootNP.setPos(-offset, -offset, -heightRange / 2.0)
        terrain.generate()

        # Apply texture
        diffuse = self.loader.loadTexture(Filename(self.basePath + terrainData["texture"]))
        diffuse.setWrapU(Texture.WMRepeat)
        diffuse.setWrapV(Texture.WMRepeat)
        rootNP.setTexture(diffuse)
        textureSize = 6.0
        ts = TextureStage.getDefault()
        rootNP.setTexScale(ts, xdim / textureSize, ydim / textureSize)

        # Create planes around area to prevent player flying off the edge
        # Levels can define barriers around them but it's probably a good
        # idea to leave this here just in case
        sides = (
            (Vec3(1, 0, 0), -xdim / 2.0),
            (Vec3(-1, 0, 0), -xdim / 2.0),
            (Vec3(0, 1, 0), -ydim / 2.0),
            (Vec3(0, -1, 0), -ydim / 2.0),
        )
        for sideNum, side in enumerate(sides):
            normal, offset = side
            sideShape = BulletPlaneShape(normal, offset)
            sideNode = BulletRigidBodyNode("side%d" % sideNum)
            sideNode.addShape(sideShape)
            self.physicsWorld.attachRigidBody(sideNode)
def create_colliders(root, pose_rig, joints_config):
    for node, parent in pose_rig.exposed_joints:
        if node.getName() not in joints_config:
            continue

        joint_config = joints_config[node.getName()]
        if "joints" not in joint_config:
            continue

        joints = joint_config["joints"]
        if len(joints) == 0:
            continue

        mass = joint_config["mass"] if "mass" in joint_config else 1

        box_rb = BulletRigidBodyNode(node.getName())
        box_rb.setMass(1.0)
        # box_rb.setLinearDamping(0.2)
        # box_rb.setAngularDamping(0.9)
        # box_rb.setFriction(1.0)
        # box_rb.setAnisotropicFriction(1.0)
        # box_rb.setRestitution(0.0)

        for joint in joints:
            child_node, child_parent = next(
                (child_node, child_parent)
                for child_node, child_parent in pose_rig.exposed_joints
                if child_node.getName() == joint
            )

            pos = child_node.getPos(child_parent)
            width = pos.length() / 2.0
            scale = Vec3(3, width, 3)

            shape = BulletBoxShape(scale)

            quat = Quat()
            lookAt(quat, child_node.getPos(child_parent), Vec3.up())
            if len(joints) > 1:
                transform = TransformState.makePosHpr(child_node.getPos(child_parent) / 2.0, quat.getHpr())
            else:
                transform = TransformState.makeHpr(quat.getHpr())

            box_rb.addShape(shape, transform)

        box_np = root.attachNewNode(box_rb)

        if len(joints) > 1:
            pos = node.getPos(pose_rig.actor)
            hpr = node.getHpr(pose_rig.actor)
            box_np.setPosHpr(root, pos, hpr)
        else:
            box_np.setPos(child_parent, child_node.getPos(child_parent) / 2.0)
            box_np.lookAt(child_parent, child_node.getPos(child_parent))

        yield box_np
Пример #48
0
    def __init__(self, player_tag):
        ShowBase.__init__(self)
        self.__player_tag = player_tag
        self.__rotations = {}

        # Panda pollutes the global namespace.  Some of the extra globals can be referred to in nicer ways
        # (for example self.render instead of render).  The globalClock object, though, is only a global!  We
        # create a reference to it here, in a way that won't upset PyFlakes.
        self.globalClock = __builtins__["globalClock"]

        # Turn off the debugging system which allows the camera to be adjusted directly by the mouse.
        self.disableMouse()

        # Set up physics: the ground plane and the capsule which represents the player.
        self.world = BulletWorld()

        # The ground first:
        shape = BulletPlaneShape(Vec3(0, 0, 1), 0)
        node = BulletRigidBodyNode('Ground')
        node.addShape(shape)
        np = self.render.attachNewNode(node)
        np.setPos(0, 0, 0)
        self.world.attachRigidBody(node)

        # Load the 3dWarehouse model.
        cathedral = self.loader.loadModel("3dWarehouse_Reykjavik_Cathedral.egg")
        cathedral.reparentTo(self.render)
        cathedral.setScale(0.5)

        # Load the Blender model.
        self.humanoid = Actor("player.egg")
        self.humanoid.setScale(0.5)
        self.humanoid.reparentTo(self.render)
        self.humanoid.loop("Walk")

        humanoidPosInterval1 = self.humanoid.posInterval(58, Point3(13, -10, 0), startPos=Point3(13, 10, 0))
        humanoidPosInterval2 = self.humanoid.posInterval(58, Point3(13, 10, 0), startPos=Point3(13, -10, 0))
        humanoidHprInterval1 = self.humanoid.hprInterval(3, Point3(180, 0, 0), startHpr=Point3(0, 0, 0))
        humanoidHprInterval2 = self.humanoid.hprInterval(3, Point3(0, 0, 0), startHpr=Point3(180, 0, 0))

        # Make the Blender model walk up and down.
        self.humanoidPace = Sequence(humanoidPosInterval1, humanoidHprInterval1, humanoidPosInterval2,
                                     humanoidHprInterval2, name="humanoidPace")

        self.humanoidPace.loop()

        # Create a light so we can see the scene.
        dlight = DirectionalLight('dlight')
        dlight.setColor(VBase4(2, 2, 2, 0))
        dlnp = self.render.attachNewNode(dlight)
        dlnp.setHpr(0, -60, 0)
        self.render.setLight(dlnp)

        # Create a task to update the scene regularly.
        self.taskMgr.add(self.update, "UpdateTask")
Пример #49
0
    def createPlane(self):
        rb = BulletRigidBodyNode('Ground')
        rb.addShape(BulletPlaneShape(Vec3(0, 0, 1), 1))
        rb.setFriction(1.0)

        np = self.render.attachNewNode(rb)
        np.setPos(Vec3(0, 0, -100))
        np.setCollideMask(BitMask32.bit(0))

        self.world.attachRigidBody(rb)

        return np
Пример #50
0
 def makePlane(self, num, norm, pos, hpr):
   shape = BulletPlaneShape(norm, 0)
   node = BulletRigidBodyNode('plane_' + str(num))
   node.addShape(shape)
   physics = render.attachNewNode(node)
   physics.setPos(*pos)
   self.world.attachRigidBody(node)
   model = loader.loadModel('models/square')
   model.setScale(10, 10, 10)
   model.setHpr(*hpr)
   model.setTransparency(TransparencyAttrib.MAlpha)
   model.setColor(1, 1, 1, 0.25)
   model.reparentTo(physics)
Пример #51
0
class DynamicBox(DynamicObject):
	def __init__(self, name, game, pos):
		self.name = name
		self.game = game
		self.shape = BulletBoxShape(Vec3(0.5, 0.5, 0.5))
		self.node = BulletRigidBodyNode(name)
		self.node.setMass(10.0)
		self.node.addShape(self.shape)
		self.setFriction(20)
		
		self.np = self.game.render.attachNewNode(self.node)
		self.np.setPos(pos)
		self.game.world.attachRigidBody(self.node)
		self.model = self.game.loader.loadModel("models/crate.egg")
		self.model.reparentTo(self.np)
		
		self.node.setCcdMotionThreshold(1e-7)
		self.node.setCcdSweptSphereRadius(0.5)
		self.debugOff()
		self.slice_able = True
	
	def update(self, dt):
		#self.activate()
		#if self.node.isActive():
		#	return
		contact = self.checkFeet()
		contacts = self.getContacts()
		
		if contact in self.game.objects and contact in contacts:
			obj = self.game.objects[contact]
			if type(obj) is KinematicPlatform:
				self.activate()
				self.setAngularVelocity(self.getAngularVelocity()*0.9)
				self.setFriction(0.1)
				#print "%s is a box sliding on %s" % (self.name, obj.name)
				#self.addSpeedVec(self.game.objects[contact].getSpeedVec())
				#self.setForce(obj.getSpeedVec()*self.node.getMass() * 100)
				platform_speed = obj.getSpeedVec()
				force = platform_speed * self.node.getMass() * 50
				#self.setSpeedXY(platform_speed[0], platform_speed[1])
				self.setSpeedVec(platform_speed)
				#self.setAngularVelocity(0)
				
				#self.node.addLin(obj.getSpeedVec()*self.node.getMass() * 100)
				#self.node.applyCentralForce(force)
				#self.setForce(force)
				#self.setFriction(20)
				#self.setPos(self.getPos() + obj.getSpeedVec())
				#self.node.setActive(False)
			else:
				self.setFriction(20)
Пример #52
0
    def buildConeShape(self, _height, _radius, _pos, _hpr):
        """Build a basic cone shape for the _obj"""
        shape = BulletConeShape(_radius, _height, ZUp)

        body = BulletRigidBodyNode("flashLight")
        body.addShape(shape)

        np = self.engine.BulletObjects["player"].attachNewNode(body)
        np.setPos(_pos)
        np.setHpr(_hpr)
        np.setCollideMask(BitMask32.allOff())

        self.engine.bulletWorld.attachRigidBody(np.node())
        return np
Пример #53
0
    def createPlane(self, pos):
        rb = BulletRigidBodyNode("plane")
        rb.addShape(BulletPlaneShape(Vec3(0, 0, 1), 1))
        rb.setFriction(1.0)
        rb.setAnisotropicFriction(1.0)
        rb.setRestitution(1.0)

        np = self.render.attachNewNode(rb)
        np.setPos(pos)
        np.setCollideMask(BitMask32.bit(0))

        self.world.attachRigidBody(rb)

        return np
Пример #54
0
    def setupFloaters2(self):
        size = Vec3(3.5, 5.5, 0.3)
        randNum = random.sample(range(10, 1500, 500), 3)
        for i in range(3):
            randX = random.randrange(-2, 3, 10)
            randY = float(randNum[i])
            # randY = random.randint(1000, 1500)
            shape = BulletBoxShape(size * 0.55)
            node = BulletRigidBodyNode('Floater')
            node.setMass(0)
            node.addShape(shape)
            np = self.render.attachNewNode(node)
            # np.setPos(9, 30, 3)
            np.setPos(randX, randY, 6)
            np.setR(0)
            self.world2.attachRigidBody(node)

            dummyNp = self.render.attachNewNode('milkyway')
            dummyNp.setPos(randX, randY, 6)

            modelNP = loader.loadModel('models/box.egg')
            modelNP_tex = loader.loadTexture("models/sky/moon_tex.jpg")
            modelNP.setTexture(modelNP_tex, 1)
            modelNP.reparentTo(dummyNp)
            modelNP.setPos(-1, 0, -1)
            modelNP.setPos(-size.x / 2.0, -size.y / 2.0, -size.z / 2.0)
            modelNP.setScale(size)
            dummyNp.hprInterval(2.5, Vec3(360, 0, 0)).loop()

            # Put A Coin On the Floater
            shape = BulletSphereShape(0.75)
            coinNode = BulletGhostNode('FloaterCoin-' + str(i))
            coinNode.addShape(shape)
            np = self.render.attachNewNode(coinNode)
            np.setCollideMask(BitMask32.allOff())
            # np.setPos(randX, randY, 2)
            np.setPos(randX, randY, 7.0)

            # Adding sphere model
            sphereNp = loader.loadModel('models/smiley.egg')
            sphereNp_tex = loader.loadTexture("models/sky/coin_2_tex.jpg")
            sphereNp.setTexture(sphereNp_tex, 1)
            sphereNp.reparentTo(np)
            sphereNp.setScale(0.85)
            sphereNp.hprInterval(1.5, Vec3(360, 0, 0)).loop()

            self.world2.attachGhost(coinNode)
            self.coins2.append(coinNode)
            print "node name:" + str(coinNode.getName())
Пример #55
0
	def renderObject(self,scale,hpr,collisionOn=False):
		(x_scale,y_scale,z_scale) = scale
		(h,p,r) = hpr
		if collisionOn is True:
			if self.name is 'wide_ramp':
				(x_c,y_c,z_c) = (x_scale + .2,y_scale+2.5,z_scale+1.75)
			if self.name is 'tree1':
				(x_c,y_c,z_c) = (x_scale,y_scale,z_scale)
			if self.name is 'tree2':
				(x_c,y_c,z_c) = (x_scale,y_scale,z_scale)
			if self.name is 'rock1':
				(x_c,y_c,z_c) = (x_scale * 2,y_scale * 2,z_scale*2)
			if self.name is 'rock2':
				(x_c,y_c,z_c) = (x_scale*100,y_scale*100,z_scale*100)
			if self.name is 'gate':
				(x_c,y_c,z_c) = (x_scale * 10,y_scale,z_scale*3.5)
			if self.name is 'statue':
				(x_c,y_c,z_c) = (x_scale,y_scale,z_scale)

       			mesh = BulletTriangleMesh()
        		for geomNP in self.model.findAllMatches('**/+GeomNode'):
            			geomNode = geomNP.node()
            			ts = geomNP.getTransform(self.model)
          		for geom in geomNode.getGeoms():
                		mesh.addGeom(geom, ts)

        		shape = BulletTriangleMeshShape(mesh, dynamic=False)

            		node = BulletRigidBodyNode(self.name)
            		node.setMass(0)
            		node.addShape(shape)

			np = self.__game.render.attachNewNode(node)
			np.setPos(self.x,self.y,self.z)
			np.setHpr(h,p,r)
			np.setScale(x_c,y_c,z_c)

			self.__game.world.attachRigidBody(node)
		self.model.setPos(self.x,self.y,self.z)
		self.model.setHpr(h,p,r)
		self.model.setScale(x_scale,y_scale,z_scale)
		self.model.reparentTo(self.__game.render)
		
		if self.name is 'statue':
			plat_texture = loader.loadTexture('models/textures/rocky.jpg')
		        self.model.setTexture(plat_texture,1)
			ts = TextureStage.getDefault()
	       	 	texture = self.model.getTexture()
			self.model.setTexScale(ts, 1, 1)
Пример #56
0
 def makeBall(self, num, pos = (0, 0, 0)):
   shape = BulletSphereShape(0.5)
   node = BulletRigidBodyNode('ball_' + str(num))
   node.setMass(1.0)
   node.setRestitution(.9)
   node.setDeactivationEnabled(False)
   node.addShape(shape)
   physics = render.attachNewNode(node)
   physics.setPos(*pos)
   self.world.attachRigidBody(node)
   model = loader.loadModel('models/ball')
   color = self.makeColor()
   model.setColor(color)
   self.ballColors['ball_' + str(num)] = color
   model.reparentTo(physics)
Пример #57
0
class MagicBox(Item):
  def createItem(self):
    self.collisionShape = BulletBoxShape(Vec3(0.5, 0.6, 0.5))
    self.actor = BulletRigidBodyNode('MagicBox')
    self.actor.addShape(self.collisionShape)
    self.np = self.render.attachNewNode(self.actor)
    self.np.setCollideMask(BitMask32.allOff())
    self.np.setPos(self.x, self.y, self.z)
    self.world.attachRigidBody(self.actor)
    
    self.actorModelNP = self.loader.loadModel('models/magicbox/ToyBox.egg')
    self.actorModelNP.reparentTo(self.np)
    self.actorModelNP.setScale(0.35)
    self.actorModelNP.setH(180)
    self.actorModelNP.setPos(0, 0, -0.5)
Пример #58
0
    def makeCameraCollision(self):
        #nodes
        node = BulletRigidBodyNode('Box')
        #node.setMass(0)
        self.ccnp = render.attachNewNode(node)
        self.ccnp.reparentTo(base.camera)

        #shapes
        shape = BulletSphereShape(.5)

        #nodes
        node.addShape(shape)

        #bullet world
        self.world.attachRigidBody(node)