def render(self, visibility, playerNum):
#don't try to render an image layer if the texture doesn't even exist
if not self.drawing:
return
coord = self.position
scale = self.scale
rot = self.angle
color = self.color
alignment = self.alignment
valignment = self.valignment
drawing = self.drawing
rect = self.rect
#frameX = self.frameX
#frameY = self.frameY
if bool(eval(self.condition)):
drawImage(drawing,
scale,
coord,
rot,
color,
rect,
alignment=alignment,
valignment=valignment)
def render(self, visibility):
"""
Render the layer.
@param visibility: Floating point visibility factor (1 = opaque, 0 = invisibile)
"""
w, h = self.stage.engine.view.geometry[2:4]
v = 1.0 - visibility ** 2
color = self.color
#coordinates are positioned with (0,0) being in the middle of the screen
coord = [w/2 + self.position[0] * w/2, h/2 - self.position[1] * h/2]
if v > .01:
color = [self.color[0], self.color[1], self.color[2], visibility]
scale = [self.scale[0], -self.scale[1]]
rot = self.angle
self.transforms = [scale, coord, rot, color]
# Blend in all the effects
for effect in self.effects:
effect.apply()
glBlendFunc(self.srcBlending, self.dstBlending)
drawImage(self.drawing, self.transforms[0], self.transforms[1],
self.transforms[2], self.transforms[3])
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)
def render(self, visibility):
"""
Render the layer.
@param visibility: Floating point visibility factor (1 = opaque, 0 = invisibile)
"""
w, h = self.stage.engine.view.geometry[2:4]
v = 1.0 - visibility**2
color = self.color
#coordinates are positioned with (0,0) being in the middle of the screen
coord = [
w / 2 + self.position[0] * w / 2, h / 2 - self.position[1] * h / 2
]
if v > .01:
color = [self.color[0], self.color[1], self.color[2], visibility]
scale = [self.scale[0], -self.scale[1]]
rot = self.angle
self.transforms = [scale, coord, rot, color]
# Blend in all the effects
for effect in self.effects:
effect.apply()
glBlendFunc(self.srcBlending, self.dstBlending)
drawImage(self.drawing, self.transforms[0], self.transforms[1],
self.transforms[2], self.transforms[3])
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)
def render(self, visibility, topMost):
v = 1.0 - ((1 - visibility) ** 2)
# render the background
w, h = self.engine.view.geometry[2:4]
with self.engine.view.orthogonalProjection(normalize=True):
if self.background:
drawImage(self.background, scale=(1.0, -1.0), coord=(w / 2, h / 2), stretched=FULL_SCREEN)
else:
self.engine.fadeScreen(0.4)
self.doneList = []
# render the scroller elements
y = self.offset
glTranslatef(-(1 - v), 0, 0)
for element in self.credits:
hE = element.getHeight()
if y + hE > 0.0 and y < 1.0:
element.render(y)
if y + hE < 0.0:
self.doneList.append(element)
y += hE
if y > 1.0:
break
if self.topLayer:
wFactor = 640.000 / self.topLayer.width1()
hPos = h - ((self.topLayer.height1() * wFactor) * 0.75)
if hPos < h * 0.6:
hPos = h * 0.6
drawImage(self.topLayer, scale=(wFactor, -wFactor), coord=(w / 2, hPos))
def render(self, visibility, topMost):
v = 1.0 - ((1 - visibility) ** 2)
# render the background
w, h = self.engine.view.geometry[2:4]
with self.engine.view.orthogonalProjection(normalize = True):
if self.background:
drawImage(self.background, scale = (1.0,-1.0), coord = (w/2,h/2), stretched = FULL_SCREEN)
else:
self.engine.fadeScreen(.4)
self.doneList = []
# render the scroller elements
y = self.offset
glTranslatef(-(1 - v), 0, 0)
for element in self.credits:
hE = element.getHeight()
if y + hE > 0.0 and y < 1.0:
element.render(y)
if y + hE < 0.0:
self.doneList.append(element)
y += hE
if y > 1.0:
break
if self.topLayer:
wFactor = 640.000/self.topLayer.width1()
hPos = h - ((self.topLayer.height1() * wFactor)*.75)
if hPos < h * .6:
hPos = h * .6
drawImage(self.topLayer, scale = (wFactor,-wFactor), coord = (w/2,hPos))
def renderBackground(self):
#myfingershurt: multiple rotation modes
if self.mode != 2:
if self.rotationMode == 0:
drawImage(self.background, scale = (1.0,-1.0),
coord = (self.wFull/2,self.hFull/2), stretched = FULL_SCREEN)
#myfingershurt:
else:
#MFH - use precalculated scale factors instead
drawImage(self.imgArr[self.arrNum], scale = (1.0,-1.0),
coord = (self.wFull/2,self.hFull/2), stretched = FULL_SCREEN)
def renderSetlist(self, visibility, topMost):
w, h = self.engine.view.geometry[2:4]
#render the background (including the header and footer)
if self.setlistStyle == 1 and self.img_list_bg:
drawImage(self.img_list_bg, scale = (1.0, -1.0), coord = (w/2,h/2), stretched = KEEP_ASPECT | FIT_WIDTH)
elif self.img_list_bg:
drawImage(self.img_list_bg, scale = (1.0, -1.0), coord = (w/2,h/2), stretched = FULL_SCREEN)
if self.img_list_head:
o = 0
if self.setlistStyle == 1:
o = self.yPos
drawImage(self.img_list_head, scale = (1.0, -1.0), coord = (w/2,h+o), stretched = KEEP_ASPECT | FIT_WIDTH, fit = TOP)
if self.setlistStyle in [0, 2] and self.img_list_foot:
drawImage(self.img_list_foot, scale = (1.0, -1.0), coord = (w/2,0), stretched = FULL_SCREEN, fit = BOTTOM)
elif self.img_list_foot:
maxPos = max(len(self.items) - self.itemsPerPage, 0)
o = (-self.itemSize[1]*h*maxPos) + self.yPos
drawImage(self.img_list_foot, scale = (1.0, -1.0), coord = (w/2,o), stretched = KEEP_ASPECT | FIT_WIDTH, fit = BOTTOM)
self.engine.theme.setlist.renderHeader(self)
#render the artwork
self.engine.theme.setlist.renderAlbumArt(self)
#render the item list itself
ns = 0 #the n value of the selectedItem
if self.setlistStyle == 2:
for n, i in enumerate(range(self.pos-self.itemsPerPage+self.followItemPos, self.pos+self.itemsPerPage)):
if i == self.selectedIndex:
ns = n
continue
i = i%len(self.items)
self.engine.theme.setlist.renderUnselectedItem(self, i, n)
else:
for n, i in enumerate(range(self.pos, self.pos+self.itemsPerPage)):
if i >= len(self.items):
break
if i == self.selectedIndex:
ns = n
continue
if isinstance(self.items[i], Song.BlankSpaceInfo):
continue
self.engine.theme.setlist.renderUnselectedItem(self, i, n)
self.engine.theme.setlist.renderSelectedItem(self, ns) #we render this last to allow overlapping effects.
#render the additional information for the selected item
self.engine.theme.setlist.renderSelectedInfo(self)
#render the foreground stuff last
self.engine.theme.setlist.renderForeground(self)
def render(self, visibility, topMost):
if not visibility:
self.active = False
return
if not self.active:
self.getPlayers()
self.active = True
self.done = True
if self.playerNum >= self.maxPlayers:
return
with self.engine.view.orthogonalProjection(normalize = True):
w, h = self.fullView
if self.img_background:
drawImage(self.img_background, scale = (1.0, -1.0), coord = (w/2,h/2), stretched = FULL_SCREEN)
self.engine.theme.themeLobby.renderPanels(self)
def renderBackground(self):
#myfingershurt: multiple rotation modes
if self.mode != 2:
if self.rotationMode == 0:
drawImage(self.background,
scale=(1.0, -1.0),
coord=(self.wFull / 2, self.hFull / 2),
stretched=FULL_SCREEN)
#myfingershurt:
else:
#MFH - use precalculated scale factors instead
drawImage(self.imgArr[self.arrNum],
scale=(1.0, -1.0),
coord=(self.wFull / 2, self.hFull / 2),
stretched=FULL_SCREEN)
def render(self, visibility, playerNum):
#don't try to render image layer if the texture doesn't even exist
if not self.drawing:
return
coord = self.position
scale = self.scale
rot = self.angle
color = self.color
alignment = self.alignment
ratio = self.ratio
if bool(eval(self.condition)):
degrees = int(360*ratio) - (int(360*ratio) % 5)
drawImage(self.drawnOverlays[degrees], scale,
coord, rot, color, alignment = alignment)
def render(self, visibility, topMost):
try:
font = self.engine.data.fontDict[self.engine.theme.characterCreateOptionFont]
helpFont = self.engine.data.fontDict[self.engine.theme.characterCreateHelpFont]
except KeyError:
font = self.engine.data.font
helpFont = self.engine.data.loadingFont
with self.engine.view.orthogonalProjection(normalize = True):
v = ((1 - visibility) **2)
w, h = self.fullView
if self.img_creator:
drawImage(self.img_creator, scale = (1.0, -1.0), coord = (w/2,h/2), stretched = FULL_SCREEN)
helpFont.render(_("Player %d") % (self.playerNum + 1), pos = (.5, .1), scale = self.engine.theme.characterCreateScale, align = 1)
for i, option in enumerate(self.options):
r, g, b = self.engine.theme.characterCreateHelpColor
glColor3f(r, g, b)
cursor = ""
if self.selected == i:
wText, hText = helpFont.getStringSize(option[1], scale = self.engine.theme.characterCreateScale)
helpFont.render(option[1], (self.engine.theme.characterCreateHelpX-(wText/2), self.engine.theme.characterCreateHelpY-hText), scale = self.engine.theme.characterCreateHelpScale)
r, g, b = self.engine.theme.characterCreateSelectColor
glColor3f(r, g, b)
cursor = self.cursor
else:
r, g, b = self.engine.theme.characterCreateFontColor
glColor3f(r, g, b)
wText, hText = font.getStringSize(option[0], scale = self.engine.theme.characterCreateScale)
font.render(option[0], (self.engine.theme.characterCreateX, self.engine.theme.characterCreateY+self.engine.theme.characterCreateSpace*i), scale = self.engine.theme.characterCreateScale)
if self.active and self.selected == i:
self.engine.theme.setSelectedColor(1-v)
if i == 0 or i > 6:
wText, hText = font.getStringSize(self.choices[i], scale = self.engine.theme.characterCreateScale)
font.render(self.choices[i]+cursor, (self.engine.theme.characterCreateOptionX-wText, self.engine.theme.characterCreateY+self.engine.theme.characterCreateSpace*i), scale = self.engine.theme.characterCreateScale)
else:
if i == self.selected:
str = "< %s >" % self.values[i-1][self.choices[i]]
else:
str = self.values[i-1][self.choices[i]]
wText, hText = font.getStringSize(str, scale = self.engine.theme.characterCreateScale)
font.render(str, (self.engine.theme.characterCreateOptionX-wText, self.engine.theme.characterCreateY+self.engine.theme.characterCreateSpace*i), scale = self.engine.theme.characterCreateScale)
if self.img_creator_top:
drawImage(self.img_creator_top, scale = (1.0, -1.0), coord = (w/2,h/2), stretched = FULL_SCREEN)
def render(self, visibility, playerNum):
#don't try to render image layer if the texture doesn't even exist
if not self.drawing:
return
coord = self.position
scale = self.scale
rot = self.angle
color = self.color
alignment = self.alignment
ratio = self.ratio
if bool(eval(self.condition)):
degrees = int(360 * ratio) - (int(360 * ratio) % 5)
drawImage(self.drawnOverlays[degrees],
scale,
coord,
rot,
color,
alignment=alignment)
def render(self, visibility, playerNum):
#don't try to render an image layer if the texture doesn't even exist
if not self.drawing:
return
coord = self.position
scale = self.scale
rot = self.angle
color = self.color
alignment = self.alignment
valignment = self.valignment
drawing = self.drawing
rect = self.rect
#frameX = self.frameX
#frameY = self.frameY
if bool(eval(self.condition)):
drawImage(drawing, scale, coord, rot, color, rect,
alignment = alignment, valignment = valignment)
def render(self, visibility, topMost):
if self.gameStarted:
return
if self.items == []:
return
Scene.render(self, visibility, topMost)
with self.engine.view.orthogonalProjection(normalize = True):
self.engine.view.setViewport(1,0)
w, h = self.engine.view.geometry[2:4]
if self.img_background:
drawImage(self.img_background, scale = (1.0, -1.0), coord = (w/2,h/2), stretched = FULL_SCREEN)
if self.mode == 0:
self.renderSetlist(visibility, topMost)
if self.moreInfoTime > 0:
self.engine.theme.setlist.renderMoreInfo(self)
if self.miniLobbyTime > 0:
self.engine.theme.setlist.renderMiniLobby(self)
# I am unsure how I want to handle this for now. Perhaps as dialogs, perhaps in SCS.
elif self.mode == 1:
self.renderSpeedSelect(visibility, topMost)
elif self.mode == 2:
self.renderTimeSelect(visibility, topMost)
def drawStarScore(self, screenwidth, screenheight, xpos, ypos, stars, scale = None, horiz_spacing = 1.2, space = 1.0, hqStar = False, align = LEFT):
minScale = 0.02
w = screenwidth
h = screenheight
if not scale:
scale = minScale
elif scale < minScale:
scale = minScale
if self.data.fcStars and stars == 7:
star = self.data.starFC
else:
star = self.data.starPerfect
wide = scale * horiz_spacing
if align == CENTER: #center - akedrou (simplifying the alignment...)
xpos -= (2 * wide)
elif align == RIGHT: #right
xpos -= (4 * wide)
if stars > 5:
for j in range(5):
if self.data.maskStars:
if self.data.theme == 2:
drawImage(star, scale = (scale,-scale), coord = (w*(xpos+wide*j)*space**4,h*ypos), color = (1, 1, 0, 1), stretched = KEEP_ASPECT | FIT_WIDTH)
else:
drawImage(star, scale = (scale,-scale), coord = (w*(xpos+wide*j)*space**4,h*ypos), color = (0, 1, 0, 1), stretched = KEEP_ASPECT | FIT_WIDTH)
else:
drawImage(star, scale = (scale,-scale), coord = (w*(xpos+wide*j)*space**4,h*ypos), stretched = KEEP_ASPECT | FIT_WIDTH)
else:
for j in range(5):
if j < stars:
if hqStar:
star = self.data.star4
else:
star = self.data.star2
else:
if hqStar:
star = self.data.star3
else:
star = self.data.star1
drawImage(star, scale = (scale,-scale), coord = (w*(xpos+wide*j)*space**4,h*ypos), stretched = KEEP_ASPECT | FIT_WIDTH)
def render(self, visibility, topMost):
# MFH - display version in any menu:
if not visibility:
self.active = False
return
self.active = True
if self.graphicMenu and self.menuBackground:
self.engine.graphicMenuShown = True
else:
self.engine.graphicMenuShown = False
with self.engine.view.orthogonalProjection(normalize=True):
v = (1 - visibility) ** 2
# Default to this font if none was specified
font = self.font
tipFont = self.tipFont
if self.fadeScreen:
self.engine.fadeScreen(v)
wS, hS = self.engine.view.geometry[2:4]
if self.graphicMenu and self.menuBackground:
# volshebnyi - better menu scaling
drawImage(self.menuBackground, scale=(1.0, -1.0), coord=(wS / 2, hS / 2), stretched=FULL_SCREEN)
else:
glEnable(GL_BLEND)
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)
glEnable(GL_COLOR_MATERIAL)
n = len(self.choices)
x, y = self.pos
for i, choice in enumerate(self.choices[self.viewOffset : self.viewOffset + self.viewSize]):
if self.graphicMenu:
if self.currentIndex == i:
xpos = (0.5, 1)
else:
xpos = (0, 0.5)
ypos = float(i + self.viewOffset)
drawImage(
self.menuText,
scale=(0.5 * self.menuScale, (-1.0 / n * self.menuScale)),
coord=(wS * self.menux, (hS * self.menuy) - (hS * self.vSpace) * i),
rect=(xpos[0], xpos[1], ypos / n, (ypos + 1.0) / n),
stretched=KEEP_ASPECT | FIT_WIDTH,
)
else:
text = choice.getText(i + self.viewOffset == self.currentIndex)
glPushMatrix()
glRotate(v * 45, 0, 0, 1)
scale = self.engine.theme.settingsmenuScale
w, h = font.getStringSize(" ", scale=scale)
# Draw arrows if scrolling is needed to see all items
if i == 0 and self.viewOffset > 0:
self.engine.theme.setBaseColor((1 - v) * max(0.1, 1 - (1.0 / self.viewOffset) / 3))
glPushMatrix()
glTranslatef(x - v / 4 - w * 2, y + h / 2, 0)
self.renderTriangle(up=(0, -1), s=0.015)
glPopMatrix()
elif i == self.viewSize - 1 and self.viewOffset + self.viewSize < n:
self.engine.theme.setBaseColor(
(1 - v) * max(0.1, 1 - (1.0 / (n - self.viewOffset - self.viewSize)) / 3)
)
glPushMatrix()
glTranslatef(x - v / 4 - w * 2, y + h / 2, 0)
self.renderTriangle(up=(0, 1), s=0.015)
glPopMatrix()
if i + self.viewOffset == self.currentIndex:
if choice.tipText and self.showTips:
if self.tipColor:
c1, c2, c3 = self.tipColor
glColor3f(c1, c2, c3)
elif self.textColor:
c1, c2, c3 = self.textColor
glColor3f(c1, c2, c3)
else:
self.engine.theme.setBaseColor(1 - v)
tipScale = self.tipScale
if self.tipScroll > -(self.tipSize) and self.tipScroll < 1:
tipFont.render(choice.tipText, (self.tipScroll, self.tipY), scale=tipScale)
if self.tipScrollMode == 0:
if self.tipScrollB > -(self.tipSize) and self.tipScrollB < 1:
tipFont.render(choice.tipText, (self.tipScrollB, self.tipY), scale=tipScale)
a = (math.sin(self.time) * 0.15 + 0.75) * (1 - v * 2)
self.engine.theme.setSelectedColor(a)
a *= -0.005
glTranslatef(a, a, a)
else:
self.engine.theme.setBaseColor(1 - v)
# MFH - settable color through Menu constructor
if i + self.viewOffset == self.currentIndex and self.selectedColor:
c1, c2, c3 = self.selectedColor
glColor3f(c1, c2, c3)
elif self.textColor:
c1, c2, c3 = self.textColor
glColor3f(c1, c2, c3)
# MFH - now to catch " >" main menu options and blank them:
if text == " >":
text = ""
if (
self.engine.data.submenuSelectFound
and len(text) > 0
and not self.mainMenu
and self.useSelectedBox
):
Tw, Th = font.getStringSize(text, scale)
boxXOffset = (x + (Tw / 2)) * wS
boxYOffset = (1.0 - (y * 4.0 / 3.0) - (Th * 1.2 / 2)) * hS
drawImage(
self.engine.data.submenuSelect,
scale=(tempWScale, tempHScale), # FIXME
coord=(boxXOffset, boxYOffset),
)
font.render(text, (x - v / 4, y), scale=scale)
v *= 2
if (
self.theme == 1 and self.font == self.engine.data.pauseFont
): # evilynux - Ugly workaround for Gh3
y += h * 0.70 # Worldrave - Changed Pause menu spacing back to .70 from .65 for now.
else:
y += h
glPopMatrix()
def render(self, visibility, topMost):
#MFH - display version in any menu:
if not visibility:
self.active = False
return
self.active = True
if self.graphicMenu and self.menuBackground:
self.engine.graphicMenuShown = True
else:
self.engine.graphicMenuShown = False
with self.engine.view.orthogonalProjection(normalize = True):
v = (1 - visibility) ** 2
# Default to this font if none was specified
font = self.font
tipFont = self.tipFont
if self.fadeScreen:
self.engine.fadeScreen(v)
wS, hS = self.engine.view.geometry[2:4]
if self.graphicMenu and self.menuBackground:
#volshebnyi - better menu scaling
drawImage(self.menuBackground, scale = (1.0,-1.0), coord = (wS/2,hS/2), stretched = FULL_SCREEN)
else:
glEnable(GL_BLEND)
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)
glEnable(GL_COLOR_MATERIAL)
n = len(self.choices)
x, y = self.pos
for i, choice in enumerate(self.choices[self.viewOffset:self.viewOffset + self.viewSize]):
if self.graphicMenu:
if self.currentIndex == i:
xpos = (.5,1)
else:
xpos = (0,.5)
ypos = float(i+self.viewOffset)
drawImage(self.menuText, scale = (.5*self.menuScale,(-1.0/n*self.menuScale)),
coord = (wS*self.menux,(hS*self.menuy)-(hS*self.vSpace)*i),
rect = (xpos[0],xpos[1],ypos/n,(ypos+1.0)/n), stretched = KEEP_ASPECT | FIT_WIDTH)
else:
text = choice.getText(i + self.viewOffset == self.currentIndex)
glPushMatrix()
glRotate(v * 45, 0, 0, 1)
scale = self.engine.theme.settingsmenuScale
w, h = font.getStringSize(" ", scale = scale)
# Draw arrows if scrolling is needed to see all items
if i == 0 and self.viewOffset > 0:
self.engine.theme.setBaseColor((1 - v) * max(.1, 1 - (1.0 / self.viewOffset) / 3))
glPushMatrix()
glTranslatef(x - v / 4 - w * 2, y + h / 2, 0)
self.renderTriangle(up = (0, -1), s = .015)
glPopMatrix()
elif i == self.viewSize - 1 and self.viewOffset + self.viewSize < n:
self.engine.theme.setBaseColor((1 - v) * max(.1, 1 - (1.0 / (n - self.viewOffset - self.viewSize)) / 3))
glPushMatrix()
glTranslatef(x - v / 4 - w * 2, y + h / 2, 0)
self.renderTriangle(up = (0, 1), s = .015)
glPopMatrix()
if i + self.viewOffset == self.currentIndex:
if choice.tipText and self.showTips:
if self.tipColor:
c1, c2, c3 = self.tipColor
glColor3f(c1,c2,c3)
elif self.textColor:
c1, c2, c3 = self.textColor
glColor3f(c1,c2,c3)
else:
self.engine.theme.setBaseColor(1-v)
tipScale = self.tipScale
if self.tipScroll > -(self.tipSize) and self.tipScroll < 1:
tipFont.render(choice.tipText, (self.tipScroll, self.tipY), scale = tipScale)
if self.tipScrollMode == 0:
if self.tipScrollB > -(self.tipSize) and self.tipScrollB < 1:
tipFont.render(choice.tipText, (self.tipScrollB, self.tipY), scale = tipScale)
a = (math.sin(self.time) * .15 + .75) * (1 - v * 2)
self.engine.theme.setSelectedColor(a)
a *= -.005
glTranslatef(a, a, a)
else:
self.engine.theme.setBaseColor(1 - v)
#MFH - settable color through Menu constructor
if i + self.viewOffset == self.currentIndex and self.selectedColor:
c1,c2,c3 = self.selectedColor
glColor3f(c1,c2,c3)
elif self.textColor:
c1,c2,c3 = self.textColor
glColor3f(c1,c2,c3)
#MFH - now to catch " >" main menu options and blank them:
if text == " >":
text = ""
if self.engine.data.submenuSelectFound and len(text) > 0 and not self.mainMenu and self.useSelectedBox:
Tw, Th = font.getStringSize(text,scale)
boxXOffset = (x + (Tw/2))*wS
boxYOffset = (1.0 - (y*4.0/3.0) - (Th*1.2/2))*hS
drawImage(self.engine.data.submenuSelect,
scale = (tempWScale,tempHScale), #FIXME
coord = (boxXOffset,boxYOffset))
font.render(text, (x - v / 4, y), scale = scale)
v *= 2
if self.theme == 1 and self.font == self.engine.data.pauseFont: # evilynux - Ugly workaround for Gh3
y += h*.70 #Worldrave - Changed Pause menu spacing back to .70 from .65 for now.
else:
y += h
glPopMatrix()
def render(self, offset):
offset = (offset * 4.0) / 3.0 # stump: get it back into alignment...
w, h = self.engine.view.geometry[2:4]
drawImage(
self.drawing, scale=(1, -1), coord=(0.5 * w, h - (0.5 * self.height + offset) * h * float(w) / float(h))
)
def render(self, visibility, topMost):
self.engine.view.setViewport(1,0)
self.visibility = visibility
if self.rbmenu:
v = 1.0 - ((1 - visibility) ** 2)
else:
v = 1
if v == 1:
self.engine.view.transitionTime = 1
if self.menu.active and not self.active:
self.active = True
w, h, = self.engine.view.geometry[2:4]
if self.active:
if self.engine.view.topLayer() is not None:
if self.optionsBG:
drawImage(self.optionsBG, (self.opt_bkg_size[2],-self.opt_bkg_size[3]), (w*self.opt_bkg_size[0],h*self.opt_bkg_size[1]), stretched = FULL_SCREEN)
if self.optionsPanel:
drawImage(self.optionsPanel, (1.0,-1.0), (w/2, h/2), stretched = FULL_SCREEN)
else:
drawImage(self.engine.data.loadingImage, (1.0,-1.0), (w/2, h/2), stretched = FULL_SCREEN)
if self.menu.active and self.engine.cmdPlay == 0:
if self.background != None:
#MFH - auto-scaling
drawImage(self.background, (1.0,-1.0), (w/2, h/2), stretched = FULL_SCREEN)
if self.BGText:
numOfChoices = len(self.menu.choices)
for i in range(numOfChoices):
#Item selected
if self.menu.currentIndex == i:
xpos = (.5,1)
#Item unselected
else:
xpos = (0,.5)
#which item?
ypos = (1/float(numOfChoices) * i, 1/float(numOfChoices) * (i + 1))
textcoord = (w*self.menux,h*self.menuy-(h*self.main_menu_vspacing)*i)
sFactor = self.main_menu_scale
wFactor = xpos[1] - xpos[0]
hFactor = ypos[1] - ypos[0]
drawImage(self.BGText,
scale = (wFactor*sFactor,-hFactor*sFactor),
coord = textcoord,
rect = (xpos[0],xpos[1],ypos[0],ypos[1]), stretched = KEEP_ASPECT | FIT_WIDTH)
#racer: added version tag to main menu:
if self.version != None:
wfactor = (w * self.engine.theme.versiontagScale) / self.version.width1()
drawImage(self.version,( wfactor, -wfactor ),(w*self.engine.theme.versiontagposX, h*self.engine.theme.versiontagposY)) #worldrave - Added theme settings to control X+Y positions of versiontag.
def render(self, visibility, topMost):
self.engine.view.setViewport(1, 0)
self.visibility = visibility
if self.rbmenu:
v = 1.0 - ((1 - visibility)**2)
else:
v = 1
if v == 1:
self.engine.view.transitionTime = 1
if self.menu.active and not self.active:
self.active = True
w, h, = self.engine.view.geometry[2:4]
if self.active:
if self.engine.view.topLayer() is not None:
if self.optionsBG:
drawImage(
self.optionsBG,
(self.opt_bkg_size[2], -self.opt_bkg_size[3]),
(w * self.opt_bkg_size[0], h * self.opt_bkg_size[1]),
stretched=FULL_SCREEN)
if self.optionsPanel:
drawImage(self.optionsPanel, (1.0, -1.0), (w / 2, h / 2),
stretched=FULL_SCREEN)
else:
drawImage(self.engine.data.loadingImage, (1.0, -1.0),
(w / 2, h / 2),
stretched=FULL_SCREEN)
if self.menu.active and self.engine.cmdPlay == 0:
if self.background != None:
#MFH - auto-scaling
drawImage(self.background, (1.0, -1.0), (w / 2, h / 2),
stretched=FULL_SCREEN)
if self.BGText:
numOfChoices = len(self.menu.choices)
for i in range(numOfChoices):
#Item selected
if self.menu.currentIndex == i:
xpos = (.5, 1)
#Item unselected
else:
xpos = (0, .5)
#which item?
ypos = (1 / float(numOfChoices) * i,
1 / float(numOfChoices) * (i + 1))
textcoord = (w * self.menux, h * self.menuy -
(h * self.main_menu_vspacing) * i)
sFactor = self.main_menu_scale
wFactor = xpos[1] - xpos[0]
hFactor = ypos[1] - ypos[0]
drawImage(self.BGText,
scale=(wFactor * sFactor, -hFactor * sFactor),
coord=textcoord,
rect=(xpos[0], xpos[1], ypos[0], ypos[1]),
stretched=KEEP_ASPECT | FIT_WIDTH)
#racer: added version tag to main menu:
if self.version != None:
wfactor = (
w * self.engine.theme.versiontagScale) / self.version.width1()
drawImage(
self.version, (wfactor, -wfactor),
(w * self.engine.theme.versiontagposX,
h * self.engine.theme.versiontagposY)
) #worldrave - Added theme settings to control X+Y positions of versiontag.
def render(self, offset):
offset = (offset*4.0)/3.0 #stump: get it back into alignment...
w, h = self.engine.view.geometry[2:4]
drawImage(self.drawing, scale = (1, -1),
coord = (.5 * w, h - (.5 * self.height + offset) * h * float(w) / float(h)))
