예제 #1
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
예제 #2
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 []
예제 #3
0
    def addMeshConvexRB(self,vertices, faces,ghost=False,**kw):
        #step 1) create GeomVertexData and add vertex information
        format=GeomVertexFormat.getV3()
        vdata=GeomVertexData("vertices", format, Geom.UHStatic)
        
        vertexWriter=GeomVertexWriter(vdata, "vertex")
        [vertexWriter.addData3f(v[0],v[1],v[2]) for v in vertices]
        
        #step 2) make primitives and assign vertices to them
        tris=GeomTriangles(Geom.UHStatic)
        [self.setGeomFaces(tris,face) for face in faces]
        
        #step 3) make a Geom object to hold the primitives
        geom=Geom(vdata)
        geom.addPrimitive(tris)
        
        #step 4) create the bullet mesh and node
        mesh = BulletTriangleMesh()
        mesh.addGeom(geom)

        shape = BulletConvexHullShape(mesh, dynamic=not ghost)#
        if ghost :
            inodenp = self.worldNP.attachNewNode(BulletGhostNode('Mesh'))
        else :
            inodenp = self.worldNP.attachNewNode(BulletRigidBodyNode('Mesh'))
        inodenp.node().addShape(shape)
#        inodenp.setPos(0, 0, 0.1)
        self.setRB(inodenp,**kw)
        inodenp.setCollideMask(BitMask32.allOn())
   
        self.world.attachRigidBody(inodenp.node())
        return inodenp
예제 #4
0
  def setup(self):
    self.worldNP = render.attachNewNode('World')

    # World
    self.debugNP = self.worldNP.attachNewNode(BulletDebugNode('Debug'))
    self.debugNP.show()

    self.world = BulletWorld()
    self.world.setGravity(Vec3(0, 0, -9.81))
    self.world.setDebugNode(self.debugNP.node())

    # Ground
    p0 = Point3(-20, -20, 0)
    p1 = Point3(-20, 20, 0)
    p2 = Point3(20, -20, 0)
    p3 = Point3(20, 20, 0)
    mesh = BulletTriangleMesh()
    mesh.addTriangle(p0, p1, p2)
    mesh.addTriangle(p1, p2, p3)
    shape = BulletTriangleMeshShape(mesh, dynamic=False)

    np = self.worldNP.attachNewNode(BulletRigidBodyNode('Mesh'))
    np.node().addShape(shape)
    np.setPos(0, 0, -2)
    np.setCollideMask(BitMask32.allOn())

    self.world.attachRigidBody(np.node())

    # Soft body world information
    info = self.world.getWorldInfo()
    info.setAirDensity(1.2)
    info.setWaterDensity(0)
    info.setWaterOffset(0)
    info.setWaterNormal(Vec3(0, 0, 0))

    # Softbody
    for i in range(50):
      p00 = Point3(-2, -2, 0)
      p10 = Point3( 2, -2, 0)
      p01 = Point3(-2,  2, 0)
      p11 = Point3( 2,  2, 0)
      node = BulletSoftBodyNode.makePatch(info, p00, p10, p01, p11, 6, 6, 0, True)
      node.generateBendingConstraints(2)
      node.getCfg().setLiftCoefficient(0.004)
      node.getCfg().setDynamicFrictionCoefficient(0.0003)
      node.getCfg().setAeroModel(BulletSoftBodyConfig.AMVertexTwoSided)
      node.setTotalMass(0.1)
      node.addForce(Vec3(0, 2, 0), 0)

      np = self.worldNP.attachNewNode(node)
      np.setPos(self.Vec3Rand() * 10 + Vec3(0, 0, 20))
      np.setHpr(self.Vec3Rand() * 16)
      self.world.attachSoftBody(node)

      fmt = GeomVertexFormat.getV3n3t2()
      geom = BulletHelper.makeGeomFromFaces(node, fmt, True)
      node.linkGeom(geom)
      nodeV = GeomNode('')
      nodeV.addGeom(geom)
      npV = np.attachNewNode(nodeV)
예제 #5
0
    def __init__(self, bulletWorld):

        #model used as collision mesh VOLCANO
        collisionModel = loader.loadModel('models/VolcanoCollision2')

        tex = loader.loadTexture("models/mars_1k_tex.jpg")
        collisionModel.setTexture(tex)

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

        shape = BulletTriangleMeshShape(mesh, dynamic=False)

        self.rigidNode = BulletRigidBodyNode('Heightfield')
        self.rigidNode.notifyCollisions(False)
        np = render.attachNewNode(self.rigidNode)
        np.node().addShape(shape)

        collisionModel.reparentTo(np)
        np.setScale(7)
        ###Ucomment next line for RAZOR map:
        #np.setHpr(0,90,0)
        np.setPos(0, 0, -2)
        np.setCollideMask(BitMask32.allOn())
        np.node().notifyCollisions(False)
        bulletWorld.attachRigidBody(np.node())

        self.hf = np.node()  # To enable/disable debug visualization
	def __init__(self, model, world, worldNP, pos, scale, hpr):
		self.worldNP = worldNP
		bulletWorld = world
		
		# Initialize the model.
		self.AIModel = loader.loadModel(model)
		self.AINode = BulletRigidBodyNode('AIChar')
		self.AIModel.setScale(scale)
		self.AIModel.flattenLight() # Combines all geom nodes into one geom node.

		# Build the triangle mesh shape and attach it with the transform.
		geom = self.AIModel.findAllMatches('**/+GeomNode').getPath(0).node().getGeom(0)
		mesh = BulletTriangleMesh()
		mesh.addGeom(geom)
		shape = BulletTriangleMeshShape(mesh, dynamic=False)
		self.AINode.addShape(shape, TransformState.makePosHprScale(Point3(0,0,0), hpr, scale))
		self.AINode.setMass(0)
		bulletWorld.attachRigidBody(self.AINode)
		
		# Apply the same transforms on the model being rendered.
		self.AIModel.reparentTo(render)
		self.AIModel.setH(hpr.getX())
		self.AIModel.setP(hpr.getY())
		self.AIModel.setR(hpr.getZ())
		self.AINode.setAngularFactor(Vec3(0,0,0))
		
		# Attach it to the world.
		self.AIChar = self.worldNP.attachNewNode(self.AINode)
		self.AIModel.reparentTo(self.AIChar)
		self.AIChar.setPos(pos)
예제 #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
예제 #9
0
	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
예제 #10
0
    def __init__(self, model, world, worldNP, pos, scale, hpr):
        self.worldNP = worldNP
        bulletWorld = world

        # Initialize the model.
        self.AIModel = loader.loadModel(model)
        self.AINode = BulletRigidBodyNode("AIChar")
        self.AIModel.setScale(scale)
        self.AIModel.flattenLight()  # Combines all geom nodes into one geom node.

        # Build the triangle mesh shape and attach it with the transform.
        geom = self.AIModel.findAllMatches("**/+GeomNode").getPath(0).node().getGeom(0)
        mesh = BulletTriangleMesh()
        mesh.addGeom(geom)
        shape = BulletTriangleMeshShape(mesh, dynamic=False)
        self.AINode.addShape(shape, TransformState.makePosHprScale(Point3(0, 0, 0), hpr, scale))
        self.AINode.setMass(0)
        bulletWorld.attachRigidBody(self.AINode)

        # Apply the same transforms on the model being rendered.
        self.AIModel.reparentTo(render)
        self.AIModel.setH(hpr.getX())
        self.AIModel.setP(hpr.getY())
        self.AIModel.setR(hpr.getZ())
        self.AINode.setAngularFactor(Vec3(0, 0, 0))

        # Attach it to the world.
        self.AIChar = self.worldNP.attachNewNode(self.AINode)
        self.AIModel.reparentTo(self.AIChar)
        self.AIChar.setPos(pos)
예제 #11
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
예제 #12
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
예제 #13
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
예제 #14
0
    def createLetter(self, loadFile, name, x, y, z):
        self.name = name
        self.letter = loader.loadModel(loadFile)
        geomnodes = self.letter.findAllMatches('**/+GeomNode')
        gn = geomnodes.getPath(0).node()
        geom = gn.getGeom(0)
        mesh = BulletTriangleMesh()
        mesh.addGeom(geom)
        shape = BulletTriangleMeshShape(mesh, dynamic=False)

        self.letterNode = BulletRigidBodyNode('Letter')
        self.letterNode.setMass(0)
        self.letterNode.addShape(shape)

        self.letters.append(self.letterNode)
        letternn = render.attachNewNode(self.letterNode)
        letternn.setPos(x, y, z)
        letternn.setScale(1)
        letternn.setP(90)  # orients the mesh for the letters to be upright

        self.world.attachRigidBody(self.letterNode)
        self.letter.reparentTo(letternn)

        self.letter.setP(
            -90)  # orients the actual letter objects to be upright
예제 #15
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
예제 #16
0
    def loadModel(self):

        if (self.viewing_object):
            self.world.removeRigidBody(self.viewing_object.node())

        Tk().withdraw(
        )  # we don't want a full GUI, so keep the root window from appearing
        filename = askopenfilename(
        )  # show an "Open" dialog box and return the path to the selected file
        # filename = "models/new2.obj"
        pandafile = Filename.fromOsSpecific(filename)
        viewing_object_NP = loader.loadModel(pandafile)
        geom = viewing_object_NP.findAllMatches("**/+GeomNode").getPath(
            0).node().getGeom(0)
        mesh = BulletTriangleMesh()
        mesh.addGeom(geom)
        shape = BulletTriangleMeshShape(mesh, dynamic=True)
        body = BulletRigidBodyNode("viewing_object")
        self.viewing_object = self.worldNP.attachNewNode(body)
        self.viewing_object.node().addShape(shape)
        self.viewing_object.setPos(0, 0, 0)
        self.viewing_object.setHpr(0, 90, 0)
        self.viewing_object.setCollideMask(BitMask32.allOn())
        self.world.attachRigidBody(self.viewing_object.node())
        self.viewing_object.setScale(50)
예제 #17
0
    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
예제 #18
0
    def generate_chunk(self):
        """ this function will generate the actual geometry that is the chunk """
        self.update_block_faces()
        self.material_nodes = {
            material_id: GeomNode(self.name)
            for material_id in block_id_mapping.keys()
        }
        self.bullet_mesh = BulletTriangleMesh()
        # self.texture_np = NodePath('textures')

        for i in range(self.arr_x):
            for j in range(self.arr_y):
                for k in range(self.arr_z):
                    if self.block_arr[i, j, k][0] == 1:
                        # convert from chunk coordinates to world coordinates so the goemetry is in the right place
                        rel_x = i + self.x_range[0]
                        rel_y = j + self.y_range[0]
                        # only x and y need to be shifted, z is fine as is
                        geom = self.make_cube_geom(
                            pos=(rel_x, rel_y, k),
                            faces_no_draw=self.block_arr[i, j, k][2:])

                        material_id = self.block_arr[i, j, k][1]
                        self.material_nodes[material_id].addGeom(geom)
                        self.bullet_mesh.addGeom(geom)
예제 #19
0
        def make_collision_from_model(input_model, node_number, mass, world,
                                      target_pos, h_adj):
            # tristrip generation from static models
            # generic tri-strip collision generator begins
            geom_nodes = input_model.find_all_matches('**/+GeomNode')
            geom_nodes = geom_nodes.get_path(node_number).node()
            # print(geom_nodes)
            geom_target = geom_nodes.get_geom(0)
            # print(geom_target)
            output_bullet_mesh = BulletTriangleMesh()
            output_bullet_mesh.add_geom(geom_target)
            tri_shape = BulletTriangleMeshShape(output_bullet_mesh,
                                                dynamic=False)
            print(output_bullet_mesh)

            body = BulletRigidBodyNode('input_model_tri_mesh')
            np = self.render.attach_new_node(body)
            np.node().add_shape(tri_shape)
            np.node().set_mass(mass)
            np.node().set_friction(0.01)
            np.set_pos(target_pos)
            np.set_scale(1)
            np.set_h(h_adj)
            # np.set_p(180)
            # np.set_r(180)
            np.set_collide_mask(BitMask32.allOn())
            world.attach_rigid_body(np.node())
예제 #20
0
    def __init__(self, track_data, world):
        super().__init__()

        self.track_data = track_data
        self.world = world

        self.snode = GeomNode('track')

        self.width = track_data["width"]

        self.cur_x1 = 0
        self.cur_y1 = 0
        self.cur_z1 = 0
        self.cur_x2 = self.width
        self.cur_y2 = 0
        self.cur_z2 = 0

        self.mesh = BulletTriangleMesh()

        self.surfaces = {}
        self.load_surfaces()

        self.segments = []
        self.gen_segments()
        shape = BulletTriangleMeshShape(self.mesh, dynamic=False)

        self.track = render.attachNewNode(BulletRigidBodyNode('Track'))
        self.track.node().addShape(shape)
        self.world.attachRigidBody(self.track.node())
        self.track.attachNewNode(self.snode)
        self.track.setTwoSided(True)
        self.track.setCollideMask(BitMask32.allOn())
예제 #21
0
def getCollisionShapeFromModel(model, mode='box', defaultCentered=False):

    #NOTE: make sure the position is relative to the center of the object
    minBounds, maxBounds = model.getTightBounds()
    offset = minBounds + (maxBounds - minBounds) / 2.0

    transform = TransformState.makeIdentity()
    if mode == 'mesh':
        # Use exact triangle mesh approximation
        mesh = BulletTriangleMesh()
        geomNodes = model.findAllMatches('**/+GeomNode')
        for nodePath in geomNodes:
            geomNode = nodePath.node()
            for n in range(geomNode.getNumGeoms()):
                geom = geomNode.getGeom(n)
                mesh.addGeom(geom)
        shape = BulletTriangleMeshShape(mesh, dynamic=False)
        transform = model.getTransform()

    elif mode == "sphere":
        minBounds, maxBounds = model.getTightBounds()
        dims = maxBounds - minBounds
        radius = np.sqrt(np.square(dims[0]) + np.square(dims[1])) / 2.0
        height = dims[2]
        shape = BulletCapsuleShape(radius, 2 * radius)
        if not defaultCentered:
            transform = TransformState.makePos(offset)

    elif mode == "hull":
        shape = BulletConvexHullShape()
        geomNodes = model.findAllMatches('**/+GeomNode')
        for nodePath in geomNodes:
            geomNode = nodePath.node()
            for n in range(geomNode.getNumGeoms()):
                geom = geomNode.getGeom(n)
                shape.addGeom(geom)

    elif mode == 'box':
        # Bounding box approximation
        minBounds, maxBounds = model.getTightBounds()
        dims = maxBounds - minBounds
        shape = BulletBoxShape(Vec3(dims.x / 2, dims.y / 2, dims.z / 2))
        if not defaultCentered:
            transform = TransformState.makePos(offset)

    elif mode == 'capsule':
        minBounds, maxBounds = model.getTightBounds()
        dims = maxBounds - minBounds
        radius = np.sqrt(np.square(dims[0]) + np.square(dims[1])) / 2.0
        height = dims[2]
        shape = BulletCapsuleShape(radius, height - 2 * radius)
        if not defaultCentered:
            transform = TransformState.makePos(offset)

    else:
        raise Exception(
            'Unknown mode type for physic object collision shape: %s' % (mode))

    return shape, transform
예제 #22
0
    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()
예제 #23
0
def get_bullet_shape(geom_node):
    shape = BulletTriangleMesh()
    for i in range(geom_node.getNumGeoms()):
        geom = geom_node.getGeom(i)
        # state = geom_node.getGeomState(i)
        shape.addGeom(geom)
    shape = BulletTriangleMeshShape(shape, True)
    return shape
예제 #24
0
def ModelToBTS(model):
    geomnodes = model.findAllMatches('**/+GeomNode')
    gn = geomnodes.getPath(0).node()
    geom = gn.getGeom(0)
    mesh = BulletTriangleMesh()
    mesh.addGeom(geom)
    shape = BulletTriangleMeshShape(mesh, dynamic=False)
    return shape
예제 #25
0
 def egg_to_BulletTriangleMeshShape(self, modelnp):
     mesh = BulletTriangleMesh()
     for collisionNP in modelnp.findAllMatches('**/+CollisionNode'):
         collisionNode = collisionNP.node()
         for collisionPolygon in collisionNode.getSolids():
             tri_points = collisionPolygon.getPoints()
             mesh.addTriangle(tri_points[0], tri_points[1], tri_points[2])
     shape = BulletTriangleMeshShape(mesh, dynamic=False)
     return shape
예제 #26
0
def gen_cdmesh_vvnf(vertices, vertex_normals, faces, name='auto'):
    geom = da.pandageom_from_vvnf(vertices * SCALE_FOR_PRECISION, vertex_normals, faces)
    bullet_triangles_mesh = BulletTriangleMesh()
    bullet_triangles_mesh.addGeom(geom)
    bullet_triangles_shape = BulletTriangleMeshShape(bullet_triangles_mesh, dynamic=True)
    bullet_triangles_shape.setMargin(0)
    geombullnode = BulletRigidBodyNode(name=name)
    geombullnode.addShape(bullet_triangles_shape)
    return geombullnode
예제 #27
0
def bullet_shape_from(source, dynamic=False):
    mesh = BulletTriangleMesh()

    for geom_node in source.findAllMatches('**/+GeomNode'):
        gn = geom_node.node()
        ts = gn.getTransform()
        for geom in gn.getGeoms():
            mesh.addGeom(geom, True, ts)

    return BulletTriangleMeshShape(mesh, dynamic=dynamic)
예제 #28
0
    def __init__(self, bulletWorld):

        self.env = loader.loadModel("models/env")
        self.env.reparentTo(render)
        self.env.setPos(0,0,-6)
        self.env.setScale(400)
        self.environ_tex = loader.loadTexture("models/tex/env_sky.jpg")
        self.env.setTexture(self.environ_tex, 1)
        self.period_cloud = self.env.hprInterval(400, (360, 0, 0))
        self.period_cloud.loop()

        self.ground = loader.loadModel("models/Ground2")
        self.ground.reparentTo(render)
        self.ground.setPos(0,0,-5)
        self.ground.setScale(0.5,0.5,0)
        self.ground_tex = loader.loadTexture("models/tex/ground.tif")
        self.ground.setTexture(self.ground_tex, 1)

        # model used as collision mesh
        collisionModel = loader.loadModel('models/Track2')
        # model used as display model
        model = loader.loadModel('models/Track2')

        tex = loader.loadTexture("models/tex/Main.png")
        model.setTexture(tex)
        # renders track from two camera views
        model.setTwoSided(True)

        collisionModel.setScale(1, 1, 100)

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

        shape = BulletTriangleMeshShape(mesh, dynamic=False)

        self.rigidNode = BulletRigidBodyNode('Heightfield')
        self.rigidNode.notifyCollisions(False)
        np = render.attachNewNode(self.rigidNode)
        np.node().addShape(shape)

        model.setScale(1, 1, .1)
        model.reparentTo(np)
        np.setScale(.7)
        np.setPos(0, 0, -5)
        np.setCollideMask(BitMask32(0xf0))
        np.node().notifyCollisions(False)
        bulletWorld.attachRigidBody(np.node())

        self.hf = np.node()  # To enable/disable debug visualisation
        
        
예제 #29
0
def build_bullet_from_model(modelNP):
    body = BulletRigidBodyNode('...')
    for geomNP in modelNP.findAllMatches('**/+GeomNode'):
        geomNode = geomNP.node()
        ts = geomNode.getTransform()
        for geom in geomNode.getGeoms():
            mesh = BulletTriangleMesh()
            mesh.addGeom(geom)

            shape = BulletTriangleMeshShape(mesh, dynamic=False)
            body.addShape(shape, ts)
    return body
예제 #30
0
        def setup_world(self):
            self.world_node = self.render.attachNewNode('World')
            self.world.setGravity(Vec3(0, 0, -9.81))

            # Landscape
            model = self.loader.loadModel("mesh/models/landscape/landscape")
            model.reparentTo(self.render)
            model.setScale(100)
            model.flatten_light()
            geom_nodes = model.findAllMatches('**/+GeomNode')
            geom_node = geom_nodes.getPath(0).node()
            geom_mesh = geom_node.getGeom(0)
            mesh = BulletTriangleMesh()
            mesh.add_geom(geom_mesh)
            ground_shape = BulletTriangleMeshShape(mesh, dynamic=False)

            ground_node = self.world_node.attachNewNode(
                BulletRigidBodyNode('Ground'))
            ground_node.node().addShape(ground_shape)
            '''
            if self.debug_mode:
                debug_node_path = self.world_node.attachNewNode(BulletDebugNode('Debug'))
                debug_node_path.show()
                debug_node_path.node().showNormals(True)
                self.world.setDebugNode(debug_node_path.node())
            '''
            self.debug_node_path = self.world_node.attachNewNode(
                BulletDebugNode('Debug'))
            self.debug_node_path.hide()
            self.world.setDebugNode(self.debug_node_path.node())

            ground_node.setPos(0, 0, 0)
            ground_node.setCollideMask(BitMask32.allOn())

            self.world.attachRigidBody(ground_node.node())

            # Character
            player = Player()

            # Other models
            path = 'mesh/models/bullet/pyramid'
            self.add_model(path, pos_x=50, pos_y=15, pos_z=370, scale=5)
            self.add_model(path, pos_x=30, pos_y=15, pos_z=370, scale=5)
            self.add_model(path, pos_x=70, pos_y=15, pos_z=390, scale=5)
            self.add_model(path, pos_x=50, pos_y=40, pos_z=360, scale=5)

            path = 'mesh/models/bullet/ball'
            self.add_model(path, pos_x=0, pos_y=15, pos_z=400, scale=8)
            self.add_model(path, pos_x=30, pos_y=40, pos_z=450, scale=8)

            taskMgr.add(self.update, 'updateWorld')
예제 #31
0
    def __init__(
        self, world:BulletWorld, entity:Entity,
        dynamic=False, rotation=[None, None, None]
        ):

        geomNodes = entity.model.findAllMatches('**/+GeomNode')
        geomNode = geomNodes.getPath(0).node()
        geom = geomNode.getGeom(0)
        mesh = BulletTriangleMesh()
        mesh.addGeom(geom)

        shape = BulletTriangleMeshShape(mesh, dynamic=dynamic)

        super().__init__(world, entity, shape, 'mesh', rotation)
예제 #32
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)
예제 #33
0
파일: HUtils.py 프로젝트: PlumpMath/HPanda
def modelToShape2(model):
    """

    :type model: str
    :return: panda3d.bullet.BulletTriangleMeshShape
    """
    np = loader.loadModel(model)  #####componer luego
    mesh = BulletTriangleMesh()
    for geomNP in np.findAllMatches('**/+GeomNode'):
        geomNode = geomNP.node()
        ts = geomNP.getTransform(np)
        for geom in geomNode.getGeoms():
            mesh.addGeom(geom, ts)
    shape = BulletTriangleMeshShape(mesh, False)
    return shape
예제 #34
0
파일: HUtils.py 프로젝트: PlumpMath/HPanda
def modelToShape(model, dynamic=False):
    """

    :type model: panda3d.core.NodePath
    :type dynamic: bool
    :return: tuple(panda3d.bullet.BulletTriangleMeshShape, transform)
    """
    geomnodes = model.findAllMatches('**/+GeomNode')
    transform = model.getTransform()
    gn = geomnodes.getPath(0).node()
    geom = gn.getGeom(0)
    mesh = BulletTriangleMesh()
    mesh.addGeom(geom)
    shape = BulletTriangleMeshShape(mesh, dynamic)
    return shape, transform
예제 #35
0
    def createElement(self, name, type, start, end=None):
        if type == "cell":
            model_file = "sphere.dae"
        elif type == "bit":
            model_file = "box.dae"
        elif type == "segment" or type == "synapse":
            model_file = "cylinder.dae"

        # Create the rigid body
        body_node = BulletRigidBodyNode(name)
        body_node.setDeactivationEnabled(False)
        body_np = self.render.attachNewNode(body_node)
        body_np.setName(name)

        if type == "segment" or type == "synapse":
            # Calculate the linear distance between the start and the end position of the segment.
            length = (Point3(start) - Point3(end)).length()

            body_np.setPos(start)
            body_np.lookAt(end)
            body_np.setScale(1, length / 2, 1)
        else:
            body_np.setPos(start)

        # Load the 3d model file using the asset folder relative path and attach the geom node to rigid body
        object_np = self.loader.loadModel(
            Filename.from_os_specific(
                os.path.join(REPO_DIR, "models", model_file)))
        object_np.reparentTo(body_np)
        object_np.setPosHpr((0, 0, 0), (0, 0, 0))
        object_np.setName(name + "_geom")
        object_np.setTexGen(TextureStage.getDefault(),
                            TexGenAttrib.MWorldPosition)

        # Apply any transforms from modelling sotware to gain performance
        object_np.flattenStrong()

        # Create the shape used for collisions
        geom_nodes = object_np.findAllMatches("**/+GeomNode")
        mesh = BulletTriangleMesh()
        for geom in geom_nodes[0].node().getGeoms():
            mesh.addGeom(geom)
        shape = BulletTriangleMeshShape(mesh, dynamic=True)
        body_node.addShape(shape)

        self.physics_manager.attachRigidBody(body_node)
        return body_np
예제 #36
0
    def setupWalls(self, _obj, _eggFile):
        tmpMesh = BulletTriangleMesh()
        node = _obj.node()

        if node.isGeomNode():
            tmpMesh.addGeom(node.getGeom(0))
        else:
            return

        body = BulletRigidBodyNode("wall")
        body.addShape(BulletTriangleMeshShape(tmpMesh, dynamic=False))
        body.setMass(0)

        np = self.rootNode.attachNewNode(body)
        np.setCollideMask(BitMask32.bit(1))

        self.parent.physics_world.attachRigidBody(body)
    def setupCollisionMeshAndRigidNodeFromModel(self):
        mesh = BulletTriangleMesh()
        for geomNP in self.floorModel.findAllMatches('**/+GeomNode'):
            geomNode = geomNP.node()
            ts = geomNP.getTransform(self.floorModel)
            for geom in geomNode.getGeoms():
                mesh.addGeom(geom, ts)

        shape = BulletTriangleMeshShape(mesh, dynamic=False)
        self.rigidNode = BulletRigidBodyNode('Floor')
        self.rigidNode.notifyCollisions(False)

        self.rigidNodePath = self.parentNodePath.attachNewNode(self.rigidNode)
        self.rigidNodePath.node().addShape(shape)
        self.rigidNodePath.setScale(12, 12, 1.5)
        self.rigidNodePath.setCollideMask(BitMask32.allOn())
        self.rigidNodePath.node().notifyCollisions(False)
예제 #38
0
    def setup_collision(self, modelName):
        mesh = BulletTriangleMesh()
        geoms = GeomNode('{}'.format(modelName))
        a = 0
        for x in self.model.findAllMatches('**/+GeomNode').getPath(
                0).node().modifyGeoms():
            if a <= len(self.model.findAllMatches('**/+GeomNode')):
                geoms.addGeom(x)
        for geom in geoms.getGeoms():
            mesh.addGeom(geom)

        shape = BulletTriangleMeshShape(mesh, dynamic=self.dynamic)
        self.nodePath = self.worldnp.attachNewNode(
            BulletRigidBodyNode('{}'.format(self.model)))
        self.nodePath.node().addShape(shape)
        self.model.reparentTo(self.nodePath)
        self.model.setPos(self.nodePath.getPos())
예제 #39
0
    def __init__(self, app, map_name):
        map_file = 'assets/maps/{}/{}.bam'.format(map_name, map_name)
        self.app = app

        self.physics_world = BulletWorld()

        node = BulletRigidBodyNode('Ground')
        self.np = self.app.render.attach_new_node(node)
        self.np.setPos(0, 0, 0)
        self.physics_world.attachRigidBody(node)

        self.model = loader.load_model(map_file)
        self.model.reparent_to(self.np)

        self.env_data = EnvironmentData(self.model, map_name, 'maps')

        self.physics_world.setGravity(self.env_data.gravity)

        sky = self.model.find(SKYSPHERE)
        sky.reparent_to(base.cam)
        sky.set_bin('background', 0)
        sky.set_depth_write(False)
        sky.set_compass()
        sky.set_light_off()

        # Bullet collision mesh
        collision_solids = self.model.find_all_matches(
            '{}*'.format(TERRAIN_COLLIDER)
        )

        #collision_solids.hide()

        for collision_solid in collision_solids:
            collision_solid.flatten_strong()
            for geom_node in collision_solid.find_all_matches('**/+GeomNode'):
                mesh = BulletTriangleMesh()
                for geom in geom_node.node().get_geoms():
                    mesh.addGeom(geom)
                shape = BulletTriangleMeshShape(mesh, dynamic=False)
                terrain_node = BulletRigidBodyNode('terrain')
                terrain_node.add_shape(shape)
                terrain_node.set_friction(self.env_data.friction)
                terrain_np = geom_node.attach_new_node(terrain_node)
                terrain_np.set_collide_mask(CM_TERRAIN | CM_COLLIDE)
                self.physics_world.attach_rigid_body(terrain_node)
예제 #40
0
    def createPlatform(self, x, y, z):
        self.platform = loader.loadModel('../models/disk/disk.egg')
        geomnodes = self.platform.findAllMatches('**/+GeomNode')
        gn = geomnodes.getPath(0).node()
        geom = gn.getGeom(0)
        mesh = BulletTriangleMesh()
        mesh.addGeom(geom)
        shape = BulletTriangleMeshShape(mesh, dynamic=False)

        node = BulletRigidBodyNode('Platform')
        node.setMass(0)
        node.addShape(shape)
        platformnn = render.attachNewNode(node)
        platformnn.setPos(x, y, z)
        platformnn.setScale(3)

        self.world.attachRigidBody(node)
        self.platform.reparentTo(platformnn)
예제 #41
0
    def createWall(self, x, y, z, h):
        self.wall = loader.loadModel('../models/wall/wall.egg')
        geomnodes = self.wall.findAllMatches('**/+GeomNode')
        gn = geomnodes.getPath(0).node()
        geom = gn.getGeom(0)
        mesh = BulletTriangleMesh()
        mesh.addGeom(geom)
        shape = BulletTriangleMeshShape(mesh, dynamic=False)

        wallNode = BulletRigidBodyNode('Wall')
        wallNode.setMass(0)
        wallNode.addShape(shape)
        wallnn = render.attachNewNode(wallNode)
        wallnn.setPos(x, y, z)
        wallnn.setH(h)
        wallnn.setScale(0.5, 50.5, 4.5)

        self.world.attachRigidBody(wallNode)
        self.wall.reparentTo(wallnn)
예제 #42
0
    def __addTriangleMesh(self, body, model, pos=(0,0,0), hpr=(0,0,0), scale=(1,1,1), dynamic=True):        
        
        mesh = BulletTriangleMesh()
      
        def one():
            geom = model.node().getGeom(0)            
            mesh.addGeom(geom)
            return []

        children =  model.findAllMatches('**/+GeomNode') or one()

        model.flattenLight()

        for piece in children:
            geom = piece.node().getGeom(0)
            mesh.addGeom(geom)

        shape = BulletTriangleMeshShape(mesh, dynamic=dynamic )
        body.addShape( shape, TransformState.makePosHprScale(pos,hpr,scale) )
  def _createBulletShape_(self,np, apply_scale = True, apply_transform = True):
    """
    @brief Creates a BulletTriangleMeshShape from the geometries in the model node.  The passed
    node path must point to a GeomNode type.  The Geom objects are then added to a 
    BulletTriangleMesh object which is then used to initialize the Shape.  Optionally, 
    the node's transform and scaled can be baked into the Geometries (recommended 
    according to the Panda3D guide https://www.panda3d.org/manual/index.php/Bullet_FAQ).
    If you apply the scale and transform make sure not to apply them again to the shape or
    the bullet node that contains the shape as it'll compound the effect.
    @warning: If the underlying GeomNode contains multiple geometries each with a different
    transform and scale then it's best to set apply_scale and apply_transform to True.
    @param np: The nodepath containing the GeomNode
    @param apply_scale: Boolean that allows choosing whether or not to apply the nodepath's scale to the geometries
    @param apply_transform: Boolean that indicates whether or not to apply the nodepath's trasform to the geometries.
    @return:  A BulletTriangleMeshShape object containing the node's geometries
    """
    
    geom_node = np.node()
    if type(geom_node) is not GeomNode:
      logging.error("Node %s is not a GeomNode node type"%(np.getName()))
      return None
    
    bullet_mesh = BulletTriangleMesh()
        
    # Assembling transform
    tr = TransformState.makeIdentity()
    geom_scale = np.getScale()
    if apply_transform:
      tr = tr.setPos(np.getPos())
      tr = tr.setQuat(np.getQuat())
      sc = LPoint3(1)
      tr = tr.setScale(sc)
    if apply_scale: # baking scale into geometry data
      tr = tr.setScale(geom_scale)    

    for geom in geom_node.getGeoms():      
      bullet_mesh.addGeom(geom,True,tr)
    
    bullet_shape = BulletTriangleMeshShape(bullet_mesh,False,True,True)    
    bullet_shape.setMargin(GameObject.DEFAULT_COLLISION_MARGIN)
    
    return bullet_shape
예제 #44
0
    def _create_bullet_nodepath(geom, geom_node, entity):
        bullet_node = BulletRigidBodyNode("NavmeshCollision")

        transform = geom_node.getTransform()
        mesh = BulletTriangleMesh()
        mesh.addGeom(geom, True, transform)

        shape = BulletTriangleMeshShape(mesh, dynamic=False)
        bullet_node.addShape(shape)

        mask = BitMask32()
        mask.set_word(CollisionGroups.navmesh)

        bullet_node.set_into_collide_mask(mask)

        # Associate with entity
        bullet_nodepath = base.render.attachNewNode(bullet_node)
        bullet_nodepath.set_python_tag("entity", entity)

        return bullet_nodepath
예제 #45
0
    def addPhysicsObject(self, model, objectType):
        """Adds a physical object to the level

        The object isn't linked with a graphical object
        """

        if objectType == "barrier":
            # Use a triangle mesh to represent the barrier as
            # it could be concave
            mesh = BulletTriangleMesh()
            mesh.addGeom(model.node().getGeom(0))
            shape = BulletTriangleMeshShape(mesh, dynamic=False)
            rigidNode = BulletRigidBodyNode("barrier")
            rigidNode.addShape(shape)
            self.physicsWorld.attachRigidBody(rigidNode)
            # Set the position from the model
            pNode = self.outsideWorldRender.attachNewNode(rigidNode)
            pNode.setPos(model.getPos())
        else:
            raise ValueError("Invalid physics object type: %s" % objectType)
예제 #46
0
def genCollisionMeshGeom(geom, name='autogen'):
    """
    generate the collision mesh of a nodepath using geom

    :param geom: the panda3d geom of the object
    :param basenodepath: the nodepath to compute relative transform
    :return: bulletrigidbody

    author: weiwei
    date: 20161212, tsukuba
    """

    geomtf = TransformState.makeIdentity()
    geombullmesh = BulletTriangleMesh()
    geombullmesh.addGeom(geom)
    geombullnode = BulletRigidBodyNode(name)
    bullettmshape = BulletTriangleMeshShape(geombullmesh, dynamic=True)
    bullettmshape.setMargin(0)
    geombullnode.addShape(bullettmshape, geomtf)
    return geombullnode
    def __init__(self, bulletWorld):

        self.sky = SkyDome()

        # model used as collision mesh
        collisionModel = loader.loadModel('models/walledTrack')
        # model used as display model
        model = loader.loadModel('models/FullTrack')

        tex = loader.loadTexture("models/tex/Main.png")
        ts = TextureStage('ts')
        ts.setMode(TextureStage.MBlend)
        model.setTexture(ts, tex, 2)
        #model.setTexScale(ts, 70)
        # renders track from two camera views
        model.setTwoSided(True)

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

        shape = BulletTriangleMeshShape(mesh, dynamic=False)

        self.rigidNode = BulletRigidBodyNode('Track')
        self.rigidNode.notifyCollisions(False)
        np = render.attachNewNode(self.rigidNode)
        np.node().addShape(shape)

        model.reparentTo(np)
        np.setScale(70)
        np.setPos(0, 0, -5)
        np.setCollideMask(BitMask32(0xf0))
        np.node().notifyCollisions(False)
        bulletWorld.attachRigidBody(np.node())

        self.hf = np.node()  # To enable/disable debug visualisation
    def createEnvironment(self):
        self.environ = loader.loadModel("models/square")
        self.environ.reparentTo(render)
        self.environ.setPos(0, 0, 0)
        self.environ.setScale(500, 500, 1)
        self.moon_tex = loader.loadTexture("models/moon_1k_tex.jpg")
        self.environ.setTexture(self.moon_tex, 1)

        shape = BulletPlaneShape(Vec3(0, 0, 1), 0)
        node = BulletRigidBodyNode('Ground')
        node.addShape(shape)
        np = render.attachNewNode(node)
        np.setPos(0, 0, 0)

        self.bulletWorld.attachRigidBody(node)

        self.visNP = loader.loadModel('models/track.egg')
        self.tex = loader.loadTexture("models/tex/Main.png")
        self.visNP.setTexture(self.tex)

        geom = self.visNP.findAllMatches('**/+GeomNode').getPath(0).node().getGeom(0)
        mesh = BulletTriangleMesh()
        mesh.addGeom(geom)
        trackShape = BulletTriangleMeshShape(mesh, dynamic=False)

        body = BulletRigidBodyNode('Bowl')
        self.visNP.node().getChild(0).addChild(body)
        bodyNP = render.anyPath(body)
        bodyNP.node().addShape(trackShape)
        bodyNP.node().setMass(0.0)
        bodyNP.setTexture(self.tex)

        self.bulletWorld.attachRigidBody(bodyNP.node())

        self.visNP.reparentTo(render)

        self.bowlNP = bodyNP
        self.visNP.setScale(70)
예제 #49
0
    def create_object(self):
        from panda3d.core import Filename, NodePath, BitMask32
        from panda3d.bullet import BulletRigidBodyNode, BulletTriangleMesh, BulletTriangleMeshShape

        from game_system.resources import ResourceManager
        f = Filename.fromOsSpecific(ResourceManager.get_absolute_path(ResourceManager["Map"]["map.egg"]))
        model = loader.loadModel(f)

        bullet_node = BulletRigidBodyNode("MapCollision")
        bullet_nodepath = NodePath(bullet_node)
        mesh = BulletTriangleMesh()

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

        shape = BulletTriangleMeshShape(mesh, dynamic=False)
        bullet_node.addShape(shape)
        bullet_nodepath.set_collide_mask(BitMask32.bit(0))
        model.reparentTo(bullet_nodepath)
        return bullet_nodepath
예제 #50
0
    def __init__(self, render, world, x, y, z):

        self.movingPlatform = loader.loadModel('../models/square-flat/square.egg')
        geomnodes = self.movingPlatform.findAllMatches('**/+GeomNode')
        gn = geomnodes.getPath(0).node()
        geom = gn.getGeom(0)
        mesh = BulletTriangleMesh()
        mesh.addGeom(geom)
        shape = BulletTriangleMeshShape(mesh, dynamic=False)

        self.node = BulletRigidBodyNode('MovingPlatform')
        self.node.setMass(0)
        self.node.addShape(shape)
        self.movingPlatformnn = render.attachNewNode(self.node)
        self.movingPlatformnn.setPos(x, y, z)

        self.movingPlatformnn.setScale(9, 7, 0.5)
        world.attachRigidBody(self.node)
        self.movingPlatform.reparentTo(self.movingPlatformnn)

        # Associates movingPlatformnn with movingPlatform
        self.movingPlatformnn.setPythonTag("movingPlatformNP", self.movingPlatform)

        # Create a sequence of intervals and play them together using parallel
        downInterval = self.movingPlatformnn.posInterval(3, Point3(x, y, z), startPos=Point3(x, y, z + 15))
        upInterval = self.movingPlatformnn.posInterval(3, Point3(x, y, z + 15), startPos=Point3(x, y, z))

        # To randomize a little, take x position of platform. If it's even move downward. If it's odd, upward
        if x % 2 == 0:
            elevate = Sequence(downInterval, upInterval, name="elevate")
        else:
            elevate = Sequence(upInterval, downInterval, name="elevateOpposite")

        elevateParallel = Parallel()
        elevateParallel.append(elevate)
        elevateParallel.loop()
예제 #51
0
    def buildTriangleMesh(cls, _engine, _obj, _levelEgg, _mass=0, _isDynamic=False):
        """Build a bullet TriangleMesh for objects"""

        mesh = BulletTriangleMesh()
        node = _obj.node()

        if node.isGeomNode():
            mesh.addGeom(node.getGeom(0))
        else:
            return

        body = BulletRigidBodyNode(_obj.getTag("level"))#+str(_obj.getTag("id")))
        body.addShape(BulletTriangleMeshShape(mesh, dynamic=_isDynamic))
        body.setMass(_mass)

        np = _engine.BulletObjects["level"].attachNewNode(body)
        #np.setCollideMask(BitMask32.allOn())
        np.setScale(_obj.getScale(_levelEgg))
        np.setPos(_obj.getPos(_levelEgg))
        np.setHpr(_obj.getHpr(_levelEgg))

        _engine.bulletWorld.attachRigidBody(body)

        return np
예제 #52
0
def makeSB():
    body = BulletRigidBodyNode('...')
    geomNodeCollection = loader.loadModel('out2.egg').findAllMatches('**/+GeomNode')
    for geomNP in geomNodeCollection:
        geomNode = geomNP.node()
        ts = geomNode.getTransform()
        
        
        mesh = BulletTriangleMesh()
        for geom in geomNode.getGeoms():            
            mesh.addGeom(geom)
        shape = BulletTriangleMeshShape(mesh, dynamic=True)
        body.addShape(shape, ts)
        body.addChild(geomNode)
                     
            #world.attachRigidBody(node)
    
    #body.copyTo(np)
    body.setMass(100.0)
    
    world.attachRigidBody(body)
    np1 = render.attachNewNode(body)
    np1.setPos(0, 0, 10)
    np1.setHpr(0,0,90)
    np1.setScale(0.5,0.5,0.5)
    print(body.getNumChildren())
    return body

#body = makeSB()

 
# Update

 
#taskMgr.add(update, 'update')
#run()
예제 #53
0
    def createLetter(self, loadFile, name, x, y, z):
        self.name = name
        self.letter = loader.loadModel(loadFile)
        geomnodes = self.letter.findAllMatches('**/+GeomNode')
        gn = geomnodes.getPath(0).node()
        geom = gn.getGeom(0)
        mesh = BulletTriangleMesh()
        mesh.addGeom(geom)
        shape = BulletTriangleMeshShape(mesh, dynamic=False)

        self.letterNode = BulletRigidBodyNode('Letter')
        self.letterNode.setMass(0)
        self.letterNode.addShape(shape)

        self.letters.append(self.letterNode)
        letternn = render.attachNewNode(self.letterNode)
        letternn.setPos(x, y, z)
        letternn.setScale(1)
        letternn.setP(90) # orients the mesh for the letters to be upright

        self.world.attachRigidBody(self.letterNode)
        self.letter.reparentTo(letternn)

        self.letter.setP(-90) # orients the actual letter objects to be upright
예제 #54
0
  def setup(self):
    self.worldNP = render.attachNewNode('World')

    # World
    self.debugNP = self.worldNP.attachNewNode(BulletDebugNode('Debug'))
    self.debugNP.show()
    self.debugNP.node().showWireframe(True)
    self.debugNP.node().showConstraints(True)
    self.debugNP.node().showBoundingBoxes(False)
    self.debugNP.node().showNormals(False)

    self.world = BulletWorld()
    self.world.setGravity(Vec3(0, 0, -9.81))
    self.world.setDebugNode(self.debugNP.node())

    # Ground
    shape = BulletPlaneShape(Vec3(0, 0, 1), 0)

    body = BulletRigidBodyNode('Ground')
    bodyNP = self.worldNP.attachNewNode(body)
    bodyNP.node().addShape(shape)
    bodyNP.setPos(0, 0, 0)
    bodyNP.setCollideMask(BitMask32.allOn())
    self.world.attachRigidBody(bodyNP.node())

    # Bowl
    visNP = loader.loadModel('models/bowl.egg')

    geom = visNP.findAllMatches('**/+GeomNode').getPath(0).node().getGeom(0)
    mesh = BulletTriangleMesh()
    mesh.addGeom(geom)
    shape = BulletTriangleMeshShape(mesh, dynamic=True)

    body = BulletRigidBodyNode('Bowl')
    bodyNP = self.worldNP.attachNewNode(body)
    bodyNP.node().addShape(shape)
    bodyNP.node().setMass(10.0)
    bodyNP.setPos(0, 0, 0)
    bodyNP.setCollideMask(BitMask32.allOn())
    self.world.attachRigidBody(bodyNP.node())

    visNP.reparentTo(bodyNP)

    self.bowlNP = bodyNP
    self.bowlNP.setScale(2)

    # Eggs
    self.eggNPs = []
    for i in range(5):
      x = random.gauss(0, 0.1)
      y = random.gauss(0, 0.1)
      z = random.gauss(0, 0.1) + 1
      h = random.random() * 360
      p = random.random() * 360
      r = random.random() * 360

      visNP = loader.loadModel('models/egg.egg')

      geom = visNP.findAllMatches('**/+GeomNode').getPath(0).node().getGeom(0)
      shape = BulletConvexHullShape()
      shape.addGeom(geom)

      body = BulletRigidBodyNode('Egg-%i' % i)
      bodyNP = self.worldNP.attachNewNode(body)
      bodyNP.node().setMass(1.0)
      bodyNP.node().addShape(shape)
      bodyNP.node().setDeactivationEnabled(False)
      bodyNP.setCollideMask(BitMask32.allOn())
      bodyNP.setPosHpr(x, y, z, h, p, r)
      #bodyNP.setScale(1.5)
      self.world.attachRigidBody(bodyNP.node())

      visNP.reparentTo(bodyNP)

      self.eggNPs.append(bodyNP)
예제 #55
0
  def setup(self):
    self.worldNP = render.attachNewNode('World')

    # World
    self.debugNP = self.worldNP.attachNewNode(BulletDebugNode('Debug'))
    self.debugNP.show()

    self.world = BulletWorld()
    self.world.setGravity(Vec3(0, 0, -9.81))
    self.world.setDebugNode(self.debugNP.node())

    # Ground
    p0 = Point3(-20, -20, 0)
    p1 = Point3(-20, 20, 0)
    p2 = Point3(20, -20, 0)
    p3 = Point3(20, 20, 0)
    mesh = BulletTriangleMesh()
    mesh.addTriangle(p0, p1, p2)
    mesh.addTriangle(p1, p2, p3)
    shape = BulletTriangleMeshShape(mesh, dynamic=False)

    np = self.worldNP.attachNewNode(BulletRigidBodyNode('Mesh'))
    np.node().addShape(shape)
    np.setPos(0, 0, -4)
    np.setCollideMask(BitMask32.allOn())

    self.world.attachRigidBody(np.node())

    # Soft body world information
    info = self.world.getWorldInfo()
    info.setAirDensity(1.2)
    info.setWaterDensity(0)
    info.setWaterOffset(0)
    info.setWaterNormal(Vec3(0, 0, 0))

    # Softbody - From points/indices
    #import cube
    #points = [Point3(x,y,z) * 3 for x,y,z in cube.nodes]
    #indices = sum([list(x) for x in cube.elements], [])

    #node = BulletSoftBodyNode.makeTetMesh(info, points, indices, True)
    #node.setVolumeMass(300);
    #node.getShape(0).setMargin(0.01)
    #node.getMaterial(0).setLinearStiffness(0.8)
    #node.getCfg().setPositionsSolverIterations(1)
    #node.getCfg().clearAllCollisionFlags()
    #node.getCfg().setCollisionFlag(BulletSoftBodyConfig.CFClusterSoftSoft, True)
    #node.getCfg().setCollisionFlag(BulletSoftBodyConfig.CFClusterRigidSoft, True)
    #node.generateClusters(16)

    #softNP = self.worldNP.attachNewNode(node)
    #softNP.setPos(0, 0, 8)
    #softNP.setHpr(0, 0, 45)
    #self.world.attachSoftBody(node)

    # Softbody - From tetgen data
    ele = file('models/cube/cube.1.ele', 'r').read()
    face = file('models/cube/cube.1.face', 'r').read()
    node = file('models/cube/cube.1.node', 'r').read()

    node = BulletSoftBodyNode.makeTetMesh(info, ele, face, node)
    node.setName('Tetra')
    node.setVolumeMass(300)
    node.getShape(0).setMargin(0.01)
    node.getMaterial(0).setLinearStiffness(0.1)
    node.getCfg().setPositionsSolverIterations(1)
    node.getCfg().clearAllCollisionFlags()
    node.getCfg().setCollisionFlag(BulletSoftBodyConfig.CFClusterSoftSoft, True)
    node.getCfg().setCollisionFlag(BulletSoftBodyConfig.CFClusterRigidSoft, True)
    node.generateClusters(6)

    softNP = self.worldNP.attachNewNode(node)
    softNP.setPos(0, 0, 8)
    softNP.setHpr(45, 0, 0)
    self.world.attachSoftBody(node)

    # Option 1:
    visNP = loader.loadModel('models/cube/cube.egg')
    visNP.reparentTo(softNP)

    geom = visNP \
        .findAllMatches('**/+GeomNode').getPath(0).node() \
        .modifyGeom(0)
    node.linkGeom(geom)
예제 #56
0
  def setup(self):
    self.worldNP = render.attachNewNode('World')

    # World
    self.debugNP = self.worldNP.attachNewNode(BulletDebugNode('Debug'))
    self.debugNP.show()

    self.world = BulletWorld()
    self.world.setGravity(Vec3(0, 0, -9.81))
    self.world.setDebugNode(self.debugNP.node())

    # Ground
    p0 = Point3(-20, -20, 0)
    p1 = Point3(-20, 20, 0)
    p2 = Point3(20, -20, 0)
    p3 = Point3(20, 20, 0)
    mesh = BulletTriangleMesh()
    mesh.addTriangle(p0, p1, p2)
    mesh.addTriangle(p1, p2, p3)
    shape = BulletTriangleMeshShape(mesh, dynamic=False)

    np = self.worldNP.attachNewNode(BulletRigidBodyNode('Mesh'))
    np.node().addShape(shape)
    np.setPos(0, 0, -2)
    np.setCollideMask(BitMask32.allOn())

    self.world.attachRigidBody(np.node())

    # Soft body world information
    info = self.world.getWorldInfo()
    info.setAirDensity(1.2)
    info.setWaterDensity(0)
    info.setWaterOffset(0)
    info.setWaterNormal(Vec3(0, 0, 0))

    # Softbody
    def makeSB(pos, hpr):

      import torus
      geom = torus.makeGeom()

      #geom = loader.loadModel('models/torus.egg') \
      #    .findAllMatches('**/+GeomNode').getPath(0).node() \
      #    .modifyGeom(0)

      geomNode = GeomNode('')
      geomNode.addGeom(geom)

      node = BulletSoftBodyNode.makeTriMesh(info, geom) 
      node.linkGeom(geomNode.modifyGeom(0))

      node.generateBendingConstraints(2)
      node.getCfg().setPositionsSolverIterations(2)
      node.getCfg().setCollisionFlag(BulletSoftBodyConfig.CFVertexFaceSoftSoft, True)
      node.randomizeConstraints()
      node.setTotalMass(50, True)

      softNP = self.worldNP.attachNewNode(node)
      softNP.setPos(pos)
      softNP.setHpr(hpr)
      self.world.attachSoftBody(node)

      geomNP = softNP.attachNewNode(geomNode)

    makeSB(Point3(-3, 0, 4), (0, 0, 0))
    makeSB(Point3(0, 0, 4), (0, 90, 90))
    makeSB(Point3(3, 0, 4), (0, 0, 0))
예제 #57
0
    def setup(self):

        # Debug (useful to turn on for physics)
        self.debugNP = self.render.attachNewNode(BulletDebugNode('Debug'))
        self.debugNP.hide()

        # Physics World
        self.world = BulletWorld()
        self.world.setGravity(Vec3(0, 0, -9.81))
        self.world.setDebugNode(self.debugNP.node())

        # Main Character
        self.player = Player()
        self.player.createPlayer(render, self.world)

        # Enemies
        self.createEnemies()

        # Music
        self.backgroundMusic = loader.loadSfx('../sounds/elfman-piano-solo.ogg')
        self.backgroundMusic.setLoop(True)
        self.backgroundMusic.stop()
        self.backgroundMusic.setVolume(0.9)  # lower this when I add sound effects

        # Sound Effects
        self.collect = base.loader.loadSfx("../sounds/collect-sound.wav")
        self.collect.setVolume(1)
        self.damage = base.loader.loadSfx("../sounds/damage.wav")
        self.damage.setVolume(0.5)
        self.winner = base.loader.loadSfx("../sounds/win-yay.wav")
        self.winner.setVolume(1)
        self.dead = base.loader.loadSfx("../sounds/severe-damage.wav")
        self.dead.setVolume(1)

        # Level 1 Skybox
        self.skybox = loader.loadModel('../models/skybox_galaxy.egg')
        self.skybox.setScale(1000) # make big enough to cover whole terrain
        self.skybox.setBin('background', 1)
        self.skybox.setDepthWrite(0)
        self.skybox.setLightOff()
        self.skybox.reparentTo(render)

        # Lighting
        dLight = DirectionalLight("dLight")
        dLight.setColor(Vec4(0.8, 0.8, 0.5, 1))
        dLight.setDirection(Vec3(-5, -5, -5))
        dlnp = render.attachNewNode(dLight)
        dlnp.setHpr(0, 60, 0)
        render.setLight(dlnp)
        aLight = AmbientLight("aLight")
        aLight.setColor(Vec4(0.5, 0.5, 0.5, 1))
        alnp = render.attachNewNode(aLight)
        render.setLight(alnp)

        # Fog
        colour = (0.2, 0.2, 0.3)
        genfog = Fog("general fog")
        genfog.setColor(*colour)
        genfog.setExpDensity(0.003)
        render.setFog(genfog)
        base.setBackgroundColor(*colour)

        # Create wall (x, y, z, h)
        self.createWall(-30.2215, -6.2, -2, 45)
        self.createWall(-203, 555.8, -2, 70)

        #-----Level 1 Platforms-----
        # Platform to collect B
        self.createPlatform(72, 70.2927, -1)

        # Platforms to collect R
        self.createPlatform(211, 210, -1)
        self.createPlatform(225, 223, 2.7)

        # Platforms to collect E and A
        self.createPlatform(330, 462, -0.4)
        self.createPlatform(340, 471, 2.1)
        self.createPlatform(350, 480, 4)
        self.createPlatform(335, 483, 5)

        # Platforms to collect K
        self.createPlatform(184, 712, -1)
        self.createPlatform(208, 730, -1)
        self.createPlatform(207, 711, -1)
        self.createPlatform(186, 731, -1)

        #-----Level 2 Platforms-----
        # Moving platforms
        if self.movingPlatforms > 0:
            del self.movingPlatforms[:]
        self.createMovingPlatforms()

        # Create complex mesh for Track using BulletTriangleMeshShape
        mesh = BulletTriangleMesh()
        self.track = loader.loadModel("../models/mountain_valley_track.egg")
        self.track.flattenStrong()
        for geomNP in self.track.findAllMatches('**/+GeomNode'):
            geomNode = geomNP.node()
            ts = geomNP.getTransform(self.track)
            for geom in geomNode.getGeoms():
                mesh.addGeom(geom, ts)

        shape = BulletTriangleMeshShape(mesh, dynamic=False)

        node = BulletRigidBodyNode('Track')
        node.setMass(0)
        node.addShape(shape)
        tracknn = render.attachNewNode(node)
        self.world.attachRigidBody(tracknn.node())
        tracknn.setPos(27, -5, -2)
        self.track.reparentTo(tracknn)
예제 #58
0
    def planContactpairs(self, torqueresist = 50, fgrtipdist = 82):
        """
        find the grasps using parallel pairs

        :param: torqueresist the maximum allowable distance to com
        :param: fgrtipdist the maximum dist between finger tips
        :return:

        author: weiwei
        date: 20161130, harada office @ osaka university
        """

        # note that pairnormals and pairfacets are duplicated for each contactpair
        # the duplication is performed on purpose for convenient access
        # also, each contactpair"s" corresponds to a facetpair
        # it is empty when no contactpair is available
        self.gripcontactpairs = []
        # gripcontactpairnormals and gripcontactpairfacets are not helpful
        # they are kept for convenience (they could be accessed using facetnormals and facetpairs)
        self.gripcontactpairnormals = []
        self.gripcontactpairfacets = []

        # for precollision detection
        # bulletworldprecc = BulletWorld()
        # # build the collision shape of objtrimesh
        # geomobj = pandageom.packpandageom(self.objtrimesh.vertices, self.objtrimesh.face_normals,
        #                                   self.objtrimesh.faces)
        # objmesh = BulletTriangleMesh()
        # objmesh.addGeom(geomobj)
        # objmeshnode = BulletRigidBodyNode('objmesh')
        # objmeshnode.addShape(BulletTriangleMeshShape(objmesh, dynamic=True))
        # bulletworldprecc.attachRigidBody(objmeshnode)

        # for raytracing
        bulletworldray = BulletWorld()
        nfacets = self.facets.shape[0]
        self.facetpairs = list(itertools.combinations(range(nfacets), 2))
        for facetpair in self.facetpairs:
            # print "facetpair"
            # print facetpair, len(self.facetpairs)
            self.gripcontactpairs.append([])
            self.gripcontactpairnormals.append([])
            self.gripcontactpairfacets.append([])
            # if one of the facet doesnt have samples, jump to next
            if self.objsamplepnts_refcls[facetpair[0]].shape[0] is 0 or \
                            self.objsamplepnts_refcls[facetpair[1]].shape[0] is 0:
                # print "no sampled points"
                continue
            # check if the faces are opposite and parallel
            dotnorm = np.dot(self.facetnormals[facetpair[0]], self.facetnormals[facetpair[1]])
            if dotnorm < -0.95:
                # check if any samplepnts's projection from facetpairs[i][0] falls in the polygon of facetpairs[i][1]
                facet0pnts = self.objsamplepnts_refcls[facetpair[0]]
                facet0normal = self.facetnormals[facetpair[0]]
                facet1normal = self.facetnormals[facetpair[1]]
                # generate collision mesh
                facetmesh = BulletTriangleMesh()
                faceidsonfacet = self.facets[facetpair[1]]
                geom = pandageom.packpandageom(self.objtrimesh.vertices,
                                               self.objtrimesh.face_normals[faceidsonfacet],
                                               self.objtrimesh.faces[faceidsonfacet])
                facetmesh.addGeom(geom)
                facetmeshbullnode = BulletRigidBodyNode('facet')
                facetmeshbullnode.addShape(BulletTriangleMeshShape(facetmesh, dynamic=True))
                bulletworldray.attachRigidBody(facetmeshbullnode)
                # check the projection of a ray
                for facet0pnt in facet0pnts:
                    pFrom = Point3(facet0pnt[0], facet0pnt[1], facet0pnt[2])
                    pTo = pFrom + Vec3(facet1normal[0], facet1normal[1], facet1normal[2])*9999
                    result = bulletworldray.rayTestClosest(pFrom, pTo)
                    if result.hasHit():
                        hitpos = result.getHitPos()
                        if np.linalg.norm(np.array(facet0pnt.tolist())-np.array([hitpos[0], hitpos[1], hitpos[2]])) < fgrtipdist:
                            fgrcenter = (np.array(facet0pnt.tolist())+np.array([hitpos[0], hitpos[1], hitpos[2]]))/2.0
                            # avoid large torque
                            if np.linalg.norm(self.objtrimesh.center_mass - fgrcenter) < torqueresist:
                                self.gripcontactpairs[-1].append([facet0pnt.tolist(), [hitpos[0], hitpos[1], hitpos[2]]])
                                self.gripcontactpairnormals[-1].append([[facet0normal[0], facet0normal[1], facet0normal[2]],
                                                                    [facet1normal[0], facet1normal[1], facet1normal[2]]])
                                self.gripcontactpairfacets[-1].append(facetpair)

                        # pre collision checking: it takes one finger as a cylinder and
                        # computes its collision with the object
                        ## first finger
                        # cylindernode0 = BulletRigidBodyNode('cylindernode0')
                        # cylinder0height = 50
                        # cylinder0normal = Vec3(facet0normal[0], facet0normal[1], facet0normal[2])
                        # cylindernode0.addShape(BulletCylinderShape(radius=self.preccradius,
                        #                                            height=cylinder0height,
                        #                                            up=cylinder0normal),
                        #                        TransformState.makePos(pFrom+cylinder0normal*cylinder0height*.6))
                        # bulletworldprecc.attachRigidBody(cylindernode0)
                        # ## second finger
                        # cylindernode1 = BulletRigidBodyNode('cylindernode1')
                        # cylinder1height = cylinder1height
                        # # use the inverse of facet0normal instead of facet1normal to follow hand orientation
                        # cylinder1normal = Vec3(-facet0normal[0], -facet0normal[1], -facet0normal[2])
                        # cylindernode1.addShape(BulletCylinderShape(radius=self.preccradius,
                        #                                            height=cylinder1height,
                        #                                            up=cylinder1normal),
                        #                        TransformState.makePos(pFrom+cylinder1normal*cylinder1height*.6))
                        # bulletworldprecc.attachRigidBody(cylindernode1)
                        # if bulletworldprecc.contactTestPair(cylindernode0, objmeshnode) and \
                        #     bulletworldprecc.contactTestPair(cylindernode1, objmeshnode):

                bulletworldray.removeRigidBody(facetmeshbullnode)

        # update the pairs
        availablepairids = np.where(self.gripcontactpairs)[0]
        self.facetpairs = np.array(self.facetpairs)[availablepairids]
        self.gripcontactpairs = np.array(self.gripcontactpairs)[availablepairids]
        self.gripcontactpairnormals = np.array(self.gripcontactpairnormals)[availablepairids]
        self.gripcontactpairfacets = np.array(self.gripcontactpairfacets)[availablepairids]
예제 #59
0
  def setup(self):
    self.worldNP = render.attachNewNode('World')

    # World
    self.debugNP = self.worldNP.attachNewNode(BulletDebugNode('Debug'))
    self.debugNP.show()

    #self.debugNP.showTightBounds()
    #self.debugNP.showBounds()

    self.world = BulletWorld()
    self.world.setGravity(Vec3(0, 0, -9.81))
    self.world.setDebugNode(self.debugNP.node())

    # Ground
    p0 = Point3(-20, -20, 0)
    p1 = Point3(-20, 20, 0)
    p2 = Point3(20, -20, 0)
    p3 = Point3(20, 20, 0)
    mesh = BulletTriangleMesh()
    mesh.addTriangle(p0, p1, p2)
    mesh.addTriangle(p1, p2, p3)
    shape = BulletTriangleMeshShape(mesh, dynamic=False)

    np = self.worldNP.attachNewNode(BulletRigidBodyNode('Mesh'))
    np.node().addShape(shape)
    np.setPos(0, 0, -2)
    np.setCollideMask(BitMask32.allOn())

    self.world.attachRigidBody(np.node())

    # Stair
    origin = Point3(0, 0, 0)
    size = Vec3(2, 10, 1)
    shape = BulletBoxShape(size * 0.5)
    for i in range(10):
      pos = origin + size * i
      pos.setY(0)

      np = self.worldNP.attachNewNode(BulletRigidBodyNode('Stair%i' % i))
      np.node().addShape(shape)
      np.setPos(pos)
      np.setCollideMask(BitMask32.allOn())

      npV = loader.loadModel('models/box.egg')
      npV.reparentTo(np)
      npV.setScale(size)

      self.world.attachRigidBody(np.node())

    # Soft body world information
    info = self.world.getWorldInfo()
    info.setAirDensity(1.2)
    info.setWaterDensity(0)
    info.setWaterOffset(0)
    info.setWaterNormal(Vec3(0, 0, 0))

    # Softbody
    center = Point3(0, 0, 0)
    radius = Vec3(1, 1, 1) * 1.5
    node = BulletSoftBodyNode.makeEllipsoid(info, center, radius, 128)
    node.setName('Ellipsoid')
    node.getMaterial(0).setLinearStiffness(0.1)
    node.getCfg().setDynamicFrictionCoefficient(1)
    node.getCfg().setDampingCoefficient(0.001)
    node.getCfg().setPressureCoefficient(1500)
    node.setTotalMass(30, True)
    node.setPose(True, False)

    np = self.worldNP.attachNewNode(node)
    np.setPos(15, 0, 12)
    #np.setH(90.0)
    #np.showBounds()
    #np.showTightBounds()
    self.world.attachSoftBody(np.node())

    geom = BulletHelper.makeGeomFromFaces(node)
    node.linkGeom(geom)
    nodeV = GeomNode('EllipsoidVisual')
    nodeV.addGeom(geom)
    npV = np.attachNewNode(nodeV)