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
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)
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
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
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
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)
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
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 []
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
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 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
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)
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
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
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
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
def __init__(self): base.accept('f1', self.toggleDebug) self.debugNode = BulletDebugNode('Debug') self.debugNode.showWireframe(True) self.debugNode.showConstraints(True) self.debugNode.showBoundingBoxes(False) self.debugNode.showNormals(False) self.debugNP = base.render.attachNewNode(self.debugNode) # self.debugNP.show() # World self.world = BulletWorld() self.world.setGravity(Vec3(0, 0, -9.81)) self.world.setDebugNode(self.debugNP.node()) # Terrain visNP = base.loader.loadModel('models/terrain.egg') mesh = BulletTriangleMesh() for x in visNP.findAllMatches('**/+GeomNode'): geom = x.node().getGeom(0) mesh.addGeom(geom) shape = BulletTriangleMeshShape(mesh, dynamic=True) body = BulletRigidBodyNode('Bowl') bodyNP = base.render.attachNewNode(body) bodyNP.node().addShape(shape) bodyNP.setPos(0, 0, 1) bodyNP.setCollideMask(BitMask32.allOn()) self.world.attachRigidBody(bodyNP.node()) visNP.reparentTo(bodyNP) shapex = BulletBoxShape(5) bodyx = BulletRigidBodyNode('Egg') bodyNPx = base.render.attachNewNode(bodyx) bodyNPx.setPos(0, 0, 3) bodyNPx.node().setMass(100.0) bodyNPx.node().addShape(shapex) self.world.attachRigidBody(bodyNPx.node()) # visNP.reparentTo(bodyNPx) # Player self.players = [] self.myId = -1 self.speed = Vec3(0, 0, 0) self.walk_speed = 2.5 # Camera base.disableMouse() props = WindowProperties() props.setCursorHidden(True) base.win.requestProperties(props) # SkySphere Sky() self.initCam()
def 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
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
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
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)
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
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
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)
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)
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
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
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
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)
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())
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 __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)
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)
def _shape_from_mesh_component(entity, component): """Load triangle mesh from class MeshComponent""" mesh_filename = "{}.egg".format(component.mesh_name) root_path = entity.scene.resource_manager.root_path model_path = path.join(root_path, "meshes", mesh_filename) filename = Filename.from_os_specific(model_path) nodepath = loader.loadModel(filename) geom_nodepath = nodepath.find('**/+GeomNode') geom_node = geom_nodepath.node() geom = geom_node.get_geom(0) transform = geom_node.getTransform() mesh = BulletTriangleMesh() mesh.addGeom(geom, True, transform) return BulletTriangleMeshShape(mesh, dynamic=False)
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)
def genBulletCDMesh(objcm, 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 = objcm.objnp.findAllMatches("+GeomNode") geombullnode = BulletRigidBodyNode(name) for gnd in gndcollection: geom = copy.deepcopy(gnd.node().getGeom(0)) # vdata = geom.modifyVertexData() # vertrewritter = GeomVertexRewriter(vdata, 'vertex') # while not vertrewritter.isAtEnd(): # v = vertrewritter.getData3f() # vertrewritter.setData3f(v[0]-objcm.com[0], v[1]-objcm.com[1], v[2]-objcm.com[2]) 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(-2) geombullnode.addShape(bullettmshape, geomtf) # rotmatpd4 = objcm.getMat(base.render) # geombullnode.addShape(bullettmshape, # TransformState.makeMat(rotmatpd4). # setPos(rotmatpd4.xformPoint(Vec3(objcm.com[0], objcm.com[1], objcm.com[2])))) from panda3d.core import Mat3, Mat4 # geombullnode.setTransform(TransformState.makeMat(Mat4(Mat3.identMat(), rotmatpd4.xformPoint(Vec3(objcm.com[0], objcm.com[1], objcm.com[2]))))) # print(objcm.com) # print(geomtf.getMat()) # geombullnode.setTransform(TransformState.makeMat(geomtf.getMat()).setPos(geomtf.getMat().xformPoint(Vec3(objcm.com[0], objcm.com[1], objcm.com[2])))) return geombullnode
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)
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 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)
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
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)
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 _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
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)
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
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()
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
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()
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
class Map(object): def __init__(self, mainReference): self.mainRef = mainReference # fog experiment myFog = Fog("Mist") myFog.setColor(0.6, 0.6, 0.6) myFog.setExpDensity(0.0007) render.setFog(myFog) # loading H_Block self.H_Block = loader.loadModel("../../models/H_Block/H_Block") self.H_Block.reparentTo(self.mainRef.render) # loading H_Block's colision mesh self.H_Block_col = loader.loadModel("../../models/H_Block/H_Block_collision") self.H_Block_col.ls() # creating triangle meshes for all static nodes self.hBlockRoomGeom = self.H_Block_col.getChild(0).getNode(0).getGeom(0) self.hBlockBulletMesh = BulletTriangleMesh() self.hBlockBulletMesh.addGeom(self.hBlockRoomGeom) self.hBlockBulletShape = BulletTriangleMeshShape(self.hBlockBulletMesh, dynamic=False) self.bulletHBlockNode = BulletRigidBodyNode('hBlockNode') self.bulletHBlockNode.addShape(self.hBlockBulletShape) self.mainRef.world.attachRigidBody(self.bulletHBlockNode) self.mainRef.render.attachNewNode(self.bulletHBlockNode).setCollideMask(BitMask32.allOn()) # arrays containing all regions and portals dividing those regions self.convexRegions = [] self.portals = [] self.convexRegionsGeometry = loader.loadModel("../../models/H_Block/ConvexRegions2") self.portalsGeometry = loader.loadModel("../../models/H_Block/Portals2") # self.portalsGeometry.reparentTo(self.mainRef.render) # Regions self.convexRegions.append( Region(0) ) # Just making the access to convexRegions easier for convexRegion in self.convexRegionsGeometry.getChild(0).getChildren(): regionNode = convexRegion.getNode(0) regionID = int( regionNode.getTag("prop") ) self.convexRegions.append( Region(regionID) ) # Get vertices that define the convex region vertexReader = GeomVertexReader(regionNode.getGeom(0).getVertexData(), InternalName.getVertex()) while( not(vertexReader.isAtEnd() ) ): data = vertexReader.getData3() X = data.getX() Y = data.getY() Z = data.getZ() self.convexRegions[-1].vertices.append(Vec3(X,Y,Z)) self.convexRegions = sorted(self.convexRegions, key=lambda convexRegion: convexRegion.regionID) # Debug # for cr in self.convexRegions: # print cr.regionID # Portals for portal in self.portalsGeometry.getChild(0).getChildren(): portalNode = portal.getNode(0) # Get vertices that define the portal frontiers = [] vertexReader = GeomVertexReader(portalNode.getGeom(0).getVertexData(), InternalName.getVertex()) for i in range(2): # We got 2 vertices per portal data = vertexReader.getData3() X = data.getX() Y = data.getY() frontiers.append(Vec2(X,Y)) connectedRegionsIDs = map(int, portalNode.getTag("prop").split(',')) self.portals.append( Portal(connectedRegionsIDs, frontiers) ) self.convexRegions[ connectedRegionsIDs[0] ].portalEntrancesList.append( PortalEntrance( self.portals[-1], connectedRegionsIDs[1] ) ) self.convexRegions[ connectedRegionsIDs[1] ].portalEntrancesList.append( PortalEntrance( self.portals[-1], connectedRegionsIDs[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)
def setup(self): # Setup scene 1: bullet World self.worldNP = render.attachNewNode('World') # Debug bullet nodepath self.debugNP = render.attachNewNode(BulletDebugNode('Debug')) self.debugNP.node().showWireframe(True) self.debugNP.node().showConstraints(True) self.debugNP.node().showBoundingBoxes(False) self.debugNP.node().showNormals(True) self.debugNP.show() self.world = BulletWorld() self.world.setGravity(Vec3(0, 0, -9.81)) self.world.setDebugNode(self.debugNP.node()) # Setup scene 2: city # Store the visual model in visNP visNP = loader.loadModel(self.map) visNP.ls() #Find all the geom's in the models visual node path; #There should only be one so we d ont need to iterate th rough all geoms found #This is so we can get the vertex information #We want to only find the lowpoly collision mesh geomnodes. geomCollect = visNP.findAllMatches('**/=col=1') #Create a mesh to store the data. mesh = BulletTriangleMesh() #loop through all the geoms found and add them to the mesh for np in geomCollect: ts = np.getTransform(visNP) for i in range(np.node().getNumGeoms()): geom = np.node().getGeom(i) #Add the geom information to the mesh #along with transform information from the visual mesh mesh.addGeom(geom, True, ts) #create a physical shape out of the triangle mesh information shape = BulletTriangleMeshShape(mesh, dynamic=False) #Create a rigid body node to add the shape too. body = BulletRigidBodyNode('City') #Attach the city node to the worldNP so its visible bodyNP = self.worldNP.attachNewNode(body) #Add the shape we created to the node bodyNP.node().addShape(shape) #bodyNP.node().setMass(0.0) bodyNP.setPos(0, 0, 0) bodyNP.setCollideMask(BitMask32.allOn()) #Attach it to the bullet world so its simulated self.world.attachRigidBody(bodyNP.node()) #Reparent the visual node to the collision mesh node visNPHigh = visNP.find('**/=vis=1') visNPHigh.reparentTo(bodyNP) self.level = bodyNP
axis = loader.loadModel('zup-axis.egg') axis.reparentTo(base.render) axis.setPos(hndpos) axis.setScale(50) axis.lookAt(hndpos+ydirect) bullcldrnp = base.render.attachNewNode("bulletcollider") base.world = BulletWorld() # hand base # rtq85hnd.rtq85np.find("**/rtq85base").showTightBounds() gbnp = rtq85hnd.rtq85np.find("**/rtq85base").find("**/+GeomNode") gb = gbnp.node().getGeom(0) gbts = gbnp.getTransform(base.render) gbmesh = BulletTriangleMesh() gbmesh.addGeom(gb) bbullnode = BulletRigidBodyNode('gb') bbullnode.addShape(BulletTriangleMeshShape(gbmesh, dynamic=True), gbts) bcollidernp=bullcldrnp.attachNewNode(bbullnode) base.world.attachRigidBody(bbullnode) bcollidernp.setCollideMask(BitMask32.allOn()) # rtq85hnd.rtq85np.find("**/rtq85lfgrtip").showTightBounds() glftnp = rtq85hnd.rtq85np.find("**/rtq85lfgrtip").find("**/+GeomNode") glft = glftnp.node().getGeom(0) glftts = glftnp.getTransform(base.render) glftmesh = BulletTriangleMesh() glftmesh.addGeom(glft) # lftbullnode = BulletRigidBodyNode('glft') # lftbullnode.addShape(BulletTriangleMeshShape(glftmesh, dynamic=True), glftts) # lftcollidernp=bullcldrnp.attachNewNode(lftbullnode)
def __addTriangleMesh(self, body, geom, pos=(0,0,0), hpr=(0,0,0), scale=(1,1,1), dynamic=True): mesh = BulletTriangleMesh() mesh.addGeom(geom) shape = BulletTriangleMeshShape(mesh, dynamic=dynamic ) body.addShape( shape, TransformState.makePosHprScale(pos,hpr,scale) )
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)
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]