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 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 generate(self):
'''(Re)generate the entire terrain erasing any current changes'''
factor = self.blockSize*self.chunkSize
#print "Factor:", factor
for terrain in self.terrains:
terrain.getRoot().removeNode()
self.terrains = []
# Breaking master heightmap into subimages
heightmaps = []
self.xchunks = (self.heightfield.getXSize()-1)/factor
self.ychunks = (self.heightfield.getYSize()-1)/factor
#print "X,Y chunks:", self.xchunks, self.ychunks
n = 0
for y in range(0, self.ychunks):
for x in range(0, self.xchunks):
heightmap = PNMImage(factor+1, factor+1)
heightmap.copySubImage(self.heightfield, 0, 0, xfrom = x*factor, yfrom = y*factor)
heightmaps.append(heightmap)
n += 1
# Generate GeoMipTerrains
n = 0
y = self.ychunks-1
x = 0
for heightmap in heightmaps:
terrain = GeoMipTerrain(str(n))
terrain.setHeightfield(heightmap)
terrain.setBruteforce(self.bruteForce)
terrain.setBlockSize(self.blockSize)
terrain.generate()
self.terrains.append(terrain)
root = terrain.getRoot()
root.reparentTo(self.root)
root.setPos(n%self.xchunks*factor, (y)*factor, 0)
# In order to texture span properly we need to reiterate through every vertex
# and redefine the uv coordinates based on our size, not the subGeoMipTerrain's
root = terrain.getRoot()
children = root.getChildren()
for child in children:
geomNode = child.node()
for i in range(geomNode.getNumGeoms()):
geom = geomNode.modifyGeom(i)
vdata = geom.modifyVertexData()
texcoord = GeomVertexWriter(vdata, 'texcoord')
vertex = GeomVertexReader(vdata, 'vertex')
while not vertex.isAtEnd():
v = vertex.getData3f()
t = texcoord.setData2f((v[0]+ self.blockSize/2 + self.blockSize*x)/(self.xsize - 1),
(v[1] + self.blockSize/2 + self.blockSize*y)/(self.ysize - 1))
x += 1
if x >= self.xchunks:
x = 0
y -= 1
n += 1
def makeSlopeImage(self):
'''Returns a greyscale PNMImage containing the slope angles.
This is composited from the assorted GeoMipTerrains.'''
slopeImage = PNMImage(self.heightfield.getXSize(), self.heightfield.getYSize())
factor = self.blockSize*self.chunkSize
n = 0
for y in range(0, self.ychunks):
for x in range(0, self.xchunks):
slopei = self.terrains[n].makeSlopeImage()
#slopeImage.copySubImage(slopei, x*factor, y*factor, 0, 0)
slopeImage.copySubImage(slopei, x*factor, y*factor)
n += 1
return slopeImage
def loadSpriteImages(self,file_path,cols,rows,flipx = False,flipy = False):
"""
Loads an image file containing individual animation frames and returns then in a list of PNMImages
inputs:
- file_path
- cols
- rows
- flipx
- flipy
Output:
- tuple ( bool , list[PNMImage] )
"""
# Make a filepath
image_file = Filename(file_path)
if image_file .empty():
raise IOError("File not found")
return (False, [])
# Instead of loading it outright, check with the PNMImageHeader if we can open
# the file.
img_head = PNMImageHeader()
if not img_head.readHeader(image_file ):
raise IOError("PNMImageHeader could not read file %s. Try using absolute filepaths"%(file_path))
return (False, [])
# Load the image with a PNMImage
full_image = PNMImage(img_head.getXSize(),img_head.getYSize())
full_image.alphaFill(0)
full_image.read(image_file)
if flipx or flipy:
full_image.flip(flipx,flipy,False)
w = int(full_image.getXSize()/cols)
h = int(full_image.getYSize()/rows)
images = []
counter = 0
for i in range(0,cols):
for j in range(0,rows):
sub_img = PNMImage(w,h)
sub_img.addAlpha()
sub_img.alphaFill(0)
sub_img.fill(1,1,1)
sub_img.copySubImage(full_image ,0 ,0 ,i*w ,j*h ,w ,h)
images.append(sub_img)
return (True, images)
def makeSlopeImage(self):
'''Returns a greyscale PNMImage containing the slope angles.
This is composited from the assorted GeoMipTerrains.'''
slopeImage = PNMImage(self.heightfield.getXSize(),
self.heightfield.getYSize())
factor = self.blockSize * self.chunkSize
n = 0
for y in range(0, self.ychunks):
for x in range(0, self.xchunks):
slopei = self.terrains[n].makeSlopeImage()
#slopeImage.copySubImage(slopei, x*factor, y*factor, 0, 0)
slopeImage.copySubImage(slopei, x * factor, y * factor)
n += 1
return slopeImage
def createSequenceNode(self,name,img,cols,rows,scale_x,scale_y,frame_rate):
seq = SequenceNode(name)
w = int(img.getXSize()/cols)
h = int(img.getYSize()/rows)
counter = 0
for i in range(0,cols):
for j in range(0,rows):
sub_img = PNMImage(w,h)
sub_img.addAlpha()
sub_img.alphaFill(0)
sub_img.fill(1,1,1)
sub_img.copySubImage(img ,0 ,0 ,i*w ,j*h ,w ,h)
# Load the image onto the texture
texture = Texture()
texture.setXSize(w)
texture.setYSize(h)
texture.setZSize(1)
texture.load(sub_img)
texture.setWrapU(Texture.WM_border_color) # gets rid of odd black edges around image
texture.setWrapV(Texture.WM_border_color)
texture.setBorderColor(LColor(0,0,0,0))
cm = CardMaker(name + '_' + str(counter))
cm.setFrame(-0.5*scale_x,0.5*scale_x,-0.5*scale_y,0.5*scale_y)
card = NodePath(cm.generate())
seq.addChild(card.node(),counter)
card.setTexture(texture)
sub_img.clear()
counter+=1
seq.setFrameRate(frame_rate)
print "Sequence Node %s contains %i frames of size %s"%(name,seq.getNumFrames(),str((w,h)))
return seq
class Typist(object):
TARGETS = {
'paper': {
'model': 'paper',
'textureRoot': 'Front',
'scale': Point3(0.85, 0.85, 1),
'hpr': Point3(0, 0, 0),
}
}
def __init__(self, base, typewriterNP, underDeskClip, sounds):
self.base = base
self.sounds = sounds
self.underDeskClip = underDeskClip
self.typeIndex = 0
self.typewriterNP = typewriterNP
self.rollerAssemblyNP = typewriterNP.find("**/roller assembly")
assert self.rollerAssemblyNP
self.rollerNP = typewriterNP.find("**/roller")
assert self.rollerNP
self.carriageNP = typewriterNP.find("**/carriage")
assert self.carriageNP
self.baseCarriagePos = self.carriageNP.getPos()
self.carriageBounds = self.carriageNP.getTightBounds()
self.font = base.loader.loadFont('Harting.ttf', pointSize=32)
self.pnmFont = PNMTextMaker(self.font)
self.fontCharSize, _, _ = fonts.measureFont(self.pnmFont, 32)
print "font char size: ", self.fontCharSize
self.pixelsPerLine = int(round(self.pnmFont.getLineHeight()))
self.target = None
""" panda3d.core.NodePath """
self.targetRoot = None
""" panda3d.core.NodePath """
self.paperY = 0.0
""" range from 0 to 1 """
self.paperX = 0.0
""" range from 0 to 1 """
self.createRollerBase()
self.tex = None
self.texImage = None
self.setupTexture()
self.scheduler = Scheduler()
task = self.base.taskMgr.add(self.tick, 'timerTask')
task.setDelay(0.01)
def tick(self, task):
self.scheduler.tick(globalClock.getRealTime())
return task.cont
def setupTexture(self):
"""
This is the overlay/decal/etc. which contains the typed characters.
The texture size and the font size are currently tied together.
:return:
"""
self.texImage = PNMImage(1024, 1024)
self.texImage.addAlpha()
self.texImage.fill(1.0)
self.texImage.alphaFill(1.0)
self.tex = Texture('typing')
self.tex.setMagfilter(Texture.FTLinear)
self.tex.setMinfilter(Texture.FTLinear)
self.typingStage = TextureStage('typing')
self.typingStage.setMode(TextureStage.MModulate)
self.tex.load(self.texImage)
# ensure we can quickly update subimages
self.tex.setKeepRamImage(True)
# temp for drawing chars
self.chImage = PNMImage(*self.fontCharSize)
def drawCharacter(self, ch, px, py):
"""
Draw a character onto the texture
:param ch:
:param px: paperX
:param py: paperY
:return: the paper-relative size of the character
"""
h = self.fontCharSize[1]
if ch != ' ':
# position -> pixel, applying margins
x = int(self.tex.getXSize() * (px * 0.8 + 0.1))
y = int(self.tex.getYSize() * (py * 0.8 + 0.1))
# always draw onto the paper, to capture
# incremental character overstrikes
self.pnmFont.generateInto(ch, self.texImage, x, y)
if False:
#print ch,"to",x,y,"w=",g.getWidth()
self.tex.load(self.texImage)
else:
# copy an area (presumably) encompassing the character
g = self.pnmFont.getGlyph(ord(ch))
cx, cy = self.fontCharSize
# a glyph is minimally sized and "moves around" in its text box
# (think ' vs. ,), so it has been drawn somewhere relative to
# the 'x' and 'y' we wanted.
x += g.getLeft()
y -= g.getTop()
self.chImage.copySubImage(
self.texImage,
0,
0, # from
x,
y, # to
cx,
cy # size
)
self.tex.loadSubImage(self.chImage, x, y)
# toggle for a typewriter that uses non-proportional spacing
#w = self.paperCharWidth(g.getWidth())
w = self.paperCharWidth()
else:
w = self.paperCharWidth()
return w, h
def start(self):
self.target = None
self.setTarget('paper')
self.hookKeyboard()
def createRollerBase(self):
""" The paper moves such that it is tangent to the roller.
This nodepath keeps a coordinate space relative to that, so that
the paper can be positioned from (0,0,0) to (0,0,1) to "roll" it
along the roller.
"""
bb = self.rollerNP.getTightBounds()
#self.rollerNP.showTightBounds()
self.paperRollerBase = self.rollerAssemblyNP.attachNewNode(
'rollerBase')
self.paperRollerBase.setHpr(0, -20, 0)
print "roller:", bb
rad = abs(bb[0].y - bb[1].y) / 2
center = Vec3(-(bb[0].x + bb[1].x) / 2 - 0.03, (bb[0].y - bb[1].y) / 2,
(bb[0].z + bb[1].z) / 2)
self.paperRollerBase.setPos(center)
def setTarget(self, name):
if self.target:
self.target.removeNode()
# load and transform the model
target = self.TARGETS[name]
self.target = self.base.loader.loadModel(target['model'])
#self.target.setScale(target['scale'])
self.target.setHpr(target['hpr'])
# put it in the world
self.target.reparentTo(self.paperRollerBase)
rbb = self.rollerNP.getTightBounds()
tbb = self.target.getTightBounds()
rs = (rbb[1] - rbb[0])
ts = (tbb[1] - tbb[0])
self.target.setScale(rs.x / ts.x, 1, 1)
# apply the texture
self.targetRoot = self.target
if 'textureRoot' in target:
self.targetRoot = self.target.find("**/" + target['textureRoot'])
assert self.targetRoot
self.targetRoot.setTexture(self.typingStage, self.tex)
#self.setupTargetClip()
# reset
self.paperX = self.paperY = 0.
newPos = self.calcPaperPos(self.paperY)
self.target.setPos(newPos)
self.moveCarriage()
def setupTargetClip(self):
"""
The target is fed in to the typewriter but until we invent "geom curling",
it shouldn't be visible under the typewriter under the desk.
The @underDeskClip node has a world-relative bounding box, which
we can convert to the target-relative bounding box, and pass to a
shader that can clip the nodes.
"""
shader = Shader.make(
Shader.SLGLSL, """
#version 120
attribute vec4 p3d_MultiTexCoord0;
attribute vec4 p3d_MultiTexCoord1;
void main() {
gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
gl_TexCoord[0] = p3d_MultiTexCoord0;
gl_TexCoord[1] = p3d_MultiTexCoord1;
}
""", """
#version 120
uniform sampler2D baseTex;
uniform sampler2D charTex;
const vec4 zero = vec4(0, 0, 0, 0);
const vec4 one = vec4(1, 1, 1, 1);
const vec4 half = vec4(0.5, 0.5, 0.5, 0);
void main() {
vec4 baseColor = texture2D(baseTex, gl_TexCoord[0].st);
vec4 typeColor = texture2D(charTex, gl_TexCoord[1].st);
gl_FragColor = baseColor * typeColor;
}""")
self.target.setShader(shader)
baseTex = self.targetRoot.getTexture()
print "Base Texture:", baseTex
self.target.setShaderInput("baseTex", baseTex)
self.target.setShaderInput("charTex", self.tex)
def hookKeyboard(self):
"""
Hook events so we can respond to keypresses.
"""
self.base.buttonThrowers[0].node().setKeystrokeEvent('keystroke')
self.base.accept('keystroke', self.schedTypeCharacter)
self.base.accept('backspace', self.schedBackspace)
self.base.accept('arrow_up', lambda: self.schedAdjustPaper(-5))
self.base.accept('arrow_up-repeat', lambda: self.schedAdjustPaper(-1))
self.base.accept('arrow_down', lambda: self.schedAdjustPaper(5))
self.base.accept('arrow_down-repeat', lambda: self.schedAdjustPaper(1))
self.base.accept('arrow_left', lambda: self.schedAdjustCarriage(-1))
self.base.accept('arrow_left-repeat',
lambda: self.schedAdjustCarriage(-1))
self.base.accept('arrow_right', lambda: self.schedAdjustCarriage(1))
self.base.accept('arrow_right-repeat',
lambda: self.schedAdjustCarriage(1))
def paperCharWidth(self, pixels=None):
if not pixels:
pixels = self.fontCharSize[0]
return float(pixels) / self.tex.getXSize()
def paperLineHeight(self):
return float(self.fontCharSize[1] * 1.2) / self.tex.getYSize()
def schedScroll(self):
if self.scheduler.isQueueEmpty():
self.schedRollPaper(1)
self.schedResetCarriage()
def schedBackspace(self):
if self.scheduler.isQueueEmpty():
def doit():
if self.paperX > 0:
self.schedAdjustCarriage(-1)
self.scheduler.schedule(0.01, doit)
def createMoveCarriageInterval(self, newX, curX=None):
if curX is None:
curX = self.paperX
here = self.calcCarriage(curX)
there = self.calcCarriage(newX)
posInterval = LerpPosInterval(self.carriageNP,
abs(newX - curX),
there,
startPos=here,
blendType='easeIn')
posInterval.setDoneEvent('carriageReset')
def isReset():
self.paperX = newX
self.base.acceptOnce('carriageReset', isReset)
return posInterval
def schedResetCarriage(self):
if self.paperX > 0.1:
self.sounds['pullback'].play()
invl = self.createMoveCarriageInterval(0)
self.scheduler.scheduleInterval(0, invl)
def calcCarriage(self, paperX):
"""
Calculate where the carriage should be offset based
on the position on the paper
:param paperX: 0...1
:return: pos for self.carriageNP
"""
x = (0.5 - paperX) * 0.69 * 0.8 + 0.01
bb = self.carriageBounds
return self.baseCarriagePos + Point3(x * (bb[1].x - bb[0].x), 0, 0)
def moveCarriage(self):
pos = self.calcCarriage(self.paperX)
self.carriageNP.setPos(pos)
def schedMoveCarriage(self, curX, newX):
if self.scheduler.isQueueEmpty():
#self.scheduler.schedule(0.1, self.moveCarriage)
invl = self.createMoveCarriageInterval(newX, curX=curX)
invl.start()
def schedAdjustCarriage(self, bx):
if self.scheduler.isQueueEmpty():
def doit():
self.paperX = max(
0.0, min(1.0, self.paperX + bx * self.paperCharWidth()))
self.moveCarriage()
self.scheduler.schedule(0.1, doit)
def calcPaperPos(self, paperY):
# center over roller, peek out a little
z = paperY * 0.8 - 0.5 + 0.175
bb = self.target.getTightBounds()
return Point3(-0.5, 0, z * (bb[1].z - bb[0].z))
def createMovePaperInterval(self, newY):
here = self.calcPaperPos(self.paperY)
there = self.calcPaperPos(newY)
posInterval = LerpPosInterval(self.target,
abs(newY - self.paperY),
there,
startPos=here,
blendType='easeInOut')
posInterval.setDoneEvent('scrollDone')
def isDone():
self.paperY = newY
self.base.acceptOnce('scrollDone', isDone)
return posInterval
def schedAdjustPaper(self, by):
if self.scheduler.isQueueEmpty():
def doit():
self.schedRollPaper(by)
self.scheduler.schedule(0.1, doit)
def schedRollPaper(self, by):
"""
Position the paper such that @percent of it is rolled over roller
:param percent:
:return:
"""
def doit():
self.sounds['scroll'].play()
newY = min(1.0, max(0.0,
self.paperY + self.paperLineHeight() * by))
invl = self.createMovePaperInterval(newY)
invl.start()
self.scheduler.schedule(0.1, doit)
def schedTypeCharacter(self, keyname):
# filter for visibility
if ord(keyname) == 13:
self.schedScroll()
elif ord(keyname) >= 32 and ord(keyname) != 127:
if self.scheduler.isQueueEmpty():
curX, curY = self.paperX, self.paperY
self.typeCharacter(keyname, curX, curY)
def typeCharacter(self, ch, curX, curY):
newX = curX
w, h = self.drawCharacter(ch, curX, curY)
newX += w
if ch != ' ':
# alternate typing sound
#self.typeIndex = (self.typeIndex+1) % 3
self.typeIndex = random.randint(0, 2)
self.sounds['type' + str(self.typeIndex + 1)].play()
else:
self.sounds['advance'].play()
if newX >= 1:
self.sounds['bell'].play()
newX = 1
self.schedMoveCarriage(self.paperX, newX)
# move first, to avoid overtype
self.paperX = newX
class HtmlView(DirectObject):
notify = DirectNotifyGlobal.directNotify.newCategory('HtmlView')
useHalfTexture = base.config.GetBool('news-half-texture', 0)
def __init__(self, parent = aspect2d):
global GlobalWebcore
self.parent_ = parent
self.mx = 0
self.my = 0
self.htmlFile = 'index.html'
self.transparency = False
if GlobalWebcore:
pass
else:
GlobalWebcore = AwWebCore(AwWebCore.LOGVERBOSE, True, AwWebCore.PFBGRA)
GlobalWebcore.setBaseDirectory('.')
for errResponse in xrange(400, 600):
GlobalWebcore.setCustomResponsePage(errResponse, 'error.html')
self.webView = GlobalWebcore.createWebView(WEB_WIDTH, WEB_HEIGHT, self.transparency, False, 70)
frameName = ''
inGameNewsUrl = self.getInGameNewsUrl()
self.imgBuffer = array.array('B')
for i in xrange(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 xrange(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 xrange(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.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])
def getInGameNewsUrl(self):
result = base.config.GetString('fallback-news-url', 'http://cdn.toontown.disney.go.com/toontown/en/gamenews/')
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)
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 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)
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)
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)
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 calcMouseLimits(self):
ll = Point3()
ur = Point3()
self.quad.calcTightBounds(ll, ur)
self.notify.debug('ll=%s ur=%s' % (ll, ur))
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
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):
if base.mouseWatcherNode.hasMouse():
x, y = self._translateRelativeCoordinates(base.mouseWatcherNode.getMouseX(), base.mouseWatcherNode.getMouseY())
if self.mx - x != 0 or self.my - y != 0:
self.webView.injectMouseMove(x, y)
self.mx, self.my = x, y
if self.webView.isDirty():
self.webView.render(self.imgBuffer.buffer_info()[0], WEB_WIDTH * 4, 4)
Texture.setTexturesPower2(2)
textureBuffer = self.guiTex.modifyRamImage()
textureBuffer.setData(self.imgBuffer.tostring())
if self.useHalfTexture:
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(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):
self.ignoreAll()
self.webView.destroy()
self.webView = None
return
def onCallback(self, name, args):
if name == 'requestFPS':
pass
def onBeginNavigation(self, url, frameName):
pass
def onBeginLoading(self, url, frameName, statusCode, mimeType):
pass
def onFinishLoading(self):
self.notify.debug('finished loading')
def onReceiveTitle(self, title, frameName):
pass
def onChangeTooltip(self, tooltip):
pass
def onChangeCursor(self, cursor):
pass
def onChangeKeyboardFocus(self, isFocused):
pass
def onChangeTargetURL(self, url):
pass
def generate(self):
'''(Re)generate the entire terrain erasing any current changes'''
factor = self.blockSize * self.chunkSize
#print "Factor:", factor
for terrain in self.terrains:
terrain.getRoot().removeNode()
self.terrains = []
# Breaking master heightmap into subimages
heightmaps = []
self.xchunks = (self.heightfield.getXSize() - 1) / factor
self.ychunks = (self.heightfield.getYSize() - 1) / factor
#print "X,Y chunks:", self.xchunks, self.ychunks
n = 0
for y in range(0, self.ychunks):
for x in range(0, self.xchunks):
heightmap = PNMImage(factor + 1, factor + 1)
heightmap.copySubImage(self.heightfield,
0,
0,
xfrom=x * factor,
yfrom=y * factor)
heightmaps.append(heightmap)
n += 1
# Generate GeoMipTerrains
n = 0
y = self.ychunks - 1
x = 0
for heightmap in heightmaps:
terrain = GeoMipTerrain(str(n))
terrain.setHeightfield(heightmap)
terrain.setBruteforce(self.bruteForce)
terrain.setBlockSize(self.blockSize)
terrain.generate()
self.terrains.append(terrain)
root = terrain.getRoot()
root.reparentTo(self.root)
root.setPos(n % self.xchunks * factor, (y) * factor, 0)
# In order to texture span properly we need to reiterate through every vertex
# and redefine the uv coordinates based on our size, not the subGeoMipTerrain's
root = terrain.getRoot()
children = root.getChildren()
for child in children:
geomNode = child.node()
for i in range(geomNode.getNumGeoms()):
geom = geomNode.modifyGeom(i)
vdata = geom.modifyVertexData()
texcoord = GeomVertexWriter(vdata, 'texcoord')
vertex = GeomVertexReader(vdata, 'vertex')
while not vertex.isAtEnd():
v = vertex.getData3f()
t = texcoord.setData2f(
(v[0] + self.blockSize / 2 + self.blockSize * x) /
(self.xsize - 1),
(v[1] + self.blockSize / 2 + self.blockSize * y) /
(self.ysize - 1))
x += 1
if x >= self.xchunks:
x = 0
y -= 1
n += 1
def __init__(self, pipeline):
DebugObject.__init__(self, "BugReporter")
self.debug("Creating bug report")
reportDir = "BugReports/" + str(int(time.time())) + "/"
reportFname = "BugReports/" + str(int(time.time())) + ""
if not isdir(reportDir):
os.makedirs(reportDir)
# Generate general log
DebugLog = "Pipeline Bug-Report\n"
DebugLog += "Created: " + datetime.datetime.now().isoformat() + "\n"
DebugLog += "System: " + sys.platform + " / " + os.name + " (" + str(
8 * struct.calcsize("P")) + " Bit)\n"
with open(join(reportDir, "general.log"), "w") as handle:
handle.write(DebugLog)
# Write stdout and stderr
with open(join(reportDir, "stdout.log"), "w") as handle:
handle.write(sys.stdout.getLog())
with open(join(reportDir, "stderr.log"), "w") as handle:
handle.write(sys.stderr.getLog())
# Write the scene graph
handle = OFileStream(join(reportDir, "scene_graph.log"))
Globals.render.ls(handle)
handle.close()
# Write the pipeline settings
SettingLog = "# Pipeline Settings Diff File:\n\n"
for key, val in pipeline.settings.settings.iteritems():
if val.value != val.default:
SettingLog += key + " = " + str(
val.value) + " (Default " + str(val.default) + ")\n"
with open(join(reportDir, "pipeline.ini"), "w") as handle:
handle.write(SettingLog)
# Write the panda settings
handle = OFileStream(join(reportDir, "pandacfg.log"))
ConfigVariableManager.getGlobalPtr().writePrcVariables(handle)
handle.close()
# Write lights and shadow sources
with open(join(reportDir, "lights.log"), "w") as handle:
pp = pprint.PrettyPrinter(indent=4, stream=handle)
handle.write("\nLights:\n")
pp.pprint(pipeline.lightManager.lightSlots)
handle.write("\n\nShadowSources:\n")
pp.pprint(pipeline.lightManager.shadowSourceSlots)
# Extract buffers
bufferDir = join(reportDir, "buffers")
if not isdir(bufferDir):
os.makedirs(bufferDir)
for name, (size, entry) in MemoryMonitor.memoryEntries.iteritems():
if type(entry) == Texture:
w, h = entry.getXSize(), entry.getYSize()
# Ignore buffers
if h < 2:
continue
pipeline.showbase.graphicsEngine.extractTextureData(
entry, pipeline.showbase.win.getGsg())
if not entry.hasRamImage():
print "Ignoring", name
continue
pnmSrc = PNMImage(w, h, 4, 2**16 - 1)
entry.store(pnmSrc)
pnmColor = PNMImage(w, h, 3, 2**16 - 1)
pnmColor.copySubImage(pnmSrc, 0, 0, 0, 0, w, h)
pnmColor.write(join(bufferDir, name + "-color.png"))
pnmAlpha = PNMImage(w, h, 3, 2**16 - 1)
pnmAlpha.copyChannel(pnmSrc, 3, 0)
pnmAlpha.write(join(bufferDir, name + "-alpha.png"))
shutil.make_archive(reportFname, 'zip', reportDir)
shutil.rmtree(reportDir)
self.debug("Bug report saved: ", reportFname + ".zip")
class Typist(object):
TARGETS = { 'paper': {
'model': 'paper',
'textureRoot': 'Front',
'scale': Point3(0.85, 0.85, 1),
'hpr' : Point3(0, 0, 0),
}
}
def __init__(self, base, typewriterNP, underDeskClip, sounds):
self.base = base
self.sounds = sounds
self.underDeskClip = underDeskClip
self.typeIndex = 0
self.typewriterNP = typewriterNP
self.rollerAssemblyNP = typewriterNP.find("**/roller assembly")
assert self.rollerAssemblyNP
self.rollerNP = typewriterNP.find("**/roller")
assert self.rollerNP
self.carriageNP = typewriterNP.find("**/carriage")
assert self.carriageNP
self.baseCarriagePos = self.carriageNP.getPos()
self.carriageBounds = self.carriageNP.getTightBounds()
self.font = base.loader.loadFont('Harting.ttf', pointSize=32)
self.pnmFont = PNMTextMaker(self.font)
self.fontCharSize, _, _ = fonts.measureFont(self.pnmFont, 32)
print "font char size: ",self.fontCharSize
self.pixelsPerLine = int(round(self.pnmFont.getLineHeight()))
self.target = None
""" panda3d.core.NodePath """
self.targetRoot = None
""" panda3d.core.NodePath """
self.paperY = 0.0
""" range from 0 to 1 """
self.paperX = 0.0
""" range from 0 to 1 """
self.createRollerBase()
self.tex = None
self.texImage = None
self.setupTexture()
self.scheduler = Scheduler()
task = self.base.taskMgr.add(self.tick, 'timerTask')
task.setDelay(0.01)
def tick(self, task):
self.scheduler.tick(globalClock.getRealTime())
return task.cont
def setupTexture(self):
"""
This is the overlay/decal/etc. which contains the typed characters.
The texture size and the font size are currently tied together.
:return:
"""
self.texImage = PNMImage(1024, 1024)
self.texImage.addAlpha()
self.texImage.fill(1.0)
self.texImage.alphaFill(1.0)
self.tex = Texture('typing')
self.tex.setMagfilter(Texture.FTLinear)
self.tex.setMinfilter(Texture.FTLinear)
self.typingStage = TextureStage('typing')
self.typingStage.setMode(TextureStage.MModulate)
self.tex.load(self.texImage)
# ensure we can quickly update subimages
self.tex.setKeepRamImage(True)
# temp for drawing chars
self.chImage = PNMImage(*self.fontCharSize)
def drawCharacter(self, ch, px, py):
"""
Draw a character onto the texture
:param ch:
:param px: paperX
:param py: paperY
:return: the paper-relative size of the character
"""
h = self.fontCharSize[1]
if ch != ' ':
# position -> pixel, applying margins
x = int(self.tex.getXSize() * (px * 0.8 + 0.1))
y = int(self.tex.getYSize() * (py * 0.8 + 0.1))
# always draw onto the paper, to capture
# incremental character overstrikes
self.pnmFont.generateInto(ch, self.texImage, x, y)
if False:
#print ch,"to",x,y,"w=",g.getWidth()
self.tex.load(self.texImage)
else:
# copy an area (presumably) encompassing the character
g = self.pnmFont.getGlyph(ord(ch))
cx, cy = self.fontCharSize
# a glyph is minimally sized and "moves around" in its text box
# (think ' vs. ,), so it has been drawn somewhere relative to
# the 'x' and 'y' we wanted.
x += g.getLeft()
y -= g.getTop()
self.chImage.copySubImage(
self.texImage,
0, 0, # from
x, y, # to
cx, cy # size
)
self.tex.loadSubImage(self.chImage, x, y)
# toggle for a typewriter that uses non-proportional spacing
#w = self.paperCharWidth(g.getWidth())
w = self.paperCharWidth()
else:
w = self.paperCharWidth()
return w, h
def start(self):
self.target = None
self.setTarget('paper')
self.hookKeyboard()
def createRollerBase(self):
""" The paper moves such that it is tangent to the roller.
This nodepath keeps a coordinate space relative to that, so that
the paper can be positioned from (0,0,0) to (0,0,1) to "roll" it
along the roller.
"""
bb = self.rollerNP.getTightBounds()
#self.rollerNP.showTightBounds()
self.paperRollerBase = self.rollerAssemblyNP.attachNewNode('rollerBase')
self.paperRollerBase.setHpr(0, -20, 0)
print "roller:",bb
rad = abs(bb[0].y - bb[1].y) / 2
center = Vec3(-(bb[0].x+bb[1].x)/2 - 0.03,
(bb[0].y-bb[1].y)/2,
(bb[0].z+bb[1].z)/2)
self.paperRollerBase.setPos(center)
def setTarget(self, name):
if self.target:
self.target.removeNode()
# load and transform the model
target = self.TARGETS[name]
self.target = self.base.loader.loadModel(target['model'])
#self.target.setScale(target['scale'])
self.target.setHpr(target['hpr'])
# put it in the world
self.target.reparentTo(self.paperRollerBase)
rbb = self.rollerNP.getTightBounds()
tbb = self.target.getTightBounds()
rs = (rbb[1] - rbb[0])
ts = (tbb[1] - tbb[0])
self.target.setScale(rs.x / ts.x, 1, 1)
# apply the texture
self.targetRoot = self.target
if 'textureRoot' in target:
self.targetRoot = self.target.find("**/" + target['textureRoot'])
assert self.targetRoot
self.targetRoot.setTexture(self.typingStage, self.tex)
#self.setupTargetClip()
# reset
self.paperX = self.paperY = 0.
newPos = self.calcPaperPos(self.paperY)
self.target.setPos(newPos)
self.moveCarriage()
def setupTargetClip(self):
"""
The target is fed in to the typewriter but until we invent "geom curling",
it shouldn't be visible under the typewriter under the desk.
The @underDeskClip node has a world-relative bounding box, which
we can convert to the target-relative bounding box, and pass to a
shader that can clip the nodes.
"""
shader = Shader.make(
Shader.SLGLSL,
"""
#version 120
attribute vec4 p3d_MultiTexCoord0;
attribute vec4 p3d_MultiTexCoord1;
void main() {
gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
gl_TexCoord[0] = p3d_MultiTexCoord0;
gl_TexCoord[1] = p3d_MultiTexCoord1;
}
""",
"""
#version 120
uniform sampler2D baseTex;
uniform sampler2D charTex;
const vec4 zero = vec4(0, 0, 0, 0);
const vec4 one = vec4(1, 1, 1, 1);
const vec4 half = vec4(0.5, 0.5, 0.5, 0);
void main() {
vec4 baseColor = texture2D(baseTex, gl_TexCoord[0].st);
vec4 typeColor = texture2D(charTex, gl_TexCoord[1].st);
gl_FragColor = baseColor * typeColor;
}"""
)
self.target.setShader(shader)
baseTex = self.targetRoot.getTexture()
print "Base Texture:",baseTex
self.target.setShaderInput("baseTex", baseTex)
self.target.setShaderInput("charTex", self.tex)
def hookKeyboard(self):
"""
Hook events so we can respond to keypresses.
"""
self.base.buttonThrowers[0].node().setKeystrokeEvent('keystroke')
self.base.accept('keystroke', self.schedTypeCharacter)
self.base.accept('backspace', self.schedBackspace)
self.base.accept('arrow_up', lambda: self.schedAdjustPaper(-5))
self.base.accept('arrow_up-repeat', lambda: self.schedAdjustPaper(-1))
self.base.accept('arrow_down', lambda:self.schedAdjustPaper(5))
self.base.accept('arrow_down-repeat', lambda:self.schedAdjustPaper(1))
self.base.accept('arrow_left', lambda: self.schedAdjustCarriage(-1))
self.base.accept('arrow_left-repeat', lambda: self.schedAdjustCarriage(-1))
self.base.accept('arrow_right', lambda:self.schedAdjustCarriage(1))
self.base.accept('arrow_right-repeat', lambda:self.schedAdjustCarriage(1))
def paperCharWidth(self, pixels=None):
if not pixels:
pixels = self.fontCharSize[0]
return float(pixels) / self.tex.getXSize()
def paperLineHeight(self):
return float(self.fontCharSize[1] * 1.2) / self.tex.getYSize()
def schedScroll(self):
if self.scheduler.isQueueEmpty():
self.schedRollPaper(1)
self.schedResetCarriage()
def schedBackspace(self):
if self.scheduler.isQueueEmpty():
def doit():
if self.paperX > 0:
self.schedAdjustCarriage(-1)
self.scheduler.schedule(0.01, doit)
def createMoveCarriageInterval(self, newX, curX=None):
if curX is None:
curX = self.paperX
here = self.calcCarriage(curX)
there = self.calcCarriage(newX)
posInterval = LerpPosInterval(
self.carriageNP, abs(newX - curX),
there,
startPos = here,
blendType='easeIn')
posInterval.setDoneEvent('carriageReset')
def isReset():
self.paperX = newX
self.base.acceptOnce('carriageReset', isReset)
return posInterval
def schedResetCarriage(self):
if self.paperX > 0.1:
self.sounds['pullback'].play()
invl = self.createMoveCarriageInterval(0)
self.scheduler.scheduleInterval(0, invl)
def calcCarriage(self, paperX):
"""
Calculate where the carriage should be offset based
on the position on the paper
:param paperX: 0...1
:return: pos for self.carriageNP
"""
x = (0.5 - paperX) * 0.69 * 0.8 + 0.01
bb = self.carriageBounds
return self.baseCarriagePos + Point3(x * (bb[1].x-bb[0].x), 0, 0)
def moveCarriage(self):
pos = self.calcCarriage(self.paperX)
self.carriageNP.setPos(pos)
def schedMoveCarriage(self, curX, newX):
if self.scheduler.isQueueEmpty():
#self.scheduler.schedule(0.1, self.moveCarriage)
invl = self.createMoveCarriageInterval(newX, curX=curX)
invl.start()
def schedAdjustCarriage(self, bx):
if self.scheduler.isQueueEmpty():
def doit():
self.paperX = max(0.0, min(1.0, self.paperX + bx * self.paperCharWidth()))
self.moveCarriage()
self.scheduler.schedule(0.1, doit)
def calcPaperPos(self, paperY):
# center over roller, peek out a little
z = paperY * 0.8 - 0.5 + 0.175
bb = self.target.getTightBounds()
return Point3(-0.5, 0, z * (bb[1].z-bb[0].z))
def createMovePaperInterval(self, newY):
here = self.calcPaperPos(self.paperY)
there = self.calcPaperPos(newY)
posInterval = LerpPosInterval(
self.target, abs(newY - self.paperY),
there,
startPos = here,
blendType='easeInOut')
posInterval.setDoneEvent('scrollDone')
def isDone():
self.paperY = newY
self.base.acceptOnce('scrollDone', isDone)
return posInterval
def schedAdjustPaper(self, by):
if self.scheduler.isQueueEmpty():
def doit():
self.schedRollPaper(by)
self.scheduler.schedule(0.1, doit)
def schedRollPaper(self, by):
"""
Position the paper such that @percent of it is rolled over roller
:param percent:
:return:
"""
def doit():
self.sounds['scroll'].play()
newY = min(1.0, max(0.0, self.paperY + self.paperLineHeight() * by))
invl = self.createMovePaperInterval(newY)
invl.start()
self.scheduler.schedule(0.1, doit)
def schedTypeCharacter(self, keyname):
# filter for visibility
if ord(keyname) == 13:
self.schedScroll()
elif ord(keyname) >= 32 and ord(keyname) != 127:
if self.scheduler.isQueueEmpty():
curX, curY = self.paperX, self.paperY
self.typeCharacter(keyname, curX, curY)
def typeCharacter(self, ch, curX, curY):
newX = curX
w, h = self.drawCharacter(ch, curX, curY)
newX += w
if ch != ' ':
# alternate typing sound
#self.typeIndex = (self.typeIndex+1) % 3
self.typeIndex = random.randint(0, 2)
self.sounds['type' + str(self.typeIndex+1)].play()
else:
self.sounds['advance'].play()
if newX >= 1:
self.sounds['bell'].play()
newX = 1
self.schedMoveCarriage(self.paperX, newX)
# move first, to avoid overtype
self.paperX = newX
def __init__(self, pipeline):
DebugObject.__init__(self, "BugReporter")
self.debug("Creating bug report")
reportDir = "BugReports/" + str(int(time.time())) + "/"
reportFname = "BugReports/" + str(int(time.time())) + ""
if not isdir(reportDir):
os.makedirs(reportDir)
# Generate general log
DebugLog = "Pipeline Bug-Report\n"
DebugLog += "Created: " + datetime.datetime.now().isoformat() + "\n"
DebugLog += "System: " + sys.platform + " / " + os.name + " (" + str(8 * struct.calcsize("P")) + " Bit)\n"
with open(join(reportDir, "general.log"), "w") as handle:
handle.write(DebugLog)
# Write stdout and stderr
with open(join(reportDir, "stdout.log"), "w") as handle:
handle.write(sys.stdout.getLog())
with open(join(reportDir, "stderr.log"), "w") as handle:
handle.write(sys.stderr.getLog())
# Write the scene graph
handle = OFileStream(join(reportDir, "scene_graph.log"))
Globals.render.ls(handle)
handle.close()
# Write the pipeline settings
SettingLog = "# Pipeline Settings Diff File:\n\n"
for key, val in pipeline.settings.settings.iteritems():
if val.value != val.default:
SettingLog += key + " = " + str(val.value) + " (Default " + str(val.default) + ")\n"
with open(join(reportDir, "pipeline.ini"), "w") as handle:
handle.write(SettingLog)
# Write the panda settings
handle = OFileStream(join(reportDir, "pandacfg.log"))
ConfigVariableManager.getGlobalPtr().writePrcVariables(handle)
handle.close()
# Write lights and shadow sources
with open(join(reportDir, "lights.log"), "w") as handle:
pp = pprint.PrettyPrinter(indent=4, stream=handle)
handle.write("\nLights:\n")
pp.pprint(pipeline.lightManager.lightSlots)
handle.write("\n\nShadowSources:\n")
pp.pprint(pipeline.lightManager.shadowSourceSlots)
# Extract buffers
bufferDir = join(reportDir, "buffers")
if not isdir(bufferDir):
os.makedirs(bufferDir)
for name, (size, entry) in MemoryMonitor.memoryEntries.iteritems():
if type(entry) == Texture:
w, h = entry.getXSize(), entry.getYSize()
# Ignore buffers
if h < 2:
continue
pipeline.showbase.graphicsEngine.extractTextureData(entry, pipeline.showbase.win.getGsg())
if not entry.hasRamImage():
print "Ignoring", name
continue
pnmSrc = PNMImage(w, h, 4, 2 ** 16 - 1)
entry.store(pnmSrc)
pnmColor = PNMImage(w, h, 3, 2 ** 16 - 1)
pnmColor.copySubImage(pnmSrc, 0, 0, 0, 0, w, h)
pnmColor.write(join(bufferDir, name + "-color.png"))
pnmAlpha = PNMImage(w, h, 3, 2 ** 16 - 1)
pnmAlpha.copyChannel(pnmSrc, 3, 0)
pnmAlpha.write(join(bufferDir, name + "-alpha.png"))
shutil.make_archive(reportFname, "zip", reportDir)
shutil.rmtree(reportDir)
self.debug("Bug report saved: ", reportFname + ".zip")
