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
