def setupRightTexture(self):
cm = CardMaker('quadMaker')
cm.setColor(1.0, 1.0, 1.0, 1.0)
aspect = base.camLens.getAspectRatio()
htmlWidth = 2.0 * aspect * WEB_WIDTH / float(WIN_WIDTH)
htmlHeight = 2.0 * float(WEB_HEIGHT) / float(WIN_HEIGHT)
# the html area will be center aligned and vertically top aligned
#cm.setFrame(-htmlWidth/2.0, htmlWidth/2.0, 1.0 - htmlHeight, 1.0)
cm.setFrame(0, htmlWidth / 2.0, -htmlHeight / 2.0, htmlHeight / 2.0)
card = cm.generate()
self.rightQuad = NodePath(card)
self.rightQuad.reparentTo(self.parent)
self.rightGuiTex = Texture("guiTex")
self.rightGuiTex.setupTexture(Texture.TT2dTexture, WEB_HALF_WIDTH,
WEB_HEIGHT, 1, Texture.TUnsignedByte,
Texture.FRgba)
self.rightGuiTex.setKeepRamImage(True)
self.rightGuiTex.makeRamImage()
self.rightGuiTex.setWrapU(Texture.WMClamp)
self.rightGuiTex.setWrapV(Texture.WMClamp)
ts = TextureStage('rightWebTS')
self.rightQuad.setTexture(ts, self.rightGuiTex)
self.rightQuad.setTexScale(ts, 1.0, -1.0)
self.rightQuad.setTransparency(0)
self.rightQuad.setTwoSided(True)
self.rightQuad.setColor(1.0, 1.0, 1.0, 1.0)
def _createMaskTextureCard(self):
"""
This will return a NodePath with a card textured with the map mask. It
also creates several other members that re needed to change the mask.
"""
# create and fill empty mask image
self._maskImage = PNMImage(self._maskResolution, self._maskResolution,
4)
for x in range(self._maskResolution):
for y in range(self._maskResolution):
#maskImage.setXel(x,y,mapImage.getRed(x/13,y/10),mapImage.getGreen(x/13,y/10),mapImage.getBlue(x/13,y/10))
self._maskImage.setXelA(x, y, 0, 0, 0, 1)
# create the texture for the mask
self.maskTexture = Texture("maskTexture")
self.maskTexture.setupTexture(Texture.TT2dTexture,
self._maskResolution,
self._maskResolution, 1,
Texture.TUnsignedByte, Texture.FRgba)
self.maskTexture.setMinfilter(Texture.FTLinear)
self.maskTexture.setWrapU(Texture.WMClamp)
self.maskTexture.setWrapV(Texture.WMClamp)
self.maskTexture.load(self._maskImage)
base.graphicsEngine.renderFrame()
# put the mask texture on a card and return it
cm = CardMaker("mask_cardMaker")
cm.setFrame(-1.0, 1.0, -1.0, 1.0)
mask = self.attachNewNode(cm.generate())
mask.setTexture(self.maskTexture, 1)
mask.setTransparency(1)
return mask
def update(self, task):
global GlobalWebcore
if base.mouseWatcherNode.hasMouse():
x, y = self._translateRelativeCoordinates(
base.mouseWatcherNode.getMouseX(),
base.mouseWatcherNode.getMouseY())
#self.notify.debug('got mouse move %d %d' % (x,y))
#self.webView.injectMouseMove(x, y)
if (self.mx - x) != 0 or (self.my - y) != 0:
self.webView.injectMouseMove(x, y)
#self.notify.debug('injecting mouse move %d %d' % (x,y))
self.mx, self.my = x, y
if self.webView.isDirty():
#self.notify.debug("webview is dirty")
self.webView.render(self.imgBuffer.buffer_info()[0],
WEB_WIDTH * 4, 4)
#Texture.setTexturesPower2(AutoTextureScale.ATSUp)
Texture.setTexturesPower2(2)
#self.notify.debug("about to modify ram image")
textureBuffer = self.guiTex.modifyRamImage()
#import pdb; pdb.set_trace()
#self.notify.debug("about to call textureBuffer.setData")
textureBuffer.setData(self.imgBuffer.tostring())
#self.notify.debug("done calling setData")
if self.useHalfTexture:
# TODO check with DRose, this feels inefficient
self.guiTex.store(self.fullPnmImage)
self.leftPnmImage.copySubImage(self.fullPnmImage, 0, 0, 0,
0, WEB_HALF_WIDTH,
WEB_HEIGHT)
self.rightPnmImage.copySubImage(self.fullPnmImage, 0, 0,
WEB_HALF_WIDTH, 0,
WEB_HALF_WIDTH, WEB_HEIGHT)
self.leftGuiTex.load(self.leftPnmImage)
self.rightGuiTex.load(self.rightPnmImage)
self.quad.hide()
#Texture.setTexturesPower2(AutoTextureScale.ATSDown)
Texture.setTexturesPower2(1)
GlobalWebcore.update()
return Task.cont
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)
# the html area will be center aligned and vertically top aligned
#cm.setFrame(-htmlWidth/2.0, htmlWidth/2.0, 1.0 - htmlHeight, 1.0)
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,0), Point2(bottomRightX, bottomRightY))
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.quad.setZ(0.1) # shtickerbook is moved up by 0.1
self.calcMouseLimits()
class MazeMapGui(DirectFrame):
notify = directNotify.newCategory("MazeMapGui")
def __init__(self, mazeLayout, maskResolution=None, radiusRatio=None):
"""
Constructor for a MazeMap. the mazeLayout parameter is a 2d array of
bools (or ints... maybe more depth will be added with that).
maskResolution is a value for the resolution of the mask covering the
map. It should range from 32 to 256. radiusRatio is essentially
the percentage of the map that is revealed with each step.
"""
DirectFrame.__init__(
self,
relief=None,
state=DGG.NORMAL,
sortOrder=DGG.BACKGROUND_SORT_INDEX,
)
# store / set parameters
self._mazeLayout = mazeLayout
self._maskResolution = maskResolution or DEFAULT_MASK_RESOLUTION
if radiusRatio is None:
self._radius = self._maskResolution * DEFAULT_RADIUS_RATIO
else:
self._radius = self._maskResolution * radiusRatio
# store false for all maze cells to represent that none of them have
# been revealed yet. This can prevent the expensive call to altering
# the mask if a cell is already revealed
self._revealedCells = []
for y in range(len(self._mazeLayout)):
self._revealedCells.append([])
for x in range(len(self._mazeLayout[0])):
self._revealedCells[y].append(False)
# create reveal function mappings
self._revealFunctions = {
MazeRevealType.SmoothCircle: self._revealSmoothCircle,
MazeRevealType.HardCircle: self._revealHardCircle,
MazeRevealType.Square: self._revealSquare,
}
self._revealFunction = MAZE_REVEAL_TYPE
# create the map and the mask
self.map = self._createMapTextureCard()
self.map.reparentTo(self)
self.maskedLayer = self.attachNewNode("maskedLayer")
self.mask = self._createMaskTextureCard()
self.mask.reparentTo(self)
self.visibleLayer = self.attachNewNode("visibleLayer")
#TODO:maze: handle locks and doors
self._players = []
self._locks = []
self._doors = []
#--- Initialization, Destruction, and Resetting ---#########################
def _createMapTextureCard(self):
"""
This will return a NodePath with a card textured with the minimap. The
minimap texture is dynamically created from the map data.
"""
# create and fill empty map image
mapImage = PNMImage(MAP_RESOLUTION, MAP_RESOLUTION)
blockFiles = []
for i in range(5):
blockFiles.append(PNMImage())
#blockFiles[i].read(Filename("mapBlock%i.png"%(i+1)))
# TODO:maze either reference a set of textures for each piece or fill with color
blockFiles[i].read(Filename('phase_4/maps/male_sleeve4New.png'))
mapImage.fill(0.8, 0.8, 0.8)
# iterate through the map data and place a block in the map image where appropriate
for x in range(len(self._mazeLayout[0])):
for y in range(len(self._mazeLayout)):
if self._mazeLayout[y][x]:
ax = float(x) / len(self._mazeLayout[0]) * MAP_RESOLUTION
ay = float(y) / len(self._mazeLayout) * MAP_RESOLUTION
#TODO:maze use different blocks for different wall types or items
#mapImage.copySubImage(random.choice(blockFiles), int(ax), int(ay), 20, 20, 32, 32)
#TODO:maze find the ideal block texture size for the map so we dont
# have to do this strange offset
#mapImage.copySubImage(blockFiles[0], int(ax), int(ay), 0, 0, 32, 32)
self._drawSquare(mapImage, int(ax), int(ay), 10,
VBase4D(0.5, 0.5, 0.5, 1.0))
# create a texture from the map image
mapTexture = Texture("mapTexture")
mapTexture.setupTexture(Texture.TT2dTexture, self._maskResolution,
self._maskResolution, 1, Texture.TUnsignedByte,
Texture.FRgba)
mapTexture.setMinfilter(Texture.FTLinear)
mapTexture.load(mapImage)
mapTexture.setWrapU(Texture.WMClamp)
mapTexture.setWrapV(Texture.WMClamp)
mapImage.clear()
del mapImage
# put the texture on a card and return it
cm = CardMaker("map_cardMaker")
cm.setFrame(-1.0, 1.0, -1.0, 1.0)
map = self.attachNewNode(cm.generate())
map.setTexture(mapTexture, 1)
return map
def _createMaskTextureCard(self):
"""
This will return a NodePath with a card textured with the map mask. It
also creates several other members that re needed to change the mask.
"""
# create and fill empty mask image
self._maskImage = PNMImage(self._maskResolution, self._maskResolution,
4)
for x in range(self._maskResolution):
for y in range(self._maskResolution):
#maskImage.setXel(x,y,mapImage.getRed(x/13,y/10),mapImage.getGreen(x/13,y/10),mapImage.getBlue(x/13,y/10))
self._maskImage.setXelA(x, y, 0, 0, 0, 1)
# create the texture for the mask
self.maskTexture = Texture("maskTexture")
self.maskTexture.setupTexture(Texture.TT2dTexture,
self._maskResolution,
self._maskResolution, 1,
Texture.TUnsignedByte, Texture.FRgba)
self.maskTexture.setMinfilter(Texture.FTLinear)
self.maskTexture.setWrapU(Texture.WMClamp)
self.maskTexture.setWrapV(Texture.WMClamp)
self.maskTexture.load(self._maskImage)
base.graphicsEngine.renderFrame()
# put the mask texture on a card and return it
cm = CardMaker("mask_cardMaker")
cm.setFrame(-1.0, 1.0, -1.0, 1.0)
mask = self.attachNewNode(cm.generate())
mask.setTexture(self.maskTexture, 1)
mask.setTransparency(1)
return mask
def _drawSquare(self, image, ulx, uly, size, color):
"""
Draws a square on the supplied PNMImage starting at (ulx, uly) with a
size of "size" and a color of "color".
"""
x = int(ulx)
while x <= ulx + size:
y = int(uly)
while y <= uly + size:
if x > 0 and y > 0 and x < image.getXSize(
) and y < image.getYSize():
image.setXelA(x, y, color)
y += 1
x += 1
def destroy(self):
del self._mazeLayout
del self._maskResolution
del self._radius
del self._revealedCells
del self._revealFunctions
del self._revealFunction
# remove and delete all nodes
self.map.removeNode()
del self.map
self.mask.removeNode()
del self.mask
self.maskedLayer.removeNode()
del self.maskedLayer
self.visibleLayer.removeNode()
del self.visibleLayer
# remove and delete all lists of nodes
for p in self._players:
p.removeNode()
del self._players
for k in self._locks:
k.removeNode()
del self._locks
for d in self._doors:
d.removeNode()
del self._doors
self._maskImage.clear()
del self._maskImage
self.maskTexture.clear()
del self.maskTexture
DirectFrame.destroy(self)
#--- Reveal shape functions ---#############################################
def _revealSmoothCircle(self, x, y, center):
length = (Vec2(x, y) - center).length()
goalAlpha = max(0.0, (length / float(self._radius)) - 0.5)
self._maskImage.setXelA(
x, y,
VBase4D(0.0, 0.0, 0.0,
min(self._maskImage.getAlpha(x, y), goalAlpha * 2.0)))
def _revealHardCircle(self, x, y, center):
length = (Vec2(x, y) - center).length()
if length <= self._radius:
self._maskImage.setXelA(x, y, VBase4D(0, 0, 0, 0))
def _revealSquare(self, x, y, center):
self._maskImage.setXelA(x, y, VBase4D(0, 0, 0, 0))
#--- Private Functions ---##################################################
def _drawHole(self, x, y):
center = Vec2(x, y)
ul = center - Vec2(self._radius, self._radius)
lr = center + Vec2(self._radius, self._radius)
x = int(ul[0])
while x <= lr[0]:
y = int(ul[1])
while y <= lr[1]:
if x > 0 and y > 0 and x < self._maskResolution and y < self._maskResolution:
self._revealFunctions[self._revealFunction](x, y, center)
y += 1
x += 1
self.maskTexture.load(self._maskImage)
self.mask.setTexture(self.maskTexture, 1)
def _tileToActualPosition(self, x, y):
y = len(self._mazeLayout) - y
cellWidth = self._maskResolution / len(self._mazeLayout[0])
cellHeight = self._maskResolution / len(self._mazeLayout)
ax = float(x) / len(self._mazeLayout[0]) * self._maskResolution
ax += cellWidth
ay = float(y) / len(self._mazeLayout) * self._maskResolution
ay += cellHeight
return ax, ay
#--- Member Functions ---###################################################
def addDoor(self, x, y, color):
"""
Adds a door to the minimap. This will add a colored dot to the map
that represents a door.
--- This is subject to change pending a new player-lock data system. ---
"""
assert self.notify.debugCall()
x, y = self._tileToActualPosition(x, y)
# TODO:maze: replace with door model / texture
cm = CardMaker("door_cardMaker")
cm.setFrame(-0.04, 0.04, -0.04, 0.04)
#door = self.visibleLayer.attachNewNode(cm.generate())
door = self.maskedLayer.attachNewNode(cm.generate())
door.setColor(color)
door.setPos(x / self._maskResolution * 2.0 - 0.97, 0,
y / self._maskResolution * -2.0 + 1.02)
self._doors.append(door)
def addLock(self, x, y, color):
"""
Adds a lock to the minimap. This will add a colored dot to the map
that represents a lock.
--- This is subject to change pending a new player-lock data system. ---
"""
assert self.notify.debugCall()
x, y = self._tileToActualPosition(x, y)
# TODO:maze: replace with lock model / texture
cm = CardMaker("lock_cardMaker")
cm.setFrame(-0.04, 0.04, -0.04, 0.04)
lock = self.maskedLayer.attachNewNode(cm.generate())
lock.setColor(color)
lock.setPos(x / self._maskResolution * 2.0 - 0.97, 0,
y / self._maskResolution * -2.0 + 1.02)
self._locks.append(lock)
def addPlayer(self, x, y, color):
"""
Adds a player to the minimap. This will add a colored dot to the map
that represents the player. The dot location can then be updated
using the revealCell call.
--- This is subject to change pending a new player-lock data system. ---
"""
assert self.notify.debugCall()
x, y = self._tileToActualPosition(x, y)
# TODO:maze: replace with player model / texture
cm = CardMaker("player_cardMaker")
cm.setFrame(-0.04, 0.04, -0.04, 0.04)
player = self.visibleLayer.attachNewNode(cm.generate())
player.setColor(color)
player.setPos(x / self._maskResolution * 2.0 - 0.97, 0,
y / self._maskResolution * -2.0 + 1.02)
self._players.append(player)
def revealCell(self, x, y, playerIndex=None):
"""
Clears out the mask around the given cell and stores that the cell has
been revealed to prevent attempting to edit the mask for the cell again.
"""
ax, ay = self._tileToActualPosition(x, y)
if not self._revealedCells[y][x]:
self._drawHole(ax, ay)
self._revealedCells[y][x] = True
if playerIndex is not None:
assert (playerIndex < len(self._players))
self._players[playerIndex].setPos(
ax / self._maskResolution * 2.0 - 0.97, 0,
ay / self._maskResolution * -2.0 + 1.02)
def revealAll(self):
""" Clears out all of the mask. """
for x in range(self._maskResolution):
for y in range(self._maskResolution):
self._maskImage.setXelA(x, y, 0, 0, 0, 0)
def reset(self):
""" Turns all of the mask on, covering the entire map. """
for x in range(self._maskResolution):
for y in range(self._maskResolution):
self._maskImage.setXelA(x, y, 0, 0, 0, 1)
def _createMapTextureCard(self):
"""
This will return a NodePath with a card textured with the minimap. The
minimap texture is dynamically created from the map data.
"""
# create and fill empty map image
mapImage = PNMImage(MAP_RESOLUTION, MAP_RESOLUTION)
blockFiles = []
for i in range(5):
blockFiles.append(PNMImage())
#blockFiles[i].read(Filename("mapBlock%i.png"%(i+1)))
# TODO:maze either reference a set of textures for each piece or fill with color
blockFiles[i].read(Filename('phase_4/maps/male_sleeve4New.png'))
mapImage.fill(0.8, 0.8, 0.8)
# iterate through the map data and place a block in the map image where appropriate
for x in range(len(self._mazeLayout[0])):
for y in range(len(self._mazeLayout)):
if self._mazeLayout[y][x]:
ax = float(x) / len(self._mazeLayout[0]) * MAP_RESOLUTION
ay = float(y) / len(self._mazeLayout) * MAP_RESOLUTION
#TODO:maze use different blocks for different wall types or items
#mapImage.copySubImage(random.choice(blockFiles), int(ax), int(ay), 20, 20, 32, 32)
#TODO:maze find the ideal block texture size for the map so we dont
# have to do this strange offset
#mapImage.copySubImage(blockFiles[0], int(ax), int(ay), 0, 0, 32, 32)
self._drawSquare(mapImage, int(ax), int(ay), 10,
VBase4D(0.5, 0.5, 0.5, 1.0))
# create a texture from the map image
mapTexture = Texture("mapTexture")
mapTexture.setupTexture(Texture.TT2dTexture, self._maskResolution,
self._maskResolution, 1, Texture.TUnsignedByte,
Texture.FRgba)
mapTexture.setMinfilter(Texture.FTLinear)
mapTexture.load(mapImage)
mapTexture.setWrapU(Texture.WMClamp)
mapTexture.setWrapV(Texture.WMClamp)
mapImage.clear()
del mapImage
# put the texture on a card and return it
cm = CardMaker("map_cardMaker")
cm.setFrame(-1.0, 1.0, -1.0, 1.0)
map = self.attachNewNode(cm.generate())
map.setTexture(mapTexture, 1)
return map
class HtmlView(DirectObject):
notify = DirectNotifyGlobal.directNotify.newCategory("HtmlView")
useHalfTexture = base.config.GetBool("news-half-texture", 0)
def __init__(self, parent=aspect2d):
"""Properly initialize ourself."""
#AwWebViewListener.AwWebViewListener.__init__(self)
self.parent = parent
self.mx = 0
self.my = 0
self.htmlFile = "index.html"
self.transparency = False # this is important looks weird if it's true
global GlobalWebcore
if GlobalWebcore:
# we get a C++ crash if we construct webcore a second time
pass
else:
GlobalWebcore = AwWebCore(AwWebCore.LOGVERBOSE, True,
AwWebCore.PFBGRA)
GlobalWebcore.setBaseDirectory('.')
for errResponse in range(400, 600):
GlobalWebcore.setCustomResponsePage(errResponse, "error.html")
self.webView = GlobalWebcore.createWebView(WEB_WIDTH, WEB_HEIGHT,
self.transparency, False,
70)
#self.webView.setListener(self)
#self.webView.setCallback("requestFPS");
frameName = ''
inGameNewsUrl = self.getInGameNewsUrl()
#self.webView.loadURL2(inGameNewsUrl)
self.imgBuffer = array.array('B')
for i in range(WEB_WIDTH * WEB_HEIGHT):
self.imgBuffer.append(0)
self.imgBuffer.append(0)
self.imgBuffer.append(0)
self.imgBuffer.append(255)
if self.useHalfTexture:
self.leftBuffer = array.array('B')
for i in range(WEB_HALF_WIDTH * WEB_HEIGHT):
self.leftBuffer.append(0)
self.leftBuffer.append(0)
self.leftBuffer.append(0)
self.leftBuffer.append(255)
self.rightBuffer = array.array('B')
for i in range(WEB_HALF_WIDTH * WEB_HEIGHT):
self.rightBuffer.append(0)
self.rightBuffer.append(0)
self.rightBuffer.append(0)
self.rightBuffer.append(255)
self.setupTexture()
if self.useHalfTexture:
self.setupHalfTextures()
#self.interval = LerpHprInterval(self.quad, 2, Vec3(360, 0, 0), Vec3(0, 0, 0))
#self.accept("escape", sys.exit, [0])
#self.accept("w", self.writeTex)
self.accept("mouse1", self.mouseDown, [AwWebView.LEFTMOUSEBTN])
self.accept("mouse3", self.mouseDown, [AwWebView.RIGHTMOUSEBTN])
self.accept("mouse1-up", self.mouseUp, [AwWebView.LEFTMOUSEBTN])
self.accept("mouse3-up", self.mouseUp, [AwWebView.RIGHTMOUSEBTN])
#self.accept("f1", self.toggleRotation)
#self.accept("f2", self.toggleTransparency)
#self.accept("f3", self.reload)
#self.accept("f4", self.zoomIn)
#self.accept("f5", self.zoomOut)
#taskMgr.doMethodLater(1.0, self.update, 'HtmlViewUpdateTask')
# we get a problem if a mid-frame hearbeat fires of this task in conjunction with igLoop
#taskMgr.add(self.update, 'HtmlViewUpdateTask', priority = 51)
#taskMgr.add(self.update, 'HtmlViewUpdateTask')
#base.newsFrame = self
def getInGameNewsUrl(self):
"""Get the appropriate URL to use if we are in test, qa, or live."""
# First if all else fails, we hard code the live news url
result = base.config.GetString(
"fallback-news-url",
"http://cdn.toontown.disney.go.com/toontown/en/gamenews/")
# next check if we have an override, say they want to url to point to a file in their harddisk
override = base.config.GetString("in-game-news-url", "")
if override:
self.notify.info(
"got an override url, using %s for in a game news" % override)
result = override
else:
try:
launcherUrl = base.launcher.getValue("GAME_IN_GAME_NEWS_URL",
"")
if launcherUrl:
result = launcherUrl
self.notify.info(
"got GAME_IN_GAME_NEWS_URL from launcher using %s" %
result)
else:
self.notify.info(
"blank GAME_IN_GAME_NEWS_URL from launcher, using %s" %
result)
except:
self.notify.warning(
"got exception getting GAME_IN_GAME_NEWS_URL from launcher, using %s"
% result)
return result
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)
# the html area will be center aligned and vertically top aligned
#cm.setFrame(-htmlWidth/2.0, htmlWidth/2.0, 1.0 - htmlHeight, 1.0)
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,0), Point2(bottomRightX, bottomRightY))
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.quad.setZ(0.1) # shtickerbook is moved up by 0.1
self.calcMouseLimits()
def setupHalfTextures(self):
self.setupLeftTexture()
self.setupRightTexture()
self.fullPnmImage = PNMImage(WEB_WIDTH, WEB_HEIGHT, 4)
self.leftPnmImage = PNMImage(WEB_HALF_WIDTH, WEB_HEIGHT, 4)
self.rightPnmImage = PNMImage(WEB_HALF_WIDTH, WEB_HEIGHT, 4)
def setupLeftTexture(self):
cm = CardMaker('quadMaker')
cm.setColor(1.0, 1.0, 1.0, 1.0)
aspect = base.camLens.getAspectRatio()
htmlWidth = 2.0 * aspect * WEB_WIDTH / float(WIN_WIDTH)
htmlHeight = 2.0 * float(WEB_HEIGHT) / float(WIN_HEIGHT)
# the html area will be center aligned and vertically top aligned
#cm.setFrame(-htmlWidth/2.0, htmlWidth/2.0, 1.0 - htmlHeight, 1.0)
cm.setFrame(-htmlWidth / 2.0, 0, -htmlHeight / 2.0, htmlHeight / 2.0)
card = cm.generate()
self.leftQuad = NodePath(card)
self.leftQuad.reparentTo(self.parent)
self.leftGuiTex = Texture("guiTex")
self.leftGuiTex.setupTexture(Texture.TT2dTexture, WEB_HALF_WIDTH,
WEB_HEIGHT, 1, Texture.TUnsignedByte,
Texture.FRgba)
self.leftGuiTex.setKeepRamImage(True)
self.leftGuiTex.makeRamImage()
self.leftGuiTex.setWrapU(Texture.WMClamp)
self.leftGuiTex.setWrapV(Texture.WMClamp)
ts = TextureStage('leftWebTS')
self.leftQuad.setTexture(ts, self.leftGuiTex)
self.leftQuad.setTexScale(ts, 1.0, -1.0)
self.leftQuad.setTransparency(0)
self.leftQuad.setTwoSided(True)
self.leftQuad.setColor(1.0, 1.0, 1.0, 1.0)
#self.quad.setZ(0.1) # shtickerbook is moved up by 0.1
def setupRightTexture(self):
cm = CardMaker('quadMaker')
cm.setColor(1.0, 1.0, 1.0, 1.0)
aspect = base.camLens.getAspectRatio()
htmlWidth = 2.0 * aspect * WEB_WIDTH / float(WIN_WIDTH)
htmlHeight = 2.0 * float(WEB_HEIGHT) / float(WIN_HEIGHT)
# the html area will be center aligned and vertically top aligned
#cm.setFrame(-htmlWidth/2.0, htmlWidth/2.0, 1.0 - htmlHeight, 1.0)
cm.setFrame(0, htmlWidth / 2.0, -htmlHeight / 2.0, htmlHeight / 2.0)
card = cm.generate()
self.rightQuad = NodePath(card)
self.rightQuad.reparentTo(self.parent)
self.rightGuiTex = Texture("guiTex")
self.rightGuiTex.setupTexture(Texture.TT2dTexture, WEB_HALF_WIDTH,
WEB_HEIGHT, 1, Texture.TUnsignedByte,
Texture.FRgba)
self.rightGuiTex.setKeepRamImage(True)
self.rightGuiTex.makeRamImage()
self.rightGuiTex.setWrapU(Texture.WMClamp)
self.rightGuiTex.setWrapV(Texture.WMClamp)
ts = TextureStage('rightWebTS')
self.rightQuad.setTexture(ts, self.rightGuiTex)
self.rightQuad.setTexScale(ts, 1.0, -1.0)
self.rightQuad.setTransparency(0)
self.rightQuad.setTwoSided(True)
self.rightQuad.setColor(1.0, 1.0, 1.0, 1.0)
#self.quad.setZ(0.1) # shtickerbook is moved up by 0.1
def calcMouseLimits(self):
ll = Point3()
ur = Point3()
self.quad.calcTightBounds(ll, ur)
self.notify.debug("ll=%s ur=%s" % (ll, ur))
# we need to get our relative position to aspect2d, since shtiker books is shifted
offset = self.quad.getPos(aspect2d)
self.notify.debug("offset = %s " % offset)
ll.setZ(ll.getZ() + offset.getZ())
ur.setZ(ur.getZ() + offset.getZ())
self.notify.debug("new LL=%s, UR=%s" % (ll, ur))
relPointll = self.quad.getRelativePoint(aspect2d, ll)
self.notify.debug("relPoint = %s" % relPointll)
self.mouseLL = (aspect2d.getScale()[0] * ll[0],
aspect2d.getScale()[2] * ll[2])
self.mouseUR = (aspect2d.getScale()[0] * ur[0],
aspect2d.getScale()[2] * ur[2])
self.notify.debug("original mouseLL=%s, mouseUR=%s" %
(self.mouseLL, self.mouseUR))
def writeTex(self, filename="guiText.png"):
self.notify.debug("writing texture")
self.guiTex.generateRamMipmapImages()
self.guiTex.write(filename)
def toggleRotation(self):
if self.interval.isPlaying():
self.interval.finish()
else:
self.interval.loop()
def mouseDown(self, button):
messenger.send('wakeup')
self.webView.injectMouseDown(button)
def mouseUp(self, button):
self.webView.injectMouseUp(button)
def reload(self):
pass
#self.webView.loadFile(self.htmlFile, '')
def zoomIn(self):
self.webView.zoomIn()
def zoomOut(self):
self.webView.zoomOut()
def toggleTransparency(self):
self.transparency = not self.transparency
self.webView.setTransparent(self.transparency)
def update(self, task):
global GlobalWebcore
if base.mouseWatcherNode.hasMouse():
x, y = self._translateRelativeCoordinates(
base.mouseWatcherNode.getMouseX(),
base.mouseWatcherNode.getMouseY())
#self.notify.debug('got mouse move %d %d' % (x,y))
#self.webView.injectMouseMove(x, y)
if (self.mx - x) != 0 or (self.my - y) != 0:
self.webView.injectMouseMove(x, y)
#self.notify.debug('injecting mouse move %d %d' % (x,y))
self.mx, self.my = x, y
if self.webView.isDirty():
#self.notify.debug("webview is dirty")
self.webView.render(self.imgBuffer.buffer_info()[0],
WEB_WIDTH * 4, 4)
#Texture.setTexturesPower2(AutoTextureScale.ATSUp)
Texture.setTexturesPower2(2)
#self.notify.debug("about to modify ram image")
textureBuffer = self.guiTex.modifyRamImage()
#import pdb; pdb.set_trace()
#self.notify.debug("about to call textureBuffer.setData")
textureBuffer.setData(self.imgBuffer.tostring())
#self.notify.debug("done calling setData")
if self.useHalfTexture:
# TODO check with DRose, this feels inefficient
self.guiTex.store(self.fullPnmImage)
self.leftPnmImage.copySubImage(self.fullPnmImage, 0, 0, 0,
0, WEB_HALF_WIDTH,
WEB_HEIGHT)
self.rightPnmImage.copySubImage(self.fullPnmImage, 0, 0,
WEB_HALF_WIDTH, 0,
WEB_HALF_WIDTH, WEB_HEIGHT)
self.leftGuiTex.load(self.leftPnmImage)
self.rightGuiTex.load(self.rightPnmImage)
self.quad.hide()
#Texture.setTexturesPower2(AutoTextureScale.ATSDown)
Texture.setTexturesPower2(1)
GlobalWebcore.update()
return Task.cont
def _translateRelativeCoordinates(self, x, y):
sx = int((x - self.mouseLL[0]) / (self.mouseUR[0] - self.mouseLL[0]) *
WEB_WIDTH_PIXELS)
sy = WEB_HEIGHT_PIXELS - int(
(y - self.mouseLL[1]) /
(self.mouseUR[1] - self.mouseLL[1]) * WEB_HEIGHT_PIXELS)
return sx, sy
def unload(self):
"""Clean up everything, especially the awesomium bits."""
self.ignoreAll()
self.webView.destroy()
self.webView = None
#global GlobalWebcore
#GlobalWebcore = None
pass
# --------------------[ WebViewListener implementation ]--------------------------
def onCallback(self, name, args):
assert self.notify.debugStateCall(self)
if name == "requestFPS":
#self.webView.setProperty( "fps", JSValue("%.1f" % (1.0 / globalClock.getDt())) )
#self.webView.executeJavascript("updateFPS()", "")
pass
def onBeginNavigation(self, url, frameName):
assert self.notify.debugStateCall(self)
pass
def onBeginLoading(self, url, frameName, statusCode, mimeType):
assert self.notify.debugStateCall(self)
pass
def onFinishLoading(self):
assert self.notify.debugStateCall(self)
self.notify.debug("finished loading")
pass
def onReceiveTitle(self, title, frameName):
assert self.notify.debugStateCall(self)
pass
def onChangeTooltip(self, tooltip):
assert self.notify.debugStateCall(self)
pass
def onChangeCursor(self, cursor):
assert self.notify.debugStateCall(self)
pass
def onChangeKeyboardFocus(self, isFocused):
assert self.notify.debugStateCall(self)
pass
def onChangeTargetURL(self, url):
assert self.notify.debugStateCall(self)
pass
def loadFlatQuad(self, fullFilename):
"""Load the flat jpg into a quad."""
assert self.notify.debugStateCall(self)
#Texture.setTexturesPower2(AutoTextureScale.ATSUp)
#Texture.setTexturesPower2(2)
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)
# the html area will be center aligned and vertically top aligned
#cm.setFrame(-htmlWidth/2.0, htmlWidth/2.0, 1.0 - htmlHeight, 1.0)
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,0), Point2(bottomRightX, bottomRightY))
cm.setUvRange(Point2(0, 1 - bottomRightY), Point2(bottomRightX, 1))
card = cm.generate()
quad = NodePath(card)
#quad.reparentTo(self.parent)
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.setKeepRamImage(True)
#guiTex.makeRamImage()
guiTex.setWrapU(Texture.WMClamp)
guiTex.setWrapV(Texture.WMClamp)
ts = TextureStage('webTS')
quad.setTexture(ts, guiTex)
#quad.setTexScale(ts, 1.0, -1.0)
quad.setTransparency(0)
quad.setTwoSided(True)
quad.setColor(1.0, 1.0, 1.0, 1.0)
result = quad
else:
# if we have an error loading the file, return None to signify an error
result = None
#Texture.setTexturesPower2(AutoTextureScale.ATSDown)
Texture.setTexturesPower2(1)
return result