def __init__(self): ShowBase.__init__(self) props = WindowProperties( ) props.setTitle( 'Differentiable Physics Engine' ) self.win.requestProperties( props ) self.t = 0 self.starttime = time.time() #self.setFrameRateMeter(True) cour = self.loader.loadFont('cmtt12.egg') self.textObject = OnscreenText(font= cour, text = 'abcdefghijklmnopqrstuvwxyz', pos=(0, -0.045), parent = self.a2dTopCenter, bg=(0,0,0,1), fg =(1,1,1,1), scale = 0.07, mayChange=True) cm = CardMaker("ground") cm.setFrame(-2000, 2000, -2000, 2000) cm.setUvRange(Point2(-2000/5,-2000/5),Point2(2000/5,2000/5)) tmp = self.render.attachNewNode(cm.generate()) tmp.reparentTo(self.render) tmp.setPos(0, 0, 0) tmp.lookAt((0, 0, -2)) tmp.setColor(1.0,1.0,1.0,1) tmp.setTexScale(TextureStage.getDefault(), 1, 1) tex = self.loader.loadTexture('textures/grid2.png') tex.setWrapU(Texture.WMRepeat) tex.setWrapV(Texture.WMRepeat) tmp.setTexture(tex,1) self.setBackgroundColor(0.0, 191.0/255.0, 1.0, 1.0) #color of the sky ambientLight = AmbientLight('ambientLight') ambientLight.setColor(Vec4(0.2, 0.2, 0.2, 1)) ambientLightNP = self.render.attachNewNode(ambientLight) self.render.setLight(ambientLightNP) # Directional light 01 directionalLight = DirectionalLight('directionalLight') directionalLight.setColor(Vec4(0.8, 0.8, 0.8, 1)) directionalLightNP = self.render.attachNewNode(directionalLight) # This light is facing backwards, towards the camera. directionalLightNP.setHpr(-60, -50, 0) directionalLightNP.node().setScene(self.render) directionalLightNP.node().setShadowCaster(True) directionalLightNP.node().getLens().setFov(40) directionalLightNP.node().getLens().setNearFar(10, 100) self.render.setLight(directionalLightNP) # Add the spinCameraTask procedure to the task manager. self.taskMgr.add(self.spinCameraTask, "SpinCameraTask") # Load the environment model. self.objects = dict() self.names = [] data = pickle.load(open("../PhysXVids/state-dump-exp15.pkl","rb")) self.json = json.loads(data["json"]) # json.loads(data["json"]) self.states = data["states"] self.load_robot_model() self.dt = self.json["integration_parameters"]["time_step"] self.setupKeys() self.robot_id = 0
def tile(x, y): """ Helper function, finds coordinates of a tile in a 16x16 texture map. """ return (Point2(x * TILE, 1 - ((y + 1) * TILE)), Point2((x + 1) * TILE, 1 - (y * TILE)))
def __init__(self): super().__init__() self.disable_mouse() self._background = load_object("background", pos=Point2(0, 0), scale=9000, depth=200, transparency=False) self._gameboard = load_object("background", pos=Point2(0, 0), scale=39.5, depth=100, transparency=False) gen_label_text("ESC : Quit", 0) gen_label_text("SPACE: Pause", 1) gen_label_text("R : Restart", 2) self._score = gen_label_text("", 0, left=False) self._bricks = deque() self._dot = load_object("brick", pos=Point2(0, 0)) self._restart() self.accept("escape", sys.exit) self.accept("enter", self.restart) self.accept("arrow_up", self._turn, [settings.POS_Y]) self.accept("arrow_down", self._turn, [settings.NEG_Y]) self.accept("arrow_left", self._turn, [settings.NEG_X]) self.accept("arrow_right", self._turn, [settings.POS_X]) self.accept("space", self._tooggle_pause) self.accept("r", self._restart) self.period = settings.PERIOD self.pause = True
def __init__(self, device): GuiHandler.__init__(self) self.func3 = "Si" self.func2 = "" self.func1 = "No" self.title = "Guardar?" self.parent = device self.video_mode = False option = WebcamVideo.get_option(0) self.texture = MovieTexture(option) self.texture.setKeepRamImage(True) #self.texture = OpenCVTexture() #self.texture.fromCamera() scale = self.texture.getTexScale() print scale #self.texture = OpenCVTexture() self.card = CardMaker('webcam') self.card.setFrame(-scale[0], scale[0], -scale[1], scale[1]) self.card.setUvRange(Point2(scale[0], 0), Point2(0, scale[1])) self.card = render.attachNewNode(self.card.generate()) screen = self.parent.get_screen() self.card.reparentTo(screen.getParent()) self.card.setTransform(screen.getTransform()) self.card.setSx(0.49) self.card.setSz(0.394) self.card.setHpr(0, 270, 0) self.card.setPos(0.004, 0.335, 0.1) self.card.hide()
def _scanTask(self, task): if self.suitList is not None: data = self.suitList else: if self.suitDict is not None: data = self.suitDict.values() else: return task.done for suit in data: if suit == self.suit: continue if suit.getLevel() < self.suit.getLevel(): continue else: if suit.getLevel() == self.suit.getLevel( ) and suit.doId > self.suit.doId: continue currPos = Point2(self.suit.getX(render), self.suit.getY(render)) otherPos = Point2(suit.getX(render), suit.getY(render)) if (currPos - otherPos).length() < self.DivertDistance: self.fsm.request('divert') return task.done return task.again
def setupTexture(self): cm = CardMaker('quadMaker') cm.setColor(1.0, 1.0, 1.0, 1.0) aspect = base.camLens.getAspectRatio() htmlWidth = 2.0 * aspect * WEB_WIDTH_PIXELS / float(WIN_WIDTH) htmlHeight = 2.0 * float(WEB_HEIGHT_PIXELS) / float(WIN_HEIGHT) cm.setFrame(-htmlWidth / 2.0, htmlWidth / 2.0, -htmlHeight / 2.0, htmlHeight / 2.0) bottomRightX = WEB_WIDTH_PIXELS / float(WEB_WIDTH + 1) bottomRightY = WEB_HEIGHT_PIXELS / float(WEB_HEIGHT + 1) cm.setUvRange(Point2(0, 1 - bottomRightY), Point2(bottomRightX, 1)) card = cm.generate() self.quad = NodePath(card) self.quad.reparentTo(self.parent_) self.guiTex = Texture('guiTex') self.guiTex.setupTexture(Texture.TT2dTexture, WEB_WIDTH, WEB_HEIGHT, 1, Texture.TUnsignedByte, Texture.FRgba) self.guiTex.setMinfilter(Texture.FTLinear) self.guiTex.setKeepRamImage(True) self.guiTex.makeRamImage() self.guiTex.setWrapU(Texture.WMRepeat) self.guiTex.setWrapV(Texture.WMRepeat) ts = TextureStage('webTS') self.quad.setTexture(ts, self.guiTex) self.quad.setTexScale(ts, 1.0, -1.0) self.quad.setTransparency(0) self.quad.setTwoSided(True) self.quad.setColor(1.0, 1.0, 1.0, 1.0) self.calcMouseLimits()
def setClickRegionFrame(self, left, right, bottom, top): transform = self.contents.getNetTransform() # We use the inverse of the cam transform so that it will not be # applied to the frame points twice: camTransform = base.cam.getNetTransform().getInverse() # Compose the inverse of the cam transform and our node's transform: transform = camTransform.compose(transform) # Discard its rotational components: transform.setQuat(Quat()) # Transform the frame points into cam space: mat = transform.getMat() camSpaceTopLeft = mat.xformPoint(Point3(left, 0, top)) camSpaceBottomRight = mat.xformPoint(Point3(right, 0, bottom)) # Project into screen space: screenSpaceTopLeft = Point2() screenSpaceBottomRight = Point2() base.camLens.project(Point3(camSpaceTopLeft), screenSpaceTopLeft) base.camLens.project(Point3(camSpaceBottomRight), screenSpaceBottomRight) left, top = screenSpaceTopLeft right, bottom = screenSpaceBottomRight self.region.setFrame(left, right, bottom, top)
def __init__(self): ShowBase.__init__(self) base.setFrameRateMeter(True) m = loader.loadModel("models/smiley") m.reparent_to(render) m.set_pos(0, 5, 0) x_size, y_size = 640, 480 xy_ratio = float(y_size) / float(x_size) self.plot = Plot(x_size, y_size) self.input_img = PNMImage(x_size, y_size) self.input_tex = Texture() self.input_tex.load(self.input_img) self.card = CardMaker('pygame_card') self.card.setUvRange( Point2(0, 1), # ll Point2(1, 1), # lr Point2(1, 0), # ur Point2(0, 0)) # ul self.screen = render.attach_new_node(self.card.generate()) self.screen.set_scale(1, 1, xy_ratio) self.screen.set_pos(-0.5, 2, -0.5 * xy_ratio) self.screen.setTexture(self.input_tex) # FIXME: Apparently mpl's print_to_buffer() doesn't write # alpha values properly. self.screen.setTransparency(TransparencyAttrib.MAlpha) taskMgr.add(self.update, "update plot")
def __init__(self, world, app): self.world = world self.image = PNMImage(self.world.width, 256) for z in self.world.zlevels(): for x in range(self.world.height): mix = sum([ZMap.COLORS[self.world.get_block(x, y, z).substance] for y in range(self.world.height)], VBase3F(0.0)) self.image.setXel(x, z, mix / float(self.world.height)) self.texture = Texture() self.texture.load(self.image) self.texture.setMagfilter(Texture.FTNearest) self.texture.setMinfilter(Texture.FTNearest) cm = CardMaker('zmap') cm.setFrame(0.95, 1, -1, 1) cm.setUvRange(Point2(1.0, 1.0), Point2(0.0, 1.0 - self.world.depth / 256.0)) self.zcard = app.render2d.attachNewNode(cm.generate()) self.zcard.setTexture(self.texture) cm = CardMaker('zpointer') cm.setFrame(0, 0.05, 0, 1.0 / self.world.depth) self.zpointer = app.render2d.attachNewNode(cm.generate()) self.zpointer.setColorScale(1.0, 0.0, 0.0, 0.4) self.accept('slice-changed', self.slice_changed)
def enterDivert(self): moveVector = Vec2() currPos = Point2(self.suit.getX(render), self.suit.getY(render)) if self.suitList is not None: data = self.suitList elif self.suitDict is not None: data = self.suitDict.values() for suit in data: if suit == self.suit: continue otherPos = Point2(suit.getX(render), suit.getY(render)) moveAway = currPos - otherPos if moveAway.length() > self.DivertDistance: continue moveMag = 1.0 / max(moveAway.lengthSquared(), 0.1) moveAway.normalize() moveAway *= moveMag moveVector += moveAway moveVector.normalize() x, y = currPos + (moveVector * self.DivertDistance) self.createPath(pos=(x, y))
def retracePath(current): path = [Point2(current.x, current.y)] while current.parent is not None: current = current.parent path.append(Point2(current.x, current.y)) path.reverse() return path
def loadFlatQuad(self, fullFilename): cm = CardMaker('cm-%s' % fullFilename) cm.setColor(1.0, 1.0, 1.0, 1.0) aspect = base.camLens.getAspectRatio() htmlWidth = 2.0 * aspect * WEB_WIDTH_PIXELS / float(WIN_WIDTH) htmlHeight = 2.0 * float(WEB_HEIGHT_PIXELS) / float(WIN_HEIGHT) cm.setFrame(-htmlWidth / 2.0, htmlWidth / 2.0, -htmlHeight / 2.0, htmlHeight / 2.0) bottomRightX = WEB_WIDTH_PIXELS / float(WEB_WIDTH + 1) bottomRightY = WEB_HEIGHT_PIXELS / float(WEB_HEIGHT + 1) cm.setUvRange(Point2(0, 1 - bottomRightY), Point2(bottomRightX, 1)) card = cm.generate() quad = NodePath(card) jpgFile = PNMImage(WEB_WIDTH, WEB_HEIGHT) smallerJpgFile = PNMImage() readFile = smallerJpgFile.read(Filename(fullFilename)) if readFile: jpgFile.copySubImage(smallerJpgFile, 0, 0) guiTex = Texture('guiTex') guiTex.setupTexture(Texture.TT2dTexture, WEB_WIDTH, WEB_HEIGHT, 1, Texture.TUnsignedByte, Texture.FRgba) guiTex.setMinfilter(Texture.FTLinear) guiTex.load(jpgFile) guiTex.setWrapU(Texture.WMClamp) guiTex.setWrapV(Texture.WMClamp) ts = TextureStage('webTS') quad.setTexture(ts, guiTex) quad.setTransparency(0) quad.setTwoSided(True) quad.setColor(1.0, 1.0, 1.0, 1.0) result = quad else: result = None Texture.setTexturesPower2(1) return result
def getMoveIvalFromPath(suit, path, elapsedT, isClient, seqName): baseSpeed = 5.0 walkMod = suit.suitPlan.getCogClassAttrs().walkMod speed = baseSpeed * walkMod moveIval = Sequence(name=suit.uniqueName(seqName)) if isClient: moveIval.append(Func(suit.setPlayRate, walkMod, 'walk')) moveIval.append(Func(suit.animFSM.request, 'walk')) for i in xrange(len(path)): if i == 0: continue waypoint = path[i] lastWP = path[i - 1] moveIval.append(Func(suit.headsUp, Point3(*waypoint))) ival = NPCWalkInterval( suit, Point3(*waypoint), startPos=Point3(*lastWP), fluid=1, name=suit.uniqueName('doWalkIval' + str(i)), duration=(Point2(waypoint[0], waypoint[1]) - Point2(lastWP[0], lastWP[1])).length() / speed) moveIval.append(ival) if isClient: moveIval.append(Func(suit.setPlayRate, 1.0, 'walk')) moveIval.append(Func(suit.animFSM.request, 'neutral')) return moveIval
def __init__(self, manager, xml): self.texture = loader.loadTexture('data/textures/bullet-hole.png') self.texture.setMinfilter(Texture.FTLinearMipmapLinear) self.container = render.attachNewNode(ModelRoot('bullet-holes')) self.card = CardMaker('bullet-hole') s = BULLETHOLE_SIZE * 0.5 self.card.setFrame(-s, s, -s, s) self.card.setUvRange(Point2(0, 0), Point2(1, 1))
def makeChunk(self, pos, size): self.bgs.append( utilities.loadObject("stars", depth=100, scaleX=200, scaleY=200.0, pos=Point2(pos.x * worldsize.x, pos.y * worldsize.y))) genFillBox(self, Point2(5, 5), 3, 6, 'metalwalls') genBox(self, Point2(10, 5), 2, 2, 'metalwalls')
def __init__(self): #This code puts the standard title and instruction text on screen self.title = OnscreenText(text="DX-Ball Game", style=1, fg=(1, 1, 0, 1), pos=(0.8, -0.95), scale=.07) self.escapeText = genLabelText("ESC: Quit", 0) self.leftkeyText = genLabelText("[Left Arrow]: Move Left", 1) self.rightkeyText = genLabelText("[Right Arrow]: Move Right", 2) self.spacekeyText = genLabelText("[Space Bar]: Fire Ball", 3) self.keys = {"turnLeft": 0, "turnRight": 0, "accel": 0, "fire": 0} self.accept("escape", sys.exit) #Escape quits #Other keys events set the appropriate value in our key dictionary self.accept("arrow_left", self.setKey, ["turnLeft", 1]) self.accept("arrow_left-up", self.setKey, ["turnLeft", 1]) self.accept("arrow_right", self.setKey, ["turnRight", 1]) self.accept("arrow_right-up", self.setKey, ["turnRight", 1]) self.accept("arrow_up", self.setKey, ["accel", 1]) self.accept("arrow_up-up", self.setKey, ["accel", 1]) self.accept("space", self.setKey, ["fire", 1]) base.disableMouse() #Disable default mouse-based camera control self.bg = loadObject( "stars", scale=146, depth=200, transparency=False) #Load the background starfield self.ship = loadObject("boardfinal", pos=Point2(0, -13), scale=BOARD_INIT_SCALE) self.ball = loadObject("ball", pos=Point2(0, -10), scale=BALL_INIT_SCALE) self.setVelocity(self.ball, Vec3(0, 0, 0)) #Initial velocity self.bricks = [] for i in range(-18, 19, 2): for j in range(8, 12, 1): self.bricks.append( loadObject("brickfinal", pos=Point2(i, j), scale=BRI_INIT_SCALE)) #As described earlier, this simply sets a key in the self.keys dictionary to #self.setExpires(self.ball,0) self.alive = True #the given value self.gameTask = taskMgr.add(self.flush_new, "flush") print "End game" self.gameTask.last = 0 #Task time of the last frame
def _projectPointToLine(self, point, line): x1, y1, x2, y2 = line x, y = point origin = Point2(x1, y1) vecLine = Point2(x2, y2) - origin vecPoint = Point2(x, y) - origin projectedPoint = vecPoint.project(vecLine) if projectedPoint.lengthSquared() > vecLine.lengthSquared(): return None if projectedPoint.dot(vecLine) < 0: return None return origin + projectedPoint
def update(self, time): self.location = Point2(self.node.getPos().x - self.player.location.x, self.node.getPos().z - self.player.location.y) if self.location.x > 20 or self.location.x < -20: return if self.location.y > 20 or self.location.y < -20: return path = findPath(Point2(self.location + Point2(20, 20)), Point2(20, 20), self.world.cmap) if len(path) > 1: move = path[1] - self.location self.bnode.applyCentralForce(Vec3(move.x - 20, 0, move.y - 20))
def make_bounds(lens, scale_size=None, crop_size=None): """ Allocates and returns a new BoundingVolume that encloses the frustum used for this kind of lens, if possible. If a suitable bounding volume cannot be created, returns None. Same as Lens's make_bounds method except that the frustrum could be smaller by specifying a scale_size or crop_size. Original implementation of make_bounds is in here: https://github.com/panda3d/panda3d/blob/master/panda/src/gobj/lens.cxx """ fll = Point3() flr = Point3() ful = Point3() fur = Point3() nll = Point3() nlr = Point3() nul = Point3() nur = Point3() film_size = lens.getFilmSize() scale_size = scale_size or 1.0 crop_size = tuple(crop_size) or film_size ll = Point2(-crop_size[0] / scale_size / film_size[0], -crop_size[1] / scale_size / film_size[1]) lr = Point2(+crop_size[0] / scale_size / film_size[0], -crop_size[1] / scale_size / film_size[1]) ul = Point2(-crop_size[0] / scale_size / film_size[0], +crop_size[1] / scale_size / film_size[1]) ur = Point2(+crop_size[0] / scale_size / film_size[0], +crop_size[1] / scale_size / film_size[1]) # Upper left. if not lens.extrude(ul, nul, ful): return None # Upper right. if not lens.extrude(ur, nur, fur): return None # Lower right. if not lens.extrude(lr, nlr, flr): return None # Lower left. if not lens.extrude(ll, nll, fll): return None return BoundingHexahedron(fll, flr, fur, ful, nll, nlr, nur, nul)
def mouseLeftClickUp(self): """Handles left mouse click actions when mouse button is depressed. Used for unit movement. """ o = None if self.hovered_compass_tile != None: x = self.turn_node.getPythonTag('pos')[0] y = self.turn_node.getPythonTag('pos')[1] orientation = int(self.hovered_compass_tile.getTag('key')) if orientation == utils.HEADING_NW: o = Point2(x - 1, y + 1) elif orientation == utils.HEADING_N: o = Point2(x, y + 1) elif orientation == utils.HEADING_NE: o = Point2(x + 1, y + 1) elif orientation == utils.HEADING_W: o = Point2(x - 1, y) elif orientation == utils.HEADING_E: o = Point2(x + 1, y) elif orientation == utils.HEADING_SW: o = Point2(x - 1, y - 1) elif orientation == utils.HEADING_S: o = Point2(x, y - 1) elif orientation == utils.HEADING_SE: o = Point2(x + 1, y - 1) else: o = None self.hideMoveCompass() if o != None: ClientMsg.move(self.parent.sel_unit_id, (x, y), (o.x, o.y))
def getTriangulatorGeomData(pointList, normalVec, texScale=(1, 1), color=(1, 1, 1, 1)): """ takes a list of points and a normal vector, gets the corresponding triangulated polygon, returns a dict with the data of that triangulated polygon : data = {"prims":[], "vertices" : [], "normals" : [], "texcoords" : []} """ data = { "prims": [], "vertices": [], "normals": [], "texcoords": [], "colors": [] } normalVec = Vec3(normalVec) normalVec.normalize() u, v = texScale trig = Triangulator() for x, y, z in pointList: if normalVec[2] > 0: vi = trig.addVertex(x, y) data["texcoords"].append(Point2(x * u, y * u)) elif normalVec[1] > 0: vi = trig.addVertex(x, z) data["texcoords"].append(Point2(x * u, z * u)) else: vi = trig.addVertex(y, z) data["texcoords"].append(Point2(y * u, z * u)) data["vertices"].append(Point3(x, y, z)) data["normals"].append(normalVec) data["colors"].append(color) trig.addPolygonVertex(vi) trig.triangulate() for i in xrange(trig.getNumTriangles()): A, B, C = trig.getTriangleV0(i), trig.getTriangleV1( i), trig.getTriangleV2(i) data["prims"].append((A, B, C)) #if normalVec[2]>0: # data["prims"].append((A, B, C)) #else: # data["prims"].append((A, C, B)) return data
def planPath(self, fromPoint, toPoint, closeEnough=0): x1, y1 = fromPoint x2, y2 = toPoint if not self._testLineIntersections((x1, y1, x2, y2), self.borders): return [ toPoint] fromVertex = AStarVertex(Point2(x1, y1)) toVertex = AStarVertex(Point2(x2, y2)) for vertex in self.vertices: self._considerLink(vertex, fromVertex) self._considerLink(vertex, toVertex) tempVertices = [fromVertex, toVertex] isApproximate = False try: if not toVertex.getNeighbors(): if closeEnough is 0: return isApproximate = True closeEnoughSquared = closeEnough * closeEnough for border in self.borders: projected = self._projectPointToLine(toVertex.pos, border) if projected is None: continue if (projected - toVertex.pos).lengthSquared() > closeEnoughSquared: continue projectionDirection = projected - toVertex.pos projectionDirection.normalize() projected += projectionDirection * self.VERTEX_EXTRUSION projectedVertex = AStarVertex(projected) projectedVertex.link(toVertex) self._considerLink(fromVertex, projectedVertex) for vertex in self.vertices: self._considerLink(vertex, projectedVertex, False) tempVertices.append(projectedVertex) astar = AStarSearch() result = astar.search(fromVertex, toVertex) if result: if isApproximate: result.pop(-1) return [ vertex.pos for vertex in result ] return finally: for tempVertex in tempVertices: tempVertex.unlinkAll() return
def getMoveIvalFromPath(np, path, speed): from direct.interval.IntervalGlobal import Sequence, Func, LerpPosInterval moveIval = Sequence() for i in range(len(path)): if i == 0: continue waypoint = path[i] lastWP = path[i - 1] moveIval.append(Func(np.headsUp, Point3(*waypoint))) ival = LerpPosInterval(np, pos = Point3(*waypoint), startPos = Point3(*lastWP), fluid = 1, duration = (Point2(waypoint[0], waypoint[1]) - Point2(lastWP[0], lastWP[1])).length() / speed) moveIval.append(ival) return moveIval
def setClickRegionFrame(self, left, right, bottom, top): transform = self.contents.getNetTransform() camTransform = base.cam.getNetTransform().getInverse() transform = camTransform.compose(transform) transform.setQuat(Quat()) mat = transform.getMat() camSpaceTopLeft = mat.xformPoint(Point3(left, 0, top)) camSpaceBottomRight = mat.xformPoint(Point3(right, 0, bottom)) screenSpaceTopLeft = Point2() screenSpaceBottomRight = Point2() base.camLens.project(Point3(camSpaceTopLeft), screenSpaceTopLeft) base.camLens.project(Point3(camSpaceBottomRight), screenSpaceBottomRight) left, top = screenSpaceTopLeft right, bottom = screenSpaceBottomRight self.region.setFrame(left, right, bottom, top)
def addPolygon(self, points): newVertices = [] for i,point in enumerate(points): prevPoint = points[i-1] x, y = point # Add a boundary line from the previous to here: x2, y2 = prevPoint self.borders.append((x2, y2, x, y)) # Create our vertex: vertex = AStarVertex(Point2(x, y)) self.vertices.append(vertex) newVertices.append(vertex) # Now set up the polygonal neighbors on all vertices: for i,vertex in enumerate(newVertices): prevVertex = newVertices[i-1] nextVertex = newVertices[(i+1)%len(newVertices)] vertex.setPolygonalNeighbors(prevVertex, nextVertex) vertex.extrudeVertex(self.VERTEX_EXTRUSION) if vertex.interiorAngle > 180: # This vertex is concave. Nothing is ever going to *walk to* it # in order to go somewhere else, so we can actually exclude it # from the pathfinding system. self.vertices.remove(vertex)
def buildMap(collidableEntities, offset=None, steps=1, delta=1.0): if (offset == None): offset = Point2(0, 0) cmap = [[0 for i in range(map2_x)] for j in range(map2_y)] # set the player pos to be 0 # so we don't get unnecessary infinite loops for entity in collidableEntities: if (isinstance(entity, Chunk)): pos = entity.np.getPos() #print "entity position" + str(pos) tfm = entity.np.getMat() for i in range(entity.bnode.getNumShapes()): stfm = entity.bnode.getShapeMat(i) spos = entity.bnode.getShapePos(i) stfm = tfm * stfm tfp = stfm.xformPoint(spos) tfp -= spos # might be out of range x_index = int(tfp.x - offset.x + map_x) y_index = int(tfp.z - offset.y + map_y) if x_index in range(map2_x) and y_index in range(map2_y): cmap[x_index][y_index] = 1 # set the player pos to be 0 # so we don't get unnecessary infinite loops cmap[map_x][map_y] = 0 return cmap
def pointCoordIn2d(point): coord3d = base.cam.getRelativePoint(render, point) coord2d = Point2() base.camLens.project(coord3d, coord2d) coordInRender2d = Point3(coord2d[0], 0, coord2d[1]) coordInAspect2d = aspect2d.getRelativePoint(render2d, coordInRender2d) return coordInAspect2d
def nodeCoordIn2d(nodePath): coord3d = nodePath.getPos(base.cam) coord2d = Point2() base.camLens.project(coord3d, coord2d) coordInRender2d = Point3(coord2d[0], 0, coord2d[1]) coordInAspect2d = aspect2d.getRelativePoint(render2d, coordInRender2d) return coordInAspect2d
def coordScreenTo3d(self, screenCoord): x, y = screenCoord screenPoint = Point2(x, y) # Do this calculation using simple geometry, rather than the absurd # collision-traversal nonsense we used to use. Thanks to # https://www.panda3d.org/forums/viewtopic.php?t=5409 # for pointing us at the right methods to make this work. # Get two points along the ray extending from the camera, in the # direction of the mouse click. nearPoint = Point3() farPoint = Point3() self.camLens.extrude(screenPoint, nearPoint, farPoint) # These points are relative to the camera, so need to be converted to # be relative to the render. Thanks to the example code (see link # above) for saving us probably some hours of debugging figuring that # one out again :) nearPoint = self.render.getRelativePoint(self.camera, nearPoint) farPoint = self.render.getRelativePoint(self.camera, farPoint) intersection = Point3() if self.groundPlane.intersectsLine(intersection, nearPoint, farPoint): # Convert to a tuple to ensure no one else is keeping a reference # around. x, y, z = intersection return (x, y, z) # The ray didn't intersect the ground. This is almost certainly going # to happen at some point; all you have to do is find a way to aim the # camera (or manipulate the screen coordinate) so that the ray points # horizontally. But we don't have code to handle it, so for now just # abort. thisIsNotHandled()
def project_2d(lens, img_metadata, pos): center = np.array(img_metadata.camera_pos) heading = np.radians(img_metadata.camera_heading_in_degrees) # Translate according to the camera center p_translated = pos - center # Apply the inverse rotation matrix to the vehicle position, same effect as rotating the camera p_rotated = np.array([ p_translated[0] * np.cos(-heading) - p_translated[1] * np.sin(-heading), p_translated[0] * np.sin(-heading) + p_translated[1] * np.cos(-heading), p_translated[2], ]) v_2d_pos_normalized = Point2() v_3d_pos = Point3( p_rotated[0], p_rotated[2], p_rotated[1]) # y and z are flipped for project() in panda3D x = int(HALF_HEIGHT) y = int(HALF_WIDTH) # project() returns true if given 3d point is within the viewing frustum if lens.project(v_3d_pos, v_2d_pos_normalized): # v_2d_pos_normlized ranges (-1, 1) in both directions, with (-1,-1) being the lower-left corner # Sensor image has non-negative pixel positions, with (0, 0) starting from top-left corner # x and y are swapped between sensor image and the image projected from panda3D lens x = int(-v_2d_pos_normalized[1] * HALF_HEIGHT + HALF_HEIGHT) y = int(v_2d_pos_normalized[0] * HALF_WIDTH + HALF_WIDTH) return x, y