def __init__(self,
screenRect,
fullRect,
absRect,
zoom=(4, 4),
pos=None,
size=None,
blend=False,
cropRect=None):
self.screenRect = screenRect
self.fullRect = fullRect
self.absRect = absRect
if pos:
self.pos = Vec2(pos[0], pos[1])
else:
self.pos = Vec2(0.0, 0.0)
print "BaseTileDisplayObject, size arg unused"
"""
if not size: # if size == None:
self.size = 100,100
else:
self.size = size
"""
self.blend = blend
self.cropRect = cropRect
self.hidden = False
def __init__(self,
filename,
blend=False,
screenGeomRect=None,
dstRectScale=None):
self.texture = Texture(filename)
if blend:
self.blendFunc = (GL_SRC_ALPHA, GL_ONE)
else:
self.blendFunc = (None, None)
#(GL_SRC_ALPHA, GL_ONE);
#(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)
self.txtrMode = M_REPLACE
# self.txtrTarget = GL_TEXTURE_2D
# self.alphaTest = False # assume this for now
self.nativeWidth, self.nativeHeight = self.texture.getWidth(
), self.texture.getHeight()
self.width, self.height = self.texture.getWidth(
), self.texture.getHeight()
if screenGeomRect == None:
self.screenGeomRect = Rect(0, 0, self.width, self.height)
else:
self.screenGeomRect = screenGeomRect
self.texXMinMax = Vec2(0, 1)
self.texYMinMax = Vec2(0, 1)
self.color = None
if dstRectScale == None:
self.setDstRectScale((1.0, 1.0))
else:
self.setDstRectScale(dstRectScale)
def addObject(o, offset=None):
if offset == None:
currentPos = o.getPos()
self.children[o] = Vec2(currentPos[0], currentPos[1])
else:
self.children[o] = Vec2(offset[0], offset[1])
o.group = self
self.resetPosFromChildren()
def draw(self, vflipTexture=False):
glPushAttrib(GL_ENABLE_BIT)
glDepthMask(GL_FALSE)
# avoids annoying boxes visible around see through particles
glEnable(GL_CULL_FACE)
#if self.alphaTest != None:
# #glEnable(GL_ALPHA_TEST);
# #glAlphaFunc(GL_GREATER, .5);
if self.blendFunc == (None, None):
glDisable(GL_BLEND)
else:
glEnable(GL_BLEND)
#glBlendFunc(GL_SRC_ALPHA, GL_ONE);
#glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)
glBlendFunc(self.blendFunc[0], self.blendFunc[1])
if self.texture != None: # don't have gl textures
glEnable(GL_TEXTURE_2D)
glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE,
GLTextureModes[self.txtrMode])
# glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, self.txtrMode ); # was GL_DECAL, or GL_MODULATE
self.texture.bind()
if (self.color != None):
glColor4f(self.color[0], self.color[1], self.color[2],
self.color[3])
unit_up_vec = Vec2(0.0, 1.0)
edge_vec = Vec2(1.0, 0.0)
if self.texture != None: # have gl textures
# print "easy texture draw:", self.screenGeomRect.x, self.screenGeomRect.y , self.screenGeomRect.width,self.screenGeomRect.height, self.texXMinMax, self.texYMinMax
DrawTxtrd2dSquareIn2DFromCorner(Vec2(self.screenGeomRect.x,
self.screenGeomRect.y),
self.screenGeomRect.width,
self.screenGeomRect.height,
self.texXMinMax,
self.texYMinMax,
vflipTexture=vflipTexture)
else:
Draw2dSquareIn2D(Vec2(0, 0), self.width, self.height)
"""
glBegin(GL_TRIANGLE_STRIP)
glTexCoord2d(0.0, 1.0);
glVertex2f(200, 400)
glTexCoord2d(0.0, 0.0);
glVertex2f(200, 200)
glTexCoord2d(1.0, 1.0);
glVertex2f(400, 400)
glTexCoord2d(1.0, 0.0);
glVertex2f(400, 200)
glEnd()
"""
self.texture.unbind()
glPopAttrib()
def __init__(self, address, objDesc, screenRect, fullRect, absRect, zoom=(4,4), pos=None, size=None, blend=False, cropRect=None, fps=None, scale=None, allowFrameSkip=True, gridColsRows=None, doCenter=True):
BaseTileDisplayObject.__init__(self, screenRect=screenRect, fullRect=fullRect, absRect=absRect, zoom=zoom, pos=pos, size=size, blend=blend, cropRect=cropRect)
self.address = address
if gridColsRows == None:
self.streamCols = 1
self.streamRows = 1
else:
self.streamCols = gridColsRows[0]
self.streamRows = gridColsRows[1]
#self.streamWidth = 352
#self.streamHeight = 288
self.streamWidth = objDesc.streamWidth
self.streamHeight = objDesc.streamHeight
if scale != None:
self.streamWidth *= scale[0]
self.streamHeight *= scale[1]
addVisibleSeparation = False
if addVisibleSeparation:
self.streamWidth += 3
self.streamHeight += 3
self.size = self.streamCols * self.streamWidth, self.streamRows * self.streamHeight
self.streamObjs = []
# print "GROUP:", self.pos, self.size
if doCenter:
# center on pos
self.setPos(pos[0] -self.size[0]/2, pos[1] - self.size[1]/2)
for r in range(self.streamRows):
for c in range(self.streamCols):
objOffset = Vec2(c * self.streamWidth, r * self.streamHeight)
#objPos = (self.pos[0] + c * self.streamWidth, self.pos[1] + r * self.streamHeight)
objPos = Vec2(self.pos[0] + objOffset[0], self.pos[1] + objOffset[1])
streamObj = glStreamedTxtrBox(address, screenRect=screenRect, imagePos=objPos, absRect= absRect, fullRect=fullRect, blend=blend, scale=scale, streamState=StreamState(), streamWidth=objDesc.streamWidth, streamHeight=objDesc.streamHeight, vflip=objDesc.vflip)
streamObj.groupOffset = objOffset
self.streamObjs.append(streamObj)
# information for sorting and aligning tiles
self.targetLocationOrder = []
self.locations = []
for r in range(self.streamRows):
for c in range(self.streamCols):
self.locations.append(Vec2(c * self.streamWidth, r * self.streamHeight))
#nC = self.streamCols-c
#self.targetLocationOrder.append(r*self.streamCols+c)
self.initialObjOrder = list(self.streamObjs)
# DEBUG
#self.targetLocationOrder = [ 0, 1, 2, 3] # numbers for the location
self.targetLocationOrder = range(self.streamRows*self.streamCols)
def __init__(self,
imageFilename,
screenRect,
fullRect,
absRect,
initialOffset=(0, 0),
zoom=(4, 4),
imagePos=(0, 0),
imageSize=None):
self.hasDrawFunc = True
self.hasEraseDrawFunc = True
self.visible = True
self.texture = Texture(imageFilename)
#self.easyTexture = EasyTexture(imageFilename, screenGeomRect=screenRect, blend=False)
#self.easyTexture.width = renderer.width * 0.8
#self.easyTexture.height = renderer.height * 0.8
#self.easyTexture.width = renderer.width
#self.easyTexture.height = renderer.height
self.useDrawPixel = False # For comparison debugging
self.xvel = 0.1
self.yvel = 0.1
self.zoom = zoom
#self.easyTexture.zoom(zoom[0], zoom[1])
#self.easyTexture.setOffset(initialOffset[0], initialOffset[1])
self.autoPan = True
self.imagePos = Vec2(imagePos[0], imagePos[1])
if imageSize == None:
self.imageSize = self.texture.getWidth(
), self.texture.getHeight()
else:
self.imageSize = imageSize
self.fullRect = fullRect
self.absRect = absRect
self.screenRect = screenRect
def resetPosFromChildren(self):
rect = self.getChildrenRect() # the rect origin is the new group origin
if rect:
difference = Vec2(rect.x, rect.y) - self.getPos()
for child, offset in self.childrenAndOffsets.items():
self.childrenAndOffsets[child] = offset - difference
self.setPos(rect.x, rect.y)
print "Group Object pos (after reset pos from children:", self.getPos()
def isPixelTransparent(self, imagecoords):
for child,offset in self.childrenAndOffsets.items():
# need to adjust image coords to match individual image instead of group rect
#print "orig imagecoords:", imagecoords
#print "child coords:", child.getPos(), "group coords:", self.getPos()
offset = child.getPos() - self.getPos()
tileImagecoords = Vec2(imagecoords[0] - offset.x, imagecoords[1] - offset.y)
#print "modified imagecoords:", tileImagecoords
if ( Rect(0,0,child.getWidth(), child.getHeight()).containsPoint(*tileImagecoords) and
not child.isPixelTransparent(tileImagecoords) ):
return False
return True
def update(self, secs, app):
posTuple = self.target.getPos()
pos = Vec2(posTuple[0], posTuple[1])
pos.x = pos.x + self.xvel * secs
pos.y = pos.y + self.yvel * secs
if pos.x > self.xrange[1]:
self.xvel = -abs(self.xvel)
if pos.y > self.yrange[1]:
self.yvel = -abs(self.yvel)
if pos.x < self.xrange[0]:
self.xvel = abs(self.xvel)
if pos.y < self.xrange[0]:
self.yvel = abs(self.yvel)
self.target.setPos(pos.x, pos.y)
def draw(self, renderer):
#glClearColor(.8, .8, .8, 1.0)
#glClear(GL_COLOR_BUFFER_BIT)
# glPixelStoref(GL_UNPACK_ALIGNMENT, 1)
# self.texture.blit( Vec2(10,10), Rect(10,10, 30,30), (app.width, app.height) )
# self.texture.blit( Vec2(50,50), Rect(0,0, 64,64), (app.width, app.height) )
# self.texture.blit( Vec2(150,50), Rect(40,40, 64,64), (app.width, app.height) , blend=True)
#self.texture.blit( Vec2(0.1 * renderer.width,0.1 * renderer.height), Rect(0,0, 30,30), (app.width, app.height) )
# convert to local coords
localBtmLeft = Vec2(self.imagePos.x - self.absRect.x,
self.imagePos.y - self.absRect.y)
localTopRight = Vec2(localBtmLeft.x + self.imageSize[0],
localBtmLeft.y + self.imageSize[1])
# clip to max/min of local display
localBtmLeft = Vec2(max(localBtmLeft.x, 0), max(localBtmLeft.y, 0))
#if mpi.rank == 3:
# print "clip top right y:", localTopRight.y, self.screenRect.height
localTopRight = Vec2(min(localTopRight.x, self.screenRect.width),
min(localTopRight.y, self.screenRect.height))
#if mpi.rank == 3:
# print "clip top right y:", localTopRight.y
blitSize = Vec2(localTopRight.x - localBtmLeft.x,
localTopRight.y - localBtmLeft.y)
# convert clipped local coords back to global coords find the source rect
globalBtmLeft = Vec2(localBtmLeft.x + self.absRect.x,
localBtmLeft.y + self.absRect.y)
globalTopRight = Vec2(localTopRight.x + self.absRect.x,
localTopRight.y + self.absRect.y)
# convert global coords to txtr coords
offset = Vec2(globalBtmLeft.x - self.imagePos.x,
globalBtmLeft.y - self.imagePos.y)
#size = (globalTopRight.x - globalBtmLeft.x, globalTopRight.y - globalBtmLeft.y + 80)
size = (globalTopRight.x - globalBtmLeft.x,
localTopRight.y - localBtmLeft.y)
if size[0] > 0 and size[1] > 0:
#if mpi.rank == 3:
# print "renderer height:", renderer.height
self.texture.blit(localBtmLeft,
Rect(offset.x, offset.y, size[0], size[1]),
(renderer.width, renderer.height))
def getLocalRectTxtrRectBL(self):
# convert to local coords, BL means 0,0 is in the Bottom Left
localBtmLeft = Vec2(self.pos.x - self.absRect.x,
self.pos.y - self.absRect.y)
# print "CALC LOCAL TR1:", localBtmLeft.x, self.getSize()[0], localBtmLeft.y, self.getSize()[1]
localTopRight = Vec2(localBtmLeft.x + self.getSize()[0],
localBtmLeft.y + self.getSize()[1])
# clip to max/min of local display
localBtmLeft = Vec2(max(localBtmLeft.x, 0), max(localBtmLeft.y, 0))
#if mpi.rank == 3:
# print "clip top right y:", localTopRight.y, self.screenRect.height
# print "CALC LOCAL TR:", localTopRight.x, self.screenRect.width, localTopRight.y, self.screenRect.height
localTopRight = Vec2(min(localTopRight.x, self.screenRect.width),
min(localTopRight.y, self.screenRect.height))
#if mpi.rank == 3:
# print "clip top right y:", localTopRight.y
blitSize = Vec2(localTopRight.x - localBtmLeft.x,
localTopRight.y - localBtmLeft.y)
# convert clipped local coords back to global coords find the source rect
globalBtmLeft = Vec2(localBtmLeft.x + self.absRect.x,
localBtmLeft.y + self.absRect.y)
globalTopRight = Vec2(localTopRight.x + self.absRect.x,
localTopRight.y + self.absRect.y)
# convert global coords to txtr coords
offset = Vec2(globalBtmLeft.x - self.pos.x,
globalBtmLeft.y - self.pos.y)
#size = (globalTopRight.x - globalBtmLeft.x, globalTopRight.y - globalBtmLeft.y + 80)
size = (globalTopRight.x - globalBtmLeft.x,
localTopRight.y - localBtmLeft.y)
# print "CALC LOCALRECTSIZE:", localTopRight, localBtmLeft
localRectSize = localTopRight - localBtmLeft
return Rect(localBtmLeft.x, localBtmLeft.y, localRectSize[0],
localRectSize[1]), Rect(offset.x, offset.y, size[0],
size[1])
def draw(self, renderer):
if self.hidden:
return
localRectBL, txtrRectBL = self.getLocalRectTxtrRectBL()
# print "pos:", self.pos, "absRect:", self.absRect
# print "movie LOCAL RECT:", localRectBL, "TXTR RECTBL:", txtrRectBL
localBtmLeftBL = Vec2(
localRectBL.x, localRectBL.y) # probably top and btm are flipped
#localTopRightTL = Vec2(localRect.x, localRect.y)
#localBtmLeftBL = Vec2(localRectBL.x, self.screenRect.height-localRectBL.y)
#localBtmRightBL = Vec2(localRectBL.x, localBtmLeftBL.y + localRectBL.height)
#print "Drawing at:", localBtmLeft
if abs(localRectBL.width) > 0 and abs(localRectBL.height) > 0:
#self.texture.blit( localBtmLeft, Rect(offset.x,offset.y, size[0], size[1]), (renderer.width, renderer.height) , blend=self.blend)
#self.texture.blit( localBtmLeft, localRectBL, (renderer.width, renderer.height) , blend=self.blend)
# use GL coords (bottom left is 0,0)
#print "Setting movie pos to: ", localBtmLeftBL
#self.moviePlayer.setPos(*(txtrBtmLeftBL))
#self.moviePlayer.setPos(10,-340)
# self.moviePlayer.setPos(30,10)
#self.moviePlayer.setPos(*(localBtmLeft - Vec2(txtrRect.x, -txtrRect.y)))
blend = False
# print "movieplayer blit:", localBtmLeftBL, txtrRectBL, (renderer.width, renderer.height) , blend
# Do simple blit for now instead of using easyTexture features.
if self.scale == None:
self.moviePlayer.easyTexture.texture.blit(
localBtmLeftBL,
txtrRectBL, (renderer.width, renderer.height),
blend=blend)
else:
self.moviePlayer.easyTexture.texture.blitWithTexScale(
localBtmLeftBL,
txtrRectBL, (renderer.width, renderer.height),
self.scale,
blend=blend)
"""
def CreateTiledMovieObject(filename,
screenRect,
pos,
absRect,
fullRect,
loadAllMovieTiles=False,
scale=None,
allowFrameSkip=None):
# A tiled movie object has a mostly frozen position on the display (for now)
# Each tile only loads the movie tiles that it will display at the
# movie's current position.
# Find the tiles that are located on the current display, load them, and
# position them.
print "CreateTiledMovieObject"
objectsToGroup = []
# Load info from description
des = ReadTiledMovieDescription(filename)
tileFilenames = os.listdir(filename)
print "tileFilenames:", tileFilenames
# calculate adjustment in case full movie width and height are not
# evenly divisible by tile width and height.
adjustment = (des["tileColsRows"][0] * des["tileRes"][0] -
des["fullRes"][0],
des["tileColsRows"][1] * des["tileRes"][1] -
des["fullRes"][1])
imageBased = False
if IsTiledMovieChunkImageBased(os.path.join(filename, tileFilenames[0])):
imageBased = True
for xIndex in range(des["tileColsRows"][0]):
for yIndex in range(des["tileColsRows"][1]): # TZ==TopZero
yIndexBZ = des["tileColsRows"][1] - 1 - yIndex # BZ==BottomZero
movieTileFilename = ""
for f in tileFilenames:
tileYIndex = yIndexBZ
if imageBased: # The 0th row for our movie and image loaders is different.
tileYIndex = yIndex
if f.startswith("%s_%s." % (xIndex, tileYIndex)
) or f == "%s_%s" % (xIndex, tileYIndex):
movieTileFilename = f
fullMovieTilePath = os.path.join(filename, movieTileFilename)
tileObject = None
# full movie width and height are not evenly divisible by
# tile width and tile height, so adjust offset
xSrcOffset = xIndex * des["tileRes"][0] - adjustment[0]
ySrcOffset = yIndex * des["tileRes"][1] - adjustment[1]
srcWidth, srcHeight = (des["tileRes"][0], des["tileRes"][1])
# adjust a possibly small row or column's offset and size
# might only be necessary for y, since y is flipped (x untested).
#if xIndex == 0:
# xOffset -= adjustment[0]
# width -= adjustment[0]
if scale != None:
xRenderOffset = xIndex * des["tileRes"][0] * scale[
0] - adjustment[0]
yRenderOffset = yIndex * des["tileRes"][1] * scale[
1] - adjustment[1] * scale[1]
# remove the adjustment when yIndex == 0
if yIndex == 0:
yRenderOffset = yIndex * des["tileRes"][1] * scale[1]
srcHeight -= adjustment[1]
renderWidth, renderHeight = srcWidth * scale[
0], srcHeight * scale[1]
else:
# remove the adjustment when yIndex == 0
if yIndex == 0: # FIXME, if we ever use imagebased (slow, movies
# from image files, this may have to be adjusted
# to use tileYIndex and maybe flip signs below.
ySrcOffset += adjustment[1]
srcHeight -= adjustment[1]
xRenderOffset, yRenderOffset = xSrcOffset, ySrcOffset
renderWidth, renderHeight = srcWidth, srcHeight
#xSrcOffset = xIndex * des["tileRes"][0]
#ySrcOffset = yIndex * des["tileRes"][1]
#moviePos = Vec2(pos[0] + xSrcOffset, pos[1] + ySrcOffset)
moviePos = Vec2(pos[0] + xRenderOffset, pos[1] + yRenderOffset)
#movieRect = Rect(pos[0] + xSrcOffset, pos[1] + ySrcOffset, srcWidth, srcHeight)
movieRenderRect = Rect(pos[0] + xRenderOffset,
pos[1] + yRenderOffset, renderWidth,
renderHeight)
# print "Checking colliderects to see if movie tile is on this display tile:", movieRenderRect.colliderect(absRect), movieRenderRect, absRect, movieRenderRect.colliderect(absRect), "indexes:", xIndex, yIndex, "flipped indexes:", xIndex,yIndexBZ
if loadAllMovieTiles or movieRenderRect.colliderect(absRect):
movieTileFilename = ""
for f in tileFilenames:
if f.startswith("%s_%s." % (xIndex, yIndexBZ)
) or f == "%s_%s" % (xIndex, yIndexBZ):
movieTileFilename = f
print "movieTileFilename:", movieTileFilename, len(
movieTileFilename)
if len(movieTileFilename.strip()) > 0:
print "movieTileFilename:", movieTileFilename, len(
movieTileFilename)
print "TiledMovie: loading tile: ", fullMovieTilePath
# obj.pos and obj.size will be used to group movie tiles.
tileObject = CreateMovieObject(
fullMovieTilePath,
screenRect,
moviePos,
absRect,
fullRect,
fps=des["FPS"],
scale=scale,
allowFrameSkip=allowFrameSkip)
else:
print "Warning movieTile not found for:", xIndex, yIndex
if not tileObject:
tileObject = NullTileDisplayObject(
pos=moviePos,
size=(movieRenderRect.width,
movieRenderRect.height)) # Empty object to represent
# objects on other nodes
# and keep object list synced.
objectsToGroup.append(tileObject)
shortName = os.path.basename(filename.strip(os.path.sep))
groupObject = TiledMovieGroupObject(shortName,
objectsToGroup,
duration=des["duration"],
fps=des["FPS"])
groupObject.doChildUpdates = True
returnObj = groupObject
return returnObj
def setPos(self, x, y):
self.imagePos = Vec2(x, y)
def getSize(self):
rect = self.getChildrenRect()
return Vec2(rect.width, rect.height)
def __init__(self):
self.pos = Vec2(0.0,0.0)
def CreateTileImageObject(imageFilename,
screenRect,
pos,
absRect,
fullRect,
blend=True,
scale=None):
print "CreateTileImageObject", imageFilename, "at", pos
imageSize = Image.open(imageFilename).size
maxTextureSize = GetMaxTextureSize()
numTiles = (int(math.ceil(float(imageSize[0]) / maxTextureSize)),
int(math.ceil(float(imageSize[1]) / maxTextureSize)))
print "NUMTILES:", numTiles
if numTiles[0] == 1 and numTiles[1] == 1:
returnObj = glTxtrBox(imageFilename,
screenRect=screenRect,
imagePos=pos,
absRect=absRect,
fullRect=fullRect,
blend=blend,
scale=scale)
else:
objectsToGroup = []
# Create a group object
xSrcOffset = 0
xRenderOffset = 0
subImageWidth = imageSize[0] / numTiles[0]
subImageHeight = imageSize[1] / numTiles[1]
for xIndex in range(numTiles[0]):
ySrcOffset = 0
yRenderOffset = 0
if xIndex == numTiles[0] - 1:
# make sure we don't cut off any
# pixels if it's not evenly divisible.
width = imageSize[0] - xSrcOffset
else:
width = subImageWidth
for yIndex in range(numTiles[1]):
if yIndex == numTiles[1] - 1:
# make sure we don't cut off any
# pixels if it's not evenly divisible.
height = imageSize[1] - ySrcOffset
else:
height = subImageHeight
pos = Vec2(xRenderOffset, -yRenderOffset) # flip y coord
# cropRect is for cropping a subsection out of the source image
cropRect = Rect(xSrcOffset, ySrcOffset, width, height)
print "Loading with crop rect:", cropRect
obj = glTxtrBox(imageFilename,
screenRect=screenRect,
imagePos=pos,
absRect=absRect,
fullRect=fullRect,
blend=blend,
cropRect=cropRect,
scale=scale)
objectsToGroup.append(obj)
ySrcOffset += obj.getSrcSize()[1]
yRenderOffset += obj.getRenderSize()[1]
xSrcOffset += obj.getSrcSize()[0]
xRenderOffset += obj.getRenderSize()[0]
shortName = os.path.basename(imageFilename.strip(os.path.sep))
groupObject = GroupObject(shortName, objectsToGroup)
returnObj = groupObject
print "************* CreateTileDisplayObject finished", returnObj
return returnObj
def CreateTiledMovieObjectFromLayout(layoutFile,
screenRect,
pos,
absRect,
fullRect,
loadAllMovieTiles=False,
scale=None,
allowFrameSkip=None):
print "CreateTiledMovieObjectFromLayout"
objectsToGroup = []
if None == pos:
pos = (0, 0)
layoutEntries = ReadLayout(layoutFile)
for entry in layoutEntries:
moviePos = Vec2(pos[0] + entry.pos[0], pos[1] + entry.pos[1])
movieRenderRect = Rect(moviePos[0], moviePos[1], entry.getWidth(),
entry.getHeight())
tileObject = None
# same code as below func
if loadAllMovieTiles or movieRenderRect.colliderect(absRect):
movieTileFilename = entry.path
fullMovieTilePath = movieTileFilename # for now has absolute paths
# same code as below function
print "movieTileFilename:", movieTileFilename, len(
movieTileFilename)
if len(movieTileFilename.strip()) > 0:
print "movieTileFilename:", movieTileFilename, len(
movieTileFilename)
print "TiledMovie: loading tile: ", fullMovieTilePath
# obj.pos and obj.size will be used to group movie tiles.
fps = fps = entry.getProperty("fps")
tileObject = CreateMovieObject(fullMovieTilePath,
screenRect,
moviePos,
absRect,
fullRect,
fps=fps,
scale=scale,
allowFrameSkip=allowFrameSkip)
else:
print "Warning movieTile not found for:", xIndex, yIndex
if not tileObject:
tileObject = NullTileDisplayObject(
pos=moviePos,
size=(movieRenderRect.width,
movieRenderRect.height)) # Empty object to represent
# objects on other nodes
# and keep object list synced.
objectsToGroup.append(tileObject)
shortName = os.path.basename(layoutFile.strip(os.path.sep))
duration = layoutEntries[0].getProperty("duration")
fps = fps = layoutEntries[0].getProperty("fps")
groupObject = TiledMovieGroupObject(shortName,
objectsToGroup,
duration=duration,
fps=fps)
groupObject.doChildUpdates = True
returnObj = groupObject
return returnObj
def CreateMultiNetGroupTileDisplayStreamObject(addresses,
objDesc,
screenRect,
pos,
absRect,
fullRect,
gridColsRows,
netGridColsRows,
blend=True,
scale=None,
doCenter=True,
plant=False):
#from streamView import StreamView
objectsToGroup = []
if len(addresses) != netGridColsRows[0] * netGridColsRows[1]:
raise Exception(
"Number of addresses should match number of net grid tiles (e.g. use: --streamGroupsColsRows=3x2). currently: %d, %s"
% (len(addresses), netGridColsRows))
#for address in addresses:
gridCols = gridColsRows[0]
gridRows = gridColsRows[1]
bigTileWidth = gridCols * objDesc.streamWidth # 352
bigTileHeight = gridRows * objDesc.streamHeight # 288
if scale != None:
bigTileWidth *= scale[0]
bigTileHeight *= scale[1]
netGridCols = netGridColsRows[0]
netGridRows = netGridColsRows[1]
print "BIGTILESIZE:", bigTileWidth, bigTileHeight
basePos = pos
if doCenter:
centeredPos = Vec2(pos[0], pos[1]) - Vec2(
netGridCols * bigTileWidth / 2, netGridRows * bigTileHeight / 2)
basePos = centeredPos
# for xcol in range(1,2):
print "grid within network stream:", gridCols, gridRows
print "bigTile width,height:", bigTileWidth, bigTileHeight
for xcol in range(netGridCols):
for yrow in range(netGridRows):
streamAddressIndex = netGridCols * yrow + xcol # btm left to right, to top
address = addresses[streamAddressIndex]
yOffset = yrow * bigTileHeight
xOffset = xcol * bigTileWidth
singlePos = Vec2(xOffset + basePos[0], yOffset + basePos[1])
loadTile = True
if plant: # only load if it's on this machine
streamTileRenderRect = Rect(singlePos[0], singlePos[1],
bigTileWidth, bigTileHeight)
# print "Checking colliderects to see if stream tile is on this display tile:", movieRenderRect.colliderect(absRect), movieRenderRect, absRect, movieRenderRect.colliderect(absRect), "indexes:", xIndex, yIndex, "flipped indexes:", xIndex,yIndexBZ
if streamTileRenderRect.colliderect(absRect):
loadTile = True
# Debug
import mpi
print mpi.rank, " Loading stream with rect: ", streamTileRenderRect, "me:", (
absRect.x, absRect.y, absRect.width,
absRect.height), address
else:
import mpi
print mpi.rank, " Not loading stream with rect: ", streamTileRenderRect, "me:", (
absRect.x, absRect.y, absRect.width,
absRect.height), address
loadTile = False
if loadTile:
groupStreamObj = GroupTiledStreamObject(
address,
objDesc,
screenRect=screenRect,
pos=singlePos,
absRect=absRect,
fullRect=fullRect,
blend=blend,
scale=scale,
gridColsRows=gridColsRows,
doCenter=False)
objectsToGroup.append(groupStreamObj)
else:
groupStreamObj = NullTileDisplayObject(
pos=singlePos, size=(bigTileWidth, bigTileHeight)
) # Empty object to represent objects on other nodes and help describe large object on this node .
objectsToGroup.append(groupStreamObj)
shortName = "_".join(addresses)
largeGroupObject = GroupObject(shortName,
objectsToGroup,
doChildUpdates=True)
return largeGroupObject
