class Transitions:
# These may be reassigned before the fade or iris transitions are
# actually invoked to change the models that will be used.
IrisModelName = "models/misc/iris"
FadeModelName = "models/misc/fade"
def __init__(self, loader, model=None, scale=3.0, pos=Vec3(0, 0, 0)):
self.transitionIval = None
self.letterboxIval = None
self.iris = None
self.fade = None
self.letterbox = None
self.fadeModel = model
self.imagePos = pos
if model:
self.alphaOff = Vec4(1, 1, 1, 0)
self.alphaOn = Vec4(1, 1, 1, 1)
model.setTransparency(1)
self.lerpFunc = LerpColorScaleInterval
else:
self.alphaOff = Vec4(0, 0, 0, 0)
self.alphaOn = Vec4(0, 0, 0, 1)
self.lerpFunc = LerpColorInterval
self.irisTaskName = "irisTask"
self.fadeTaskName = "fadeTask"
self.letterboxTaskName = "letterboxTask"
def __del__(self):
if self.fadeModel:
self.fadeModel.removeNode()
self.fadeModel = None
##################################################
# Fade
##################################################
# We can set a custom model for the fade before using it for the first time
def setFadeModel(self, model, scale=1.0):
self.fadeModel = model
# We have to change some default parameters for a custom fadeModel
self.alphaOn = Vec4(1, 1, 1, 1)
# Reload fade if its already been created
if self.fade:
self.fade.destroy()
self.fade = None
self.loadFade()
def loadFade(self):
if self.fade is None:
# We create a DirectFrame for the fade polygon, instead of
# simply loading the polygon model and using it directly,
# so that it will also obscure mouse events for objects
# positioned behind it.
self.fade = DirectFrame(
parent=hidden,
guiId='fade',
relief=None,
image=self.fadeModel,
image_scale=(4, 2, 2),
state=DGG.NORMAL,
)
if not self.fadeModel:
# No fade model was given, so we make this the fade model.
self.fade["relief"] = DGG.FLAT
self.fade["frameSize"] = (-2, 2, -1, 1)
self.fade["frameColor"] = (0, 0, 0, 1)
self.fade.setTransparency(TransparencyAttrib.MAlpha)
self.fade.setBin('unsorted', 0)
self.fade.setColor(0, 0, 0, 0)
def getFadeInIval(self, t=0.5, finishIval=None):
"""
Returns an interval without starting it. This is particularly useful in
cutscenes, so when the cutsceneIval is escaped out of we can finish the fade immediately
"""
#self.noTransitions() masad: this creates a one frame pop, is it necessary?
self.loadFade()
transitionIval = Sequence(
Func(self.fade.reparentTo, aspect2d, DGG.FADE_SORT_INDEX),
Func(self.fade.showThrough
), # in case aspect2d is hidden for some reason
self.lerpFunc(
self.fade,
t,
self.alphaOff,
# self.alphaOn,
),
Func(self.fade.detachNode),
name=self.fadeTaskName,
)
if finishIval:
transitionIval.append(finishIval)
return transitionIval
def getFadeOutIval(self, t=0.5, finishIval=None):
"""
Create a sequence that lerps the color out, then
parents the fade to hidden
"""
self.noTransitions()
self.loadFade()
transitionIval = Sequence(
Func(self.fade.reparentTo, aspect2d, DGG.FADE_SORT_INDEX),
Func(self.fade.showThrough
), # in case aspect2d is hidden for some reason
self.lerpFunc(
self.fade,
t,
self.alphaOn,
# self.alphaOff,
),
name=self.fadeTaskName,
)
if finishIval:
transitionIval.append(finishIval)
return transitionIval
def fadeIn(self, t=0.5, finishIval=None):
"""
Play a fade in transition over t seconds.
Places a polygon on the aspect2d plane then lerps the color
from black to transparent. When the color lerp is finished, it
parents the fade polygon to hidden.
"""
gsg = base.win.getGsg()
if gsg:
# If we're about to fade in from black, go ahead and
# preload all the textures etc.
base.graphicsEngine.renderFrame()
render.prepareScene(gsg)
render2d.prepareScene(gsg)
if (t == 0):
# Fade in immediately with no lerp
#print "transitiosn: fadeIn 0.0"
self.noTransitions()
self.loadFade()
self.fade.detachNode()
else:
# Create a sequence that lerps the color out, then
# parents the fade to hidden
self.transitionIval = self.getFadeInIval(t, finishIval)
self.transitionIval.start()
def fadeOut(self, t=0.5, finishIval=None):
"""
Play a fade out transition over t seconds.
Places a polygon on the aspect2d plane then lerps the color
from transparent to full black. When the color lerp is finished,
it leaves the fade polygon covering the aspect2d plane until you
fadeIn or call noFade.
lerp
"""
if (t == 0):
# Fade out immediately with no lerp
self.noTransitions()
self.loadFade()
self.fade.reparentTo(aspect2d, DGG.FADE_SORT_INDEX)
self.fade.setColor(self.alphaOn)
elif ConfigVariableBool('no-loading-screen', False):
if finishIval:
self.transitionIval = finishIval
self.transitionIval.start()
else:
# Create a sequence that lerps the color out, then
# parents the fade to hidden
self.transitionIval = self.getFadeOutIval(t, finishIval)
self.transitionIval.start()
def fadeOutActive(self):
return self.fade and self.fade.getColor()[3] > 0
def fadeScreen(self, alpha=0.5):
"""
Put a semitransparent screen over the camera plane
to darken out the world. Useful for drawing attention to
a dialog box for instance
"""
#print "transitiosn: fadeScreen"
self.noTransitions()
self.loadFade()
self.fade.reparentTo(aspect2d, DGG.FADE_SORT_INDEX)
self.fade.setColor(self.alphaOn[0], self.alphaOn[1], self.alphaOn[2],
alpha)
def fadeScreenColor(self, color):
"""
Put a semitransparent screen over the camera plane
to darken out the world. Useful for drawing attention to
a dialog box for instance
"""
#print "transitiosn: fadeScreenColor"
self.noTransitions()
self.loadFade()
self.fade.reparentTo(aspect2d, DGG.FADE_SORT_INDEX)
self.fade.setColor(color)
def noFade(self):
"""
Removes any current fade tasks and parents the fade polygon away
"""
#print "transitiosn: noFade"
if self.transitionIval:
self.transitionIval.pause()
self.transitionIval = None
if self.fade:
# Make sure to reset the color, since fadeOutActive() is looking at it
self.fade.setColor(self.alphaOff)
self.fade.detachNode()
def setFadeColor(self, r, g, b):
self.alphaOn.set(r, g, b, 1)
self.alphaOff.set(r, g, b, 0)
##################################################
# Iris
##################################################
def loadIris(self):
if self.iris == None:
self.iris = loader.loadModel(self.IrisModelName)
self.iris.setPos(0, 0, 0)
def irisIn(self, t=0.5, finishIval=None):
"""
Play an iris in transition over t seconds.
Places a polygon on the aspect2d plane then lerps the scale
of the iris polygon up so it looks like we iris in. When the
scale lerp is finished, it parents the iris polygon to hidden.
"""
self.noTransitions()
self.loadIris()
if (t == 0):
self.iris.detachNode()
else:
self.iris.reparentTo(aspect2d, DGG.FADE_SORT_INDEX)
self.transitionIval = Sequence(
LerpScaleInterval(self.iris, t, scale=0.18, startScale=0.01),
Func(self.iris.detachNode),
name=self.irisTaskName,
)
if finishIval:
self.transitionIval.append(finishIval)
self.transitionIval.start()
def irisOut(self, t=0.5, finishIval=None):
"""
Play an iris out transition over t seconds.
Places a polygon on the aspect2d plane then lerps the scale
of the iris down so it looks like we iris out. When the scale
lerp is finished, it leaves the iris polygon covering the
aspect2d plane until you irisIn or call noIris.
"""
self.noTransitions()
self.loadIris()
self.loadFade() # we need this to cover up the hole.
if (t == 0):
self.iris.detachNode()
self.fadeOut(0)
else:
self.iris.reparentTo(aspect2d, DGG.FADE_SORT_INDEX)
self.transitionIval = Sequence(
LerpScaleInterval(self.iris, t, scale=0.01, startScale=0.18),
Func(self.iris.detachNode),
# Use the fade to cover up the hole that the iris would leave
Func(self.fadeOut, 0),
name=self.irisTaskName,
)
if finishIval:
self.transitionIval.append(finishIval)
self.transitionIval.start()
def noIris(self):
"""
Removes any current iris tasks and parents the iris polygon away
"""
if self.transitionIval:
self.transitionIval.pause()
self.transitionIval = None
if self.iris != None:
self.iris.detachNode()
# Actually we need to remove the fade too,
# because the iris effect uses it.
self.noFade()
def noTransitions(self):
"""
This call should immediately remove any and all transitions running
"""
self.noFade()
self.noIris()
# Letterbox is not really a transition, it is a screen overlay
# self.noLetterbox()
##################################################
# Letterbox
##################################################
def loadLetterbox(self):
if not self.letterbox:
# We create a DirectFrame for the fade polygon, instead of
# simply loading the polygon model and using it directly,
# so that it will also obscure mouse events for objects
# positioned behind it.
self.letterbox = NodePath("letterbox")
# Allow fade in and out of the bars
self.letterbox.setTransparency(1)
# Allow DirectLabels to be parented to the letterbox sensibly
self.letterbox.setBin('unsorted', 0)
# Allow a custom look to the letterbox graphic.
# TODO: This model isn't available everywhere. We should
# pass it in as a parameter.
button = loader.loadModel('models/gui/toplevel_gui',
okMissing=True)
barImage = None
if button:
barImage = button.find('**/generic_button')
self.letterboxTop = DirectFrame(
parent=self.letterbox,
guiId='letterboxTop',
relief=DGG.FLAT,
state=DGG.NORMAL,
frameColor=(0, 0, 0, 1),
borderWidth=(0, 0),
frameSize=(-1, 1, 0, 0.2),
pos=(0, 0, 0.8),
image=barImage,
image_scale=(2.25, 1, .5),
image_pos=(0, 0, .1),
image_color=(0.3, 0.3, 0.3, 1),
sortOrder=0,
)
self.letterboxBottom = DirectFrame(
parent=self.letterbox,
guiId='letterboxBottom',
relief=DGG.FLAT,
state=DGG.NORMAL,
frameColor=(0, 0, 0, 1),
borderWidth=(0, 0),
frameSize=(-1, 1, 0, 0.2),
pos=(0, 0, -1),
image=barImage,
image_scale=(2.25, 1, .5),
image_pos=(0, 0, .1),
image_color=(0.3, 0.3, 0.3, 1),
sortOrder=0,
)
# masad: always place these at the bottom of render
self.letterboxTop.setBin('sorted', 0)
self.letterboxBottom.setBin('sorted', 0)
self.letterbox.reparentTo(render2d, -1)
self.letterboxOff(0)
def noLetterbox(self):
"""
Removes any current letterbox tasks and parents the letterbox polygon away
"""
if self.letterboxIval:
self.letterboxIval.pause()
self.letterboxIval = None
if self.letterbox:
self.letterbox.stash()
def letterboxOn(self, t=0.25, finishIval=None):
"""
Move black bars in over t seconds.
"""
self.noLetterbox()
self.loadLetterbox()
self.letterbox.unstash()
if (t == 0):
self.letterboxBottom.setPos(0, 0, -1)
self.letterboxTop.setPos(0, 0, 0.8)
else:
self.letterboxIval = Sequence(
Parallel(
LerpPosInterval(
self.letterboxBottom,
t,
pos=Vec3(0, 0, -1),
#startPos = Vec3(0, 0, -1.2),
),
LerpPosInterval(
self.letterboxTop,
t,
pos=Vec3(0, 0, 0.8),
# startPos = Vec3(0, 0, 1),
),
),
name=self.letterboxTaskName,
)
if finishIval:
self.letterboxIval.append(finishIval)
self.letterboxIval.start()
def letterboxOff(self, t=0.25, finishIval=None):
"""
Move black bars away over t seconds.
"""
self.noLetterbox()
self.loadLetterbox()
self.letterbox.unstash()
if (t == 0):
self.letterbox.stash()
else:
self.letterboxIval = Sequence(
Parallel(
LerpPosInterval(
self.letterboxBottom,
t,
pos=Vec3(0, 0, -1.2),
# startPos = Vec3(0, 0, -1),
),
LerpPosInterval(
self.letterboxTop,
t,
pos=Vec3(0, 0, 1),
# startPos = Vec3(0, 0, 0.8),
),
),
Func(self.letterbox.stash),
Func(messenger.send, 'letterboxOff'),
name=self.letterboxTaskName,
)
if finishIval:
self.letterboxIval.append(finishIval)
self.letterboxIval.start()
class Transitions:
# These may be reassigned before the fade or iris transitions are
# actually invoked to change the models that will be used.
IrisModelName = "models/misc/iris"
FadeModelName = "models/misc/fade"
def __init__(self, loader,
model=None,
scale=3.0,
pos=Vec3(0, 0, 0)):
self.transitionIval = None
self.letterboxIval = None
self.iris = None
self.fade = None
self.letterbox = None
self.fadeModel = model
self.imagePos = pos
if model:
self.alphaOff = Vec4(1, 1, 1, 0)
self.alphaOn = Vec4(1, 1, 1, 1)
model.setTransparency(1)
self.lerpFunc = LerpColorScaleInterval
else:
self.alphaOff = Vec4(0, 0, 0, 0)
self.alphaOn = Vec4(0, 0, 0, 1)
self.lerpFunc = LerpColorInterval
self.irisTaskName = "irisTask"
self.fadeTaskName = "fadeTask"
self.letterboxTaskName = "letterboxTask"
def __del__(self):
if self.fadeModel:
self.fadeModel.removeNode()
self.fadeModel = None
##################################################
# Fade
##################################################
# We can set a custom model for the fade before using it for the first time
def setFadeModel(self, model, scale=1.0):
self.fadeModel = model
# We have to change some default parameters for a custom fadeModel
self.alphaOn = Vec4(1, 1, 1, 1)
# Reload fade if its already been created
if self.fade:
self.fade.destroy()
self.fade = None
self.loadFade()
def loadFade(self):
if self.fade is None:
# We create a DirectFrame for the fade polygon, instead of
# simply loading the polygon model and using it directly,
# so that it will also obscure mouse events for objects
# positioned behind it.
self.fade = DirectFrame(
parent = hidden,
guiId = 'fade',
relief = None,
image = self.fadeModel,
image_scale = (4, 2, 2),
state = DGG.NORMAL,
)
if not self.fadeModel:
# No fade model was given, so we make this the fade model.
self.fade["relief"] = DGG.FLAT
self.fade["frameSize"] = (-2, 2, -1, 1)
self.fade["frameColor"] = (0, 0, 0, 1)
self.fade.setTransparency(TransparencyAttrib.MAlpha)
self.fade.setBin('unsorted', 0)
self.fade.setColor(0,0,0,0)
def getFadeInIval(self, t=0.5, finishIval=None):
"""
Returns an interval without starting it. This is particularly useful in
cutscenes, so when the cutsceneIval is escaped out of we can finish the fade immediately
"""
#self.noTransitions() masad: this creates a one frame pop, is it necessary?
self.loadFade()
transitionIval = Sequence(Func(self.fade.reparentTo, aspect2d, DGG.FADE_SORT_INDEX),
Func(self.fade.showThrough), # in case aspect2d is hidden for some reason
self.lerpFunc(self.fade, t,
self.alphaOff,
# self.alphaOn,
),
Func(self.fade.detachNode),
name = self.fadeTaskName,
)
if finishIval:
transitionIval.append(finishIval)
return transitionIval
def getFadeOutIval(self, t=0.5, finishIval=None):
"""
Create a sequence that lerps the color out, then
parents the fade to hidden
"""
self.noTransitions()
self.loadFade()
transitionIval = Sequence(Func(self.fade.reparentTo,aspect2d,DGG.FADE_SORT_INDEX),
Func(self.fade.showThrough), # in case aspect2d is hidden for some reason
self.lerpFunc(self.fade, t,
self.alphaOn,
# self.alphaOff,
),
name = self.fadeTaskName,
)
if finishIval:
transitionIval.append(finishIval)
return transitionIval
def fadeIn(self, t=0.5, finishIval=None):
"""
Play a fade in transition over t seconds.
Places a polygon on the aspect2d plane then lerps the color
from black to transparent. When the color lerp is finished, it
parents the fade polygon to hidden.
"""
gsg = base.win.getGsg()
if gsg:
# If we're about to fade in from black, go ahead and
# preload all the textures etc.
base.graphicsEngine.renderFrame()
render.prepareScene(gsg)
render2d.prepareScene(gsg)
if (t == 0):
# Fade in immediately with no lerp
#print "transitiosn: fadeIn 0.0"
self.noTransitions()
self.loadFade()
self.fade.detachNode()
else:
# Create a sequence that lerps the color out, then
# parents the fade to hidden
self.transitionIval = self.getFadeInIval(t, finishIval)
self.transitionIval.start()
def fadeOut(self, t=0.5, finishIval=None):
"""
Play a fade out transition over t seconds.
Places a polygon on the aspect2d plane then lerps the color
from transparent to full black. When the color lerp is finished,
it leaves the fade polygon covering the aspect2d plane until you
fadeIn or call noFade.
lerp
"""
if (t == 0):
# Fade out immediately with no lerp
self.noTransitions()
self.loadFade()
self.fade.reparentTo(aspect2d, DGG.FADE_SORT_INDEX)
self.fade.setColor(self.alphaOn)
elif ConfigVariableBool('no-loading-screen', False):
if finishIval:
self.transitionIval = finishIval
self.transitionIval.start()
else:
# Create a sequence that lerps the color out, then
# parents the fade to hidden
self.transitionIval = self.getFadeOutIval(t,finishIval)
self.transitionIval.start()
def fadeOutActive(self):
return self.fade and self.fade.getColor()[3] > 0
def fadeScreen(self, alpha=0.5):
"""
Put a semitransparent screen over the camera plane
to darken out the world. Useful for drawing attention to
a dialog box for instance
"""
#print "transitiosn: fadeScreen"
self.noTransitions()
self.loadFade()
self.fade.reparentTo(aspect2d, DGG.FADE_SORT_INDEX)
self.fade.setColor(self.alphaOn[0],
self.alphaOn[1],
self.alphaOn[2],
alpha)
def fadeScreenColor(self, color):
"""
Put a semitransparent screen over the camera plane
to darken out the world. Useful for drawing attention to
a dialog box for instance
"""
#print "transitiosn: fadeScreenColor"
self.noTransitions()
self.loadFade()
self.fade.reparentTo(aspect2d, DGG.FADE_SORT_INDEX)
self.fade.setColor(color)
def noFade(self):
"""
Removes any current fade tasks and parents the fade polygon away
"""
#print "transitiosn: noFade"
if self.transitionIval:
self.transitionIval.pause()
self.transitionIval = None
if self.fade:
# Make sure to reset the color, since fadeOutActive() is looking at it
self.fade.setColor(self.alphaOff)
self.fade.detachNode()
def setFadeColor(self, r, g, b):
self.alphaOn.set(r, g, b, 1)
self.alphaOff.set(r, g, b, 0)
##################################################
# Iris
##################################################
def loadIris(self):
if self.iris == None:
self.iris = loader.loadModel(self.IrisModelName)
self.iris.setPos(0, 0, 0)
def irisIn(self, t=0.5, finishIval=None):
"""
Play an iris in transition over t seconds.
Places a polygon on the aspect2d plane then lerps the scale
of the iris polygon up so it looks like we iris in. When the
scale lerp is finished, it parents the iris polygon to hidden.
"""
self.noTransitions()
self.loadIris()
if (t == 0):
self.iris.detachNode()
else:
self.iris.reparentTo(aspect2d, DGG.FADE_SORT_INDEX)
self.transitionIval = Sequence(LerpScaleInterval(self.iris, t,
scale = 0.18,
startScale = 0.01),
Func(self.iris.detachNode),
name = self.irisTaskName,
)
if finishIval:
self.transitionIval.append(finishIval)
self.transitionIval.start()
def irisOut(self, t=0.5, finishIval=None):
"""
Play an iris out transition over t seconds.
Places a polygon on the aspect2d plane then lerps the scale
of the iris down so it looks like we iris out. When the scale
lerp is finished, it leaves the iris polygon covering the
aspect2d plane until you irisIn or call noIris.
"""
self.noTransitions()
self.loadIris()
self.loadFade() # we need this to cover up the hole.
if (t == 0):
self.iris.detachNode()
self.fadeOut(0)
else:
self.iris.reparentTo(aspect2d, DGG.FADE_SORT_INDEX)
self.transitionIval = Sequence(LerpScaleInterval(self.iris, t,
scale = 0.01,
startScale = 0.18),
Func(self.iris.detachNode),
# Use the fade to cover up the hole that the iris would leave
Func(self.fadeOut, 0),
name = self.irisTaskName,
)
if finishIval:
self.transitionIval.append(finishIval)
self.transitionIval.start()
def noIris(self):
"""
Removes any current iris tasks and parents the iris polygon away
"""
if self.transitionIval:
self.transitionIval.pause()
self.transitionIval = None
if self.iris != None:
self.iris.detachNode()
# Actually we need to remove the fade too,
# because the iris effect uses it.
self.noFade()
def noTransitions(self):
"""
This call should immediately remove any and all transitions running
"""
self.noFade()
self.noIris()
# Letterbox is not really a transition, it is a screen overlay
# self.noLetterbox()
##################################################
# Letterbox
##################################################
def loadLetterbox(self):
if not self.letterbox:
# We create a DirectFrame for the fade polygon, instead of
# simply loading the polygon model and using it directly,
# so that it will also obscure mouse events for objects
# positioned behind it.
self.letterbox = NodePath("letterbox")
# Allow fade in and out of the bars
self.letterbox.setTransparency(1)
# Allow DirectLabels to be parented to the letterbox sensibly
self.letterbox.setBin('unsorted', 0)
# Allow a custom look to the letterbox graphic.
# TODO: This model isn't available everywhere. We should
# pass it in as a parameter.
button = loader.loadModel('models/gui/toplevel_gui',
okMissing = True)
barImage = None
if button:
barImage = button.find('**/generic_button')
self.letterboxTop = DirectFrame(
parent = self.letterbox,
guiId = 'letterboxTop',
relief = DGG.FLAT,
state = DGG.NORMAL,
frameColor = (0, 0, 0, 1),
borderWidth = (0, 0),
frameSize = (-1, 1, 0, 0.2),
pos = (0, 0, 0.8),
image = barImage,
image_scale = (2.25,1,.5),
image_pos = (0,0,.1),
image_color = (0.3,0.3,0.3,1),
sortOrder = 0,
)
self.letterboxBottom = DirectFrame(
parent = self.letterbox,
guiId = 'letterboxBottom',
relief = DGG.FLAT,
state = DGG.NORMAL,
frameColor = (0, 0, 0, 1),
borderWidth = (0, 0),
frameSize = (-1, 1, 0, 0.2),
pos = (0, 0, -1),
image = barImage,
image_scale = (2.25,1,.5),
image_pos = (0,0,.1),
image_color = (0.3,0.3,0.3,1),
sortOrder = 0,
)
# masad: always place these at the bottom of render
self.letterboxTop.setBin('sorted',0)
self.letterboxBottom.setBin('sorted',0)
self.letterbox.reparentTo(render2d, -1)
self.letterboxOff(0)
def noLetterbox(self):
"""
Removes any current letterbox tasks and parents the letterbox polygon away
"""
if self.letterboxIval:
self.letterboxIval.pause()
self.letterboxIval = None
if self.letterbox:
self.letterbox.stash()
def letterboxOn(self, t=0.25, finishIval=None):
"""
Move black bars in over t seconds.
"""
self.noLetterbox()
self.loadLetterbox()
self.letterbox.unstash()
if (t == 0):
self.letterboxBottom.setPos(0, 0, -1)
self.letterboxTop.setPos(0, 0, 0.8)
else:
self.letterboxIval = Sequence(Parallel(
LerpPosInterval(self.letterboxBottom,
t,
pos = Vec3(0, 0, -1),
#startPos = Vec3(0, 0, -1.2),
),
LerpPosInterval(self.letterboxTop,
t,
pos = Vec3(0, 0, 0.8),
# startPos = Vec3(0, 0, 1),
),
),
name = self.letterboxTaskName,
)
if finishIval:
self.letterboxIval.append(finishIval)
self.letterboxIval.start()
def letterboxOff(self, t=0.25, finishIval=None):
"""
Move black bars away over t seconds.
"""
self.noLetterbox()
self.loadLetterbox()
self.letterbox.unstash()
if (t == 0):
self.letterbox.stash()
else:
self.letterboxIval = Sequence(Parallel(
LerpPosInterval(self.letterboxBottom,
t,
pos = Vec3(0, 0, -1.2),
# startPos = Vec3(0, 0, -1),
),
LerpPosInterval(self.letterboxTop,
t,
pos = Vec3(0, 0, 1),
# startPos = Vec3(0, 0, 0.8),
),
),
Func(self.letterbox.stash),
Func(messenger.send,'letterboxOff'),
name = self.letterboxTaskName,
)
if finishIval:
self.letterboxIval.append(finishIval)
self.letterboxIval.start()
class DirectWindow( DirectFrame ):
def __init__( self
, pos = ( -.5, .5)
, title = 'Title'
, bgColor = (.5,.5,.5,1)
, buttonColor = (1,1,1,1) #( .6, .6, .6, 1 )
#, minSize = ( .5, .5 )
#, maxSize = ( 1, 1 )
, minWindowSize = (0,0)
, maxWindowSize = (10000,10000)
, virtualSize = (1,1)
, windowBorderTextureFiles = [ DEFAULT_TITLE_TEXTURE_LEFT
, DEFAULT_TITLE_TEXTURE_CENTER
, DEFAULT_TITLE_TEXTURE_RIGHT
, DEFAULT_RESIZE_GEOM ]
, windowBorderGeomFiles = [ DEFAULT_TITLE_GEOM_RIGHT ]
, windowColors = [ ( 1, 1, 1, 1 )
, ( 1, 1, 1, 1 )
, ( 1, 1, 1, 1 )
, ( 1, 1, 1, 1 ) ]
, borderSize = 0.01
, dragbarSize = 0.05
, parent=None):
self.windowPos = pos
self.minWindowSize = minWindowSize
self.maxWindowSize = maxWindowSize
self.virtualSize = virtualSize
self.borderSize = borderSize
self.dragbarSize = dragbarSize
if parent is None:
parent=aspect2d
self.parent=parent
self.previousSize = (10,10)
self.collapsed = False
# maybe we should check if aspect2d doesnt already contain the aspect2dMouseNode
self.mouseNode = self.parent.attachNewNode( 'aspect2dMouseNode', sort = 999999 )
taskMgr.add( self.mouseNodeTask, 'mouseNodeTask' )
windowBorderTextures = list()
for windowBorder in windowBorderTextureFiles:
if windowBorder is not None:
mdlFile = loader.loadTexture(windowBorder)
windowBorderTextures.append(mdlFile)
else:
windowBorderTextures.append(None)
windowBorderGeoms = list()
for windowGeom in windowBorderGeomFiles:
if windowGeom is not None:
mdlFile = loader.loadModel(windowGeom)
mdls = ( mdlFile.find('**/**-default'),
mdlFile.find('**/**-click'),
mdlFile.find('**/**-rollover'),
mdlFile.find('**/**-disabled') )
windowBorderGeoms.append(mdls)
else:
windowBorderGeoms.append((None,None,None,None,),)
# the main window we want to move around
self.parentWindow = DirectFrame(
parent=self.parent, pos=(self.windowPos[0], 0, self.windowPos[1]),
#frameSize=# is defined in resize
scale=(1, 1, -1),
frameColor=bgColor,
borderWidth=(0, 0), relief=DGG.FLAT, sortOrder=1, )
# header of the window (drag&drop with it)
# the title part of the window, drag around to move the window
self.headerParent = DirectButton(
parent=self.parentWindow, pos=(0, 0, 0),
#frameSize=# is defined in resize
scale=(1, 1, self.dragbarSize),
frameColor=(1, 1, 1, 1),
borderWidth=(0, 0), relief=DGG.FLAT, )
self.headerParent.bind(DGG.B1PRESS,self.startWindowDrag)
# images in the headerParent
self.headerCenter = DirectFrame(
parent=self.headerParent, pos=(0, 0, 1),
#frameSize=# is defined in resize
scale=(1,1,-1),
frameColor=windowColors[1], frameTexture=windowBorderTextures[1],
borderWidth=(0, 0), relief=DGG.FLAT, )
self.headerLeft = DirectFrame(
parent=self.headerParent, pos=(0, 0, 1),
frameSize=(0, self.dragbarSize, 0, 1), scale=(1,1,-1),
frameColor=windowColors[0], frameTexture=windowBorderTextures[0],
borderWidth=(0, 0), relief=DGG.FLAT, )
# collapse button
self.headerRight = DirectButton(
parent=self.headerParent, #pos=# is defined in resize
frameSize=(0, self.dragbarSize, 0, 1), scale=(1,1,-1),
frameColor=windowColors[2], #frameTexture=windowBorderTextures[2],
borderWidth=(0, 0), relief=DGG.FLAT,
command=self.toggleCollapsed,
geom=windowBorderGeoms[0], geom_scale=(self.dragbarSize,1,1) )
# the resize button of the window
self.resizeButton = DirectButton(
parent=self.parentWindow, pos=(1-self.dragbarSize, 0, 1),
frameSize=(0, 1, 0, 1), scale=(self.dragbarSize,1,-self.dragbarSize),
frameColor=windowColors[3], frameTexture=windowBorderTextures[3],
borderWidth=(0, 0), relief=DGG.FLAT, sortOrder=1, )
self.resizeButton.bind(DGG.B1PRESS,self.startResizeDrag)
# text in the center of the window
text = TextNode('WindowTitleTextNode')
text.setText(title)
text.setAlign(TextNode.ACenter)
text.setTextColor( 0, 0, 0, 1 )
text.setShadow(0.05, 0.05)
text.setShadowColor( 1, 1, 1, 1 )
self.textNodePath = self.headerCenter.attachNewNode(text)
self.textNodePath.setPos(.5,0,.3)
self.textNodePath.setScale(0.8*self.dragbarSize,1,0.8)
if Y_INVERTED:
scale = (1,1,-1)
else:
scale = (1,1,1)
# the content part of the window, put stuff beneath
# contentWindow.getCanvas() to put it into it
self.contentWindow = DirectScrolledFrame(
parent = self.parentWindow,
#pos = # is defined in resize
scale = scale,
canvasSize = (0,self.virtualSize[0],0,self.virtualSize[1]),
frameColor = buttonColor,
relief = DGG.RAISED,
borderWidth = (0,0),
verticalScroll_frameSize = [0,self.dragbarSize,0,1],
verticalScroll_frameTexture = loader.loadTexture( 'rightBorder.png' ),
verticalScroll_incButton_frameTexture = loader.loadTexture( 'scrollDown.png' ),
verticalScroll_decButton_frameTexture = loader.loadTexture( 'scrollDown.png' ),
verticalScroll_thumb_frameTexture = loader.loadTexture( 'scrollBar.png' ),
horizontalScroll_frameSize = [0,1,0,self.dragbarSize],
horizontalScroll_frameTexture = loader.loadTexture( 'bottomBorder.png' ),
horizontalScroll_incButton_frameTexture = loader.loadTexture( 'scrollDown.png' ),
horizontalScroll_decButton_frameTexture = loader.loadTexture( 'scrollDown.png' ),
horizontalScroll_thumb_frameTexture = loader.loadTexture( 'scrollBar.png' ),
)
# child we attach should be inside the window
DirectFrame.__init__( self,
parent = self.contentWindow.getCanvas(),
pos = (0,0,self.virtualSize[1]),
scale = (1,1,1),
frameSize = ( 0, self.virtualSize[0]+2*self.borderSize, 0, self.virtualSize[1] ),
#frameColor = (0,0,0,1),
relief = DGG.RIDGE,
borderWidth = (0,0),
)
self.initialiseoptions(DirectWindow)
# offset then clicking on the resize button from the mouse to the resizebutton
# position, required to calculate the position / scaling
self.offset = None
self.resizeButtonTaskName = "resizeTask-%s" % str(hash(self))
# do sizing of the window to virtualSize
#self.resize( self.virtualSize[0]+2*self.borderSize
# , self.virtualSize[1]+self.dragbarSize+2*self.borderSize )
self.resize(10,10)
# a task that keeps a node at the position of the mouse-cursor
def mouseNodeTask(self, task):
if WindowManager.hasMouse():
x=WindowManager.getMouseX()
y=WindowManager.getMouseY()
# the mouse position is read relative to render2d, so set it accordingly
self.mouseNode.setPos( render2d, x, 0, y )
return task.cont
# dragging functions
def startWindowDrag( self, param ):
self.parentWindow.wrtReparentTo( self.mouseNode )
self.ignoreAll()
self.accept( 'mouse1-up', self.stopWindowDrag )
def stopWindowDrag( self, param=None ):
# this could be called even after the window has been destroyed
#if self:
# this is called 2 times (bug), so make sure it's not already parented to aspect2d
if self.parentWindow.getParent() != self.parent:
self.parentWindow.wrtReparentTo(self.parent)
self.ignoreAll()
# resize functions
def startResizeDrag(self, param):
self.offset = self.resizeButton.getPos(aspect2d) - self.mouseNode.getPos(aspect2d)
taskMgr.remove( self.resizeButtonTaskName )
taskMgr.add( self.resizeButtonTask, self.resizeButtonTaskName )
self.accept( 'mouse1-up', self.stopResizeDrag,['x'] )
def resize(self,windowX,windowY):
# limit max/min size of the window
maxX = min(self.maxWindowSize[0], self.virtualSize[0]+2*self.borderSize)
minX = max( self.dragbarSize*3, self.minWindowSize[0])
windowWidth = min( maxX, max( minX, windowX ) )
maxY = min( self.maxWindowSize[1], self.virtualSize[1]+self.dragbarSize+2*self.borderSize )
minY = max( self.dragbarSize*4, self.minWindowSize[1])
windowHeight = min( maxY, max( minY, windowY ) )
if self.collapsed:
windowHeight = 2*self.dragbarSize+2*self.borderSize
windowWidth = windowWidth
self.contentWindow.hide()
# store changed window width only
self.previousSize = windowWidth, self.previousSize[1]
else:
self.contentWindow.show()
self.previousSize = windowWidth, windowHeight
# set the window size
self.headerParent['frameSize'] = (0, windowWidth, 0, 1)
self.headerCenter['frameSize'] = (0, windowWidth, 0, 1)
self.parentWindow['frameSize'] = (0, windowWidth, 0, windowHeight)
self.contentWindow['frameSize'] = (0, windowWidth-self.borderSize*2, 0, windowHeight-self.dragbarSize-2*self.borderSize)
self.contentWindow.setPos(self.borderSize,0,windowHeight-self.borderSize)
self.headerRight.setPos(windowWidth-self.dragbarSize, 0, 1)
self.textNodePath.setPos(windowWidth/2.,0,.3)
self.resizeButton.setPos(windowWidth-self.dragbarSize, 0, windowHeight)
def resizeButtonTask(self, task=None):
mPos = self.mouseNode.getPos(self.parentWindow)
# max height, the smaller of (given maxWindowSize and real size of content and borders
windowX = mPos.getX() + self.offset.getX() + self.dragbarSize
windowY = mPos.getZ() - self.offset.getZ()
self.resize(windowX,windowY)
return task.cont
def stopResizeDrag(self, param):
taskMgr.remove( self.resizeButtonTaskName )
self.ignoreAll()
# a bugfix for a wrong implementation
def detachNode( self ):
self.parentWindow.detachNode()
#self. = None
#DirectFrame.detachNode( self )
def removeNode( self ):
self.parentWindow.removeNode()
#DirectFrame.removeNode( self )
def toggleCollapsed(self,state=None):
if state is None:
state=not self.collapsed
if state:
self.collapse()
else:
self.uncollapse()
def collapse(self):
self.collapsed = True
self.resize(*self.previousSize)
def uncollapse(self):
self.collapsed = False
self.resize(*self.previousSize)
