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 __init__(self, **kwargs):
"""
See the Element class to find out what attributes are available
from scratch
"""
super(VideoPlayer, self).__init__(**kwargs)
self.videofile = getattr(self.config, 'file_video', None)
self.loopCount = getattr(self.config, 'loop', 1)
self.hoffset = getattr(self.config, 'hoffset', 0)
self.voffset = getattr(self.config, 'voffset', 0)
#self.videoScale = getattr(self.config, 'scale', (1,1))
#self.playrate = getattr(self.config, 'speed', 1.0)
if self.videofile:
movieTexture = loader.loadTexture(self.videofile)
cm = CardMaker("video_card")
# cm.setFrameFullscreenQuad()
cm.setUvRange(movieTexture)
card = NodePath(cm.generate())
card.reparentTo(self.hudNP)
card.setTexture(movieTexture)
card.setTexScale(TextureStage.getDefault(),
movieTexture.getTexScale())
card.setPos(-0.5 + self.hoffset, 0.0, -0.5 + self.voffset)
self.movie = movieTexture
print card.getScale()
self.time = 0
self.movie.stop()
self.hideElement()
def __init__(self, name, nrplates, width, height, shaderfile, texturefile, uvlist, jitter=-1):
self.name = name
self.texturefile = texturefile
self.shaderfile = shaderfile
self.np = NodePath('leaf')
self.tex = loader.loadTexture('textures/' + texturefile)
self.tex.setMinfilter(Texture.FTLinearMipmapLinear)
self.tex.setMagfilter(Texture.FTLinearMipmapLinear)
self.tex.setAnisotropDegree(2)
self.np.setTexture(self.tex)
self.np.setTwoSided(True)
self.np.setTransparency(TransparencyAttrib.MAlpha)
self.np.setDepthWrite(False)
maker = CardMaker('leaf')
maker.setFrame(-width/2.0, width/2.0, 0, height)
#maker.setFrame(0,1,0,1)
for i in range(nrplates):
if uvlist != None:
maker.setUvRange(uvlist[i][0], uvlist[i][1])
else:
maker.setUvRange(Point2(0,0), Point2(1,0.98))
node = self.np.attachNewNode(maker.generate())
#node.setTwoSided(True)
node.setHpr(i * 180.0 / nrplates,0,0)
self.np.flattenStrong()
#np.flattenLight()
#np.setTwoSided(True)
if jitter == -1:
self.jitter = height/width/2
else:
self.jitter = jitter
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 title(self):
#Removes title and loads current room
def destroyTitle(task):
card.removeNode()
startGame()
def startGame():
if os.path.isfile('saves/location.json'):
self.directToRoom()
else:
self.homeFirst()
#Loads title animation
titleText = self.loader.loadTexture('resources/titleText.avi')
titleText.setLoopCount(1)
titleText.play()
#Displays title
cm = CardMaker('titleText')
cm.setFrameFullscreenQuad()
cm.setUvRange(titleText)
# noinspection PyArgumentList
card = NodePath(cm.generate())
card.reparentTo(self.render2d)
card.setTexture(titleText)
self.taskMgr.doMethodLater(5.6, destroyTitle, 'endTitle')
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 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
def makeCard(self, color, width, height, i, j, divisions):
divisions = float(divisions)
x = i / divisions
y = j / divisions
d = 1 / divisions
card = CardMaker("wall")
card.setColor(*color)
card.setFrame(width*(x*2-1), width*((x+d)*2-1), height*(y*2-1), height*((y+d)*2-1))
card.setUvRange(Point2(width*x, height*y), Point2(width*(x+d), height*(y+d)))
card.setHasUvs(True)
card.setHasNormals(True)
node = self.node.attachNewNode(card.generate())
def makeCard(self, color, width, height, i, j, divisions):
divisions = float(divisions)
x = i / divisions
y = j / divisions
d = 1 / divisions
card = CardMaker("wall")
card.setColor(*color)
card.setFrame(width * (x * 2 - 1), width * ((x + d) * 2 - 1),
height * (y * 2 - 1), height * ((y + d) * 2 - 1))
card.setUvRange(Point2(width * x, height * y),
Point2(width * (x + d), height * (y + d)))
card.setHasUvs(True)
card.setHasNormals(True)
node = self.node.attachNewNode(card.generate())
class BulletHoles:
"""The name says it all."""
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 makeNew(self, pos, nor, parent=None):
"""Makes a new bullet hole."""
if parent == None:
parent = self.container
else:
# Add a subnode to the parent, if it's not already there
child = parent.find('bullet-holes')
if child.isEmpty():
parent = parent.attachNewNode('bullet-holes')
else:
parent = child
newhole = NodePath(self.card.generate())
newhole.reparentTo(parent)
newhole.lookAt(render, Point3(newhole.getPos(render) - nor))
newhole.setR(newhole, random() * 360.0)
newhole.setPos(render, pos)
# Offset it a little to avoid z-fighting
# Increase this value if you still see it.
newhole.setY(newhole, -.001 - random() * 0.01)
del newhole
# We don't want one batch per bullet hole, so flatten it.
# This could be made smarter to preserve culling, but
# I have yet to see a performance loss.
# The clearTexture() is a necessary hack.
parent.clearTexture()
parent.flattenStrong()
parent.setTexture(self.texture)
parent.setTransparency(TransparencyAttrib.MDual)
parent.setShaderOff(1)
parent.hide(BitMask32.bit(
2)) # Invisible to volumetric lighting camera (speedup)
parent.hide(BitMask32.bit(3)) # Invisible to shadow cameras (speedup)
def destroy(self):
self.container.removeNode()
class BulletHoles:
"""The name says it all."""
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 makeNew(self, pos, nor, parent = None):
"""Makes a new bullet hole."""
if parent == None:
parent = self.container
else:
# Add a subnode to the parent, if it's not already there
child = parent.find('bullet-holes')
if child.isEmpty():
parent = parent.attachNewNode('bullet-holes')
else:
parent = child
newhole = NodePath(self.card.generate())
newhole.reparentTo(parent)
newhole.lookAt(render, Point3(newhole.getPos(render) - nor))
newhole.setR(newhole, random() * 360.0)
newhole.setPos(render, pos)
# Offset it a little to avoid z-fighting
# Increase this value if you still see it.
newhole.setY(newhole, -.001 - random() * 0.01)
del newhole
# We don't want one batch per bullet hole, so flatten it.
# This could be made smarter to preserve culling, but
# I have yet to see a performance loss.
# The clearTexture() is a necessary hack.
parent.clearTexture()
parent.flattenStrong()
parent.setTexture(self.texture)
parent.setTransparency(TransparencyAttrib.MDual)
parent.setShaderOff(1)
parent.hide(BitMask32.bit(2)) # Invisible to volumetric lighting camera (speedup)
parent.hide(BitMask32.bit(3)) # Invisible to shadow cameras (speedup)
def destroy(self):
self.container.removeNode()
def __init__(self,
name,
nrplates,
width,
height,
shaderfile,
texturefile,
uvlist,
jitter=-1):
#print name, nrplates, width, height, shaderfile, texturefile, uvlist, jitter
self.name = name
self.texturefile = texturefile
self.shaderfile = shaderfile
self.np = NodePath('leaf')
self.tex = loader.loadTexture('textures/' + texturefile)
self.tex.setMinfilter(Texture.FTLinearMipmapLinear)
self.tex.setMagfilter(Texture.FTLinearMipmapLinear)
self.tex.setAnisotropicDegree(2)
self.np.setTexture(self.tex)
self.np.setTwoSided(True)
self.np.setTransparency(TransparencyAttrib.MAlpha)
#self.np.setTransparency( TransparencyAttrib.MMultisample )
self.np.setDepthWrite(False)
maker = CardMaker('leaf')
maker.setFrame(-width / 2.0, width / 2.0, 0, height)
#maker.setFrame( 0,1,0,1)
for i in range(nrplates):
if uvlist != None:
maker.setUvRange(uvlist[i][0], uvlist[i][1])
else:
maker.setUvRange(Point2(0, 0), Point2(1, 0.98))
node = self.np.attachNewNode(maker.generate())
#node.setTwoSided( True )
node.setHpr(i * 180.0 / nrplates, 0, 0)
self.np.flattenStrong()
#np.flattenLight()
#np.setTwoSided( True )
if jitter == -1:
self.jitter = height / width / 2
else:
self.jitter = jitter
def __setupPreview(self):
"""Creates the preview."""
if not self.previewCheck.Value: return
if self.preview != None:
self.__destroyPreview()
self.preview = wx.StaticBitmap(self, style = wx.SUNKEN_BORDER, size = PREVIEW_SIZE)
self.sizer.Add(self.preview, 0, wx.ADJUST_MINSIZE | wx.ALIGN_CENTER, 0)
cm = CardMaker("preview")
cm.setFrame(-1, 1, -1, 1)
cm.setUvRange(Point2(0, 0), Point2(1, 1))
self.previewTexture = Texture()
self.previewBuffer = WindowManager.windows[0].win.makeTextureBuffer("preview", *PREVIEW_SIZE)
self.previewBuffer.setClearColor(Vec4(1, 1, 1, 1))
self.previewCamera = base.makeCamera2d(self.previewBuffer)
self.previewPlane = NodePath(cm.generate())
self.previewPlane.setFogOff(1000)
self.previewPlane.setLightOff(1000)
self.previewCamera.node().setScene(self.previewPlane)
self.previewBuffer.addRenderTexture(self.previewTexture, GraphicsOutput.RTMCopyRam)
self.previewCamera.node().setActive(texturePainter.texturePainterStatus == TEXTURE_PAINTER_STATUS_ENABLED)
self.Layout()
def __init__(self, direction, particleSpeed, gravity, particleLifetime, scale, texture, textureBlendType, texCoordU, texCoordV):
self.direction = direction
self.particleSpeed = particleSpeed
self.gravity = gravity
self.particleLifetime = particleLifetime
self.scale = scale
self.texture = texture
self.textureBlendType = textureBlendType
self.texCoordU = texCoordU
self.texCoordV = texCoordV
self.timeAlive = 0
self.node = render.attachNewNode('Particle')
cm = CardMaker('ParticleCard')
cm.setUvRange(Point2(texCoordU[0], texCoordV[0]), Point2(texCoordU[1], texCoordV[1]))
card = self.node.attachNewNode(cm.generate())
#card.setPos(-self.scale / 2.0, 0, -self.scale / 2.0)
card.setScale(self.scale)
card.setTexture(self.texture)
card.setLightOff()
card.setBillboardPointEye()
ballBody.setMass(M)
ballBody.setPosition(ballNP.getPos(render))
ballBody.setQuaternion(ballNP.getQuat(render))
# Create a ballGeom
ballGeom = OdeSphereGeom(space, 1)
ballGeom.setCollideBits(BitMask32(0x00000001))
ballGeom.setCategoryBits(BitMask32(0x00000001))
ballGeom.setBody(ballBody)
# Create the sound
ballSound = loader.loadSfx("audio/sfx/GUI_rollover.wav")
balls.append((ballNP, ballGeom, ballSound))
# Add a plane to collide with
cm = CardMaker("ground")
cm.setFrame(-20, 20, -20, 20)
cm.setUvRange((0, 1), (1, 0))
ground = render.attachNewNode(cm.generate())
ground.setPos(0, 0, 0); ground.lookAt(0, 0, -1)
groundGeom = OdePlaneGeom(space, (0, 0, 1, 0))
groundGeom.setCollideBits(BitMask32(0x00000001))
groundGeom.setCategoryBits(BitMask32(0x00000001))
# Add a texture to the ground
groundImage = PNMImage(512, 512)
groundImage.fill(1, 1, 1)
groundBrush = PNMBrush.makeSpot((0, 0, 0, 1), 8, True)
groundPainter = PNMPainter(groundImage)
groundPainter.setPen(groundBrush)
groundTexture = Texture("ground")
ground.setTexture(groundTexture)
groundImgChanged = False
class VideoPlayer:
def __init__(self, name, resources):
self.log = logging.getLogger('pano.videoPlayer' + name)
self.resources = resources
self.texCard = None
self.texCardNode = None
self.videoTex = None
self.vidSound = None
self.animInterface = None
# has the length of a movie in seconds
self.totalTime = 0.0
def dispose(self):
self._releaseResources()
def playFullScreen(self, video, audio=None):
self._releaseResources()
# self.videoTex = loader.loadTexture(self.resources.getResourceFullPath(PanoConstants.RES_TYPE_VIDEOS, video))
self.videoTex = MovieTexture('name')
self.videoTex.read(
self.resources.getResourceFullPath(PanoConstants.RES_TYPE_VIDEOS,
video))
self.texCard = CardMaker("Full screen Video Card for " + video)
self.texCard.setFrameFullscreenQuad()
self.texCard.setUvRange(self.videoTex)
self.texCardNode = NodePath(self.texCard.generate())
self.texCardNode.reparentTo(render2d)
self.texCardNode.setTexture(self.videoTex)
if audio is not None:
self.vidSound = loader.loadSfx(
self.resources.getResourceFullPath(
PanoConstants.RES_TYPE_MUSIC, audio))
self.videoTex.synchronizeTo(self.vidSound)
self.animInterface = self.videoTex
if self.vidSound is not None:
self.animInterface = self.vidSound
self.totalTime = self.videoTex.getTime()
self.animInterface.setLoop(False)
self.animInterface.play()
def stop(self):
if self.animInterface is not None:
self.animInterface.stop()
def pause(self):
if self.animInterface is not None:
t = self.animInterface.getTime()
self.animInterface.stop()
self.animInterface.setTime(t)
def hasFinished(self):
if self.animInterface is not None:
if type(self.animInterface) == AudioSound:
return self.animInterface.getTime(
) >= self.animInterface.length()
else:
return self.totalTime <= self.animInterface.getTime()
else:
return True
def getAnimInterface(self):
return self.animInterface
def _releaseResources(self):
if self.texCardNode is not None:
self.texCardNode.removeNode()
self.texCard = None
self.texCardNode = None
self.videoTex = None
self.vidSound = None
self.animInterface = None
self.totalTime = 0.0
def renderToGeom(resources, geom, video, audio):
videoTex = loader.loadTexture(
resources.getResourceFullPath(PanoConstants.RES_TYPE_VIDEOS,
video))
if videoTex is None:
print "Couldn't load video %s" % video
return None
# if (base.sfxManagerList[0].getType().getName() != "OpenALAudioManager"):
# self.log.error("OpenAL support is not enabled, cannot proceed.")
# return None
if (videoTex.getType().getName() != "MovieTexture"):
print "MovieTexture support is not enabled, cannot proceed."
return None
geom.setTexture(videoTex)
videoTex.setWrapU(Texture.WMClamp)
videoTex.setWrapV(Texture.WMClamp)
if videoTex.getTexturesPower2():
geom.setTexScale(TextureStage.getDefault(), videoTex.getTexScale())
if audio is not None:
vidSound = loader.loadSfx(
resources.getResourceFullPath(PanoConstants.RES_TYPE_MUSIC,
audio))
videoTex.synchronizeTo(vidSound)
return vidSound
else:
return videoTex
def renderToTexture(resources, video, audio):
videoTex = loader.loadTexture(
resources.getResourceFullPath(PanoConstants.RES_TYPE_VIDEOS,
video))
if videoTex is None:
print "Couldn't load video %s" % video
return None
if (videoTex.getType().getName() != "MovieTexture"):
print "MovieTexture support is not enabled, cannot proceed."
return None
videoTex.setWrapU(Texture.WMClamp)
videoTex.setWrapV(Texture.WMClamp)
#TODO: Check how I can set the texture scale
# if videoTex.getTexturesPower2():
# geom.setTexScale(TextureStage.getDefault(), videoTex.getTexScale())
if audio is not None:
vidSound = loader.loadSfx(
resources.getResourceFullPath(PanoConstants.RES_TYPE_MUSIC,
audio))
videoTex.synchronizeTo(vidSound)
return vidSound
else:
return videoTex
renderToGeom = staticmethod(renderToGeom)
renderToTexture = staticmethod(renderToTexture)
