Esempio n. 1
0
 def __init__(self, name, scene, visibleLODsDict={"eggfileName":("maxFar","minNear")}, collisionEgg=None, x0=0, y0=0, z0=0, parent=None, margin=0.02, mass=0,
              directRender=True, convex=True):
     self.name = name
     self.scene = scene
     NodePath.__init__(self,LODNode(name+"_LODNode"))
     ###LOD###
     for k in visibleLODsDict.keys():
         v=base.loader.loadModel(k)
         v.reparentTo(self)
         self.node().addSwitch(visibleLODsDict[k][0],visibleLODsDict[k][1])
     #########
     self.body = BulletRigidBodyNode(self.name + "_RigidBody")
     self.attachNewNode(self.body)
     if collisionEgg != None:
         m = self.scene.Base.loader.loadModel(collisionEgg)
         if convex:
             sTuple = modelToConvex(m)
         else:
             sTuple = modelToShape(m)
         sTuple[0].setMargin(margin)
         self.body.addShape(sTuple[0], sTuple[1])
         self.body.setMass(mass)
         self.body.setPythonTag("name", self.name + "_RigidBody")
         self.scene.world.attachRigidBody(self.body)
     self.setPos(x0, y0, z0)
     if directRender:
         self.reparentTo(self.scene.Base.render)
     elif parent != None:
         self.reparentTo(parent)
    def CreateGfx(self, loader, idx):
        #                __node
        #                /   \
        #  cellsNodePath   columnBox

        self.lod = LODNode("columnLOD")  # Level of detail node for Column
        self.__node = NodePath(
            self.lod
        )  # NodePath(PandaNode('column'))# loader.loadModel("models/box")
        self.__node.setPos(0, 0, 0)
        self.__node.setScale(1, 1, 1)

        self.idx = idx

        # self.__node.setTag('clickable',str(idx))#to be able to click on it

        self.__rhombusEnvelope = loader.loadModel(
            os.path.join(os.getcwd(), "models/rhombus"))
        self.__rhombusEnvelope.setPos(self.width / 2, self.width / 2, 0.0)

        self.__rhombusEnvelope.setScale(self.width / 2, self.width / 2, 0.5)
        self.__rhombusEnvelope.setName("columnBox")

        self.__cellsNodePath = NodePath(
            PandaNode("cellsNode"))  # to pack all cells into one node path
        self.__cellsNodePath.setName("column")
        self.__cellsNodePath.setTag(
            "id",
            str(idx))  # to be able to retrieve index of column for mouse click

        self.lod.addSwitch(100.0, 0.0)
        self.lod.addSwitch(5000.0, 100.0)

        self.__cellsNodePath.reparentTo(self.__node)
        self.__rhombusEnvelope.reparentTo(self.__node)

        x = 0
        y = 0
        idx = 0
        for n in self.cells:
            n.CreateGfx(loader, idx)
            idx += 1

            pos = self._TransformRhombToGlob([x, y], 1 + self.CELL_OFFSET, 0.0)

            n.getNode().setPos(pos[0], pos[1], 0)

            x += 1
            if x >= self.nOfCellsPerAxis:
                y += 1
                x = 0

            n.getNode().reparentTo(self.__cellsNodePath)

        self.gfxCreated = True
Esempio n. 3
0
    def CreateGfx(self, loader, idx):
        #                __node
        #                /   \
        #  cellsNodePath   columnBox

        self.lod = LODNode("columnLOD")  # Level of detail node for Column
        self.__node = NodePath(
            self.lod
        )  # NodePath(PandaNode('column'))# loader.loadModel("models/box")
        self.__node.setPos(0, 0, 0)
        self.__node.setScale(1, 1, 1)

        self.idx = idx

        # self.__node.setTag('clickable',str(idx))#to be able to click on it

        self.__columnBox = loader.loadModel(os.path.join(os.getcwd(),"models/cube"))
        self.__columnBox.setPos(
            0, 0, -0.5 + (0 if len(self.cells) == 0 else len(self.cells)*(1+CELL_OFFSET) / 2)
        )
        self.__columnBox.setScale(
            0.5, 0.5, 0.5 * (1 if len(self.cells) == 0 else len(self.cells)*(1+CELL_OFFSET))
        )
        self.__columnBox.setName("columnBox")

        self.__cellsNodePath = NodePath(
            PandaNode("cellsNode")
        )  # to pack all cells into one node path
        self.__cellsNodePath.setName("column")
        self.__cellsNodePath.setTag(
            "id", str(idx)
        )  # to be able to retrieve index of column for mouse click

        self.lod.addSwitch(100.0, 0.0)
        self.lod.addSwitch(5000.0, 100.0)

        self.__cellsNodePath.reparentTo(self.__node)
        self.__columnBox.reparentTo(self.__node)

        z = 0
        idx = 0
        for n in self.cells:
            n.CreateGfx(loader, idx)
            idx += 1
            n.getNode().setPos(0, 0, z)
            z += 1+CELL_OFFSET
            n.getNode().reparentTo(self.__cellsNodePath)

        self.gfxCreated = True
Esempio n. 4
0
 def make_lod(self):
     shapes = loader.load_model("assets/shapes.bam")
     for shape in shapes.get_children():
         lod = LODNode(shape.name+ "_lod")
         lod_root = NodePath(lod)
         self.shapes[shape.name] = lod_root
         lod_shapes = list(shape.get_children())
         lod_shapes.sort(key=lambda x: x.name, reverse=True)
         prev = 2
         for l, lod_shape in enumerate(lod_shapes):
             lod_shape.clear_transform()
             far, near = ((l+2)*4)*100, prev-2
             lod.add_switch(far, near)
             lod_shape.reparent_to(lod_root)
             prev = far
Esempio n. 5
0
    def __init__(self):
        # The basics
        ShowBase.__init__(self)
        base.disableMouse()
        # Add the model

        lod = LODNode('Tree LOD node')
        tree = NodePath(lod)
        tree.reparentTo(render)

        tree2 = self.loader.loadModel("tree2")
        lod.addSwitch(50.0, 0.0)
        tree2.reparentTo(tree)

        tree1 = self.loader.loadModel("tree1")
        lod.addSwitch(100.0, 50.0)
        tree1.reparentTo(tree)

        tree0 = self.loader.loadModel("tree0")
        lod.addSwitch(999999.0, 100.0)
        tree0.reparentTo(tree)

        # Bookkeeping for the rotation around the model
        self.direction = 0.0
        self.distance = 20.0
        self.speed = 20.0
        self.last_time = 0.0

        # Initial camera setup
        self.camera.set_pos(0, -self.distance, self.distance)
        self.camera.look_at(0, 0, 5)

        # Key events and camera movement task
        self.accept("arrow_up", self.adjust_distance, [-1.0])
        self.accept("arrow_up-up", self.adjust_distance, [1.0])
        self.accept("arrow_down", self.adjust_distance, [1.0])
        self.accept("arrow_down-up", self.adjust_distance, [-1.0])
        self.accept("escape", sys.exit)
        self.taskMgr.add(self.update_camera, 'adjust camera', sort=10)
Esempio n. 6
0
        def makeTile(x, y, tile):
            # the idea here is to make
            # all the needed nodes,
            # then instance them to all the LODNode's children that show them

            x2 = x + size
            y2 = y + size

            tileCenter = Vec3(x + x2, y + y2, 0) / 2

            collisionNode = NodePath(
                CollisionNode("tile_collisionNode")) if collision else None

            for l in levels:
                l.initForTile(tile)
            for f, levs in factoryToLevels.iteritems():
                f.draw(dict((l.lod, l.drawResourcesFactory) for l in levs), x,
                       y, x2, y2, tileCenter, collisionNode)

            collisionUtil.colTree(collisionNode)
            lodNode = LODNode('tile_lod')
            lodNodePath = NodePath(lodNode)

            subTileNodeLists = []
            s = size / 2
            for f in subTileFactories:
                nodeList = [
                    f(x, y, tile),
                    f(x + s, y, tile),
                    f(x, y + s, tile),
                    f(x + s, y + s, tile)
                ]
                subTileNodeLists.append(nodeList)

            for l in levels:
                l.finishTile()

            lodNodePath.setPos(tileCenter)
            if collision: collisionNode.setPos(tileCenter)
            for lod, levs in LODAndLevelList:
                holder = NodePath("holder")
                # instance regular meshes
                for l in levs:
                    n = l.node
                    if n is not None:
                        n.instanceTo(holder)
                # instance subtile LOD nodes
                if lod in LODtoSubTileFactoryIndexs:
                    for i in LODtoSubTileFactoryIndexs[lod]:
                        for n in subTileNodeLists[i]:
                            instanceTo(holder)

                holder.reparentTo(lodNodePath)
                lodNode.addSwitch(lod.high, lod.low)

            # TODO, better center LOD Node using bounds
            # lodNode.setCenter()

            for l in levels:
                l.clean()

            if collision:
                tileHolder = NodePath("tile_holder")
                collisionNode.reparentTo(tileHolder)
                lodNodePath.reparentTo(tileHolder)
                return tileHolder
            else:
                return lodNodePath