mirror of
https://github.com/Sneed-Group/Poodletooth-iLand
synced 2024-12-26 21:22:27 -06:00
315 lines
10 KiB
Python
Executable file
315 lines
10 KiB
Python
Executable file
"""
|
|
NodePath for Jam-o-Drum model
|
|
|
|
@author: Ben Buchwald <bb2@alumni.cmu.edu>
|
|
Last Updated: 11/29/2005
|
|
|
|
@var DRUMPAD_RADIUS: constant representing the radius of the drumpad as a percentage
|
|
of the radius of the table
|
|
@type DRUMPAD_RADIUS: float
|
|
@var SPINNER_RADIUS: constant representing the radius of the spinner as a percentage
|
|
of the radius of the table
|
|
@type SPINNER_RADIUS: float
|
|
"""
|
|
|
|
from direct.showbase.DirectObject import DirectObject
|
|
from direct.showbase.Audio3DManager import Audio3DManager
|
|
from direct.gui.DirectGui import *
|
|
from direct.task import Task
|
|
import math
|
|
from pandac.PandaModules import NodePath
|
|
from pandac.PandaModules import Texture, CardMaker, DepthOffsetAttrib, OrthographicLens
|
|
|
|
DRUMPAD_RADIUS = .167
|
|
SPINNER_RADIUS = .254
|
|
|
|
class JamoDrumNodePath(NodePath):
|
|
"""
|
|
A C{NodePath} of a heirarchy of a Jam-o-Drum. Creating one of these sets up
|
|
the camera as well for displaying an orthographic view of this Jam-o-drum
|
|
|
|
@ivar stations: list of 4 L{Station} objects representing each Jam-o-Drum station
|
|
@type stations: L{Station}[]
|
|
"""
|
|
def __init__(self,table=None,mask=None):
|
|
"""
|
|
@keyword table: filename of a table texture. See table_template.psd. Either
|
|
paint anywhere inside the mask for a complete background
|
|
or turn off the pads and spinner and paint in the table circle
|
|
for just a table texture that will have spinners and pads
|
|
put on top of it.
|
|
@type mask: str
|
|
@keyword mask: filename of a mask texture of the non-Jam-o-Drum area. probably
|
|
jod_mask.png that comes with the Jam-o-Drum library.
|
|
@type mask: str
|
|
"""
|
|
NodePath.__init__(self,"JamoDrum")
|
|
|
|
totalHeight = max(1.0,math.sqrt(2)/4.0+SPINNER_RADIUS)*2
|
|
|
|
cm = CardMaker("card")
|
|
cm.setFrame(-1,1,-1,1)
|
|
self.tableCard = self.attachNewNode(cm.generate())
|
|
self.tableCard.setP(-90)
|
|
self.tableCard.setScale(4.0/3.0)
|
|
self.tableCard.setLightOff()
|
|
self.tableCard.setBin("background",0)
|
|
self.tableCard.setDepthTest(0)
|
|
self.tableCard.setDepthWrite(0)
|
|
self.tableCard.hide()
|
|
|
|
if (table):
|
|
self.setTableTexture(loader.loadTexture(table))
|
|
|
|
|
|
if (mask):
|
|
cm = CardMaker("JOD Mask")
|
|
cm.setFrame(-4.0/3.0,4.0/3.0,-4.0/3.0,4.0/3.0)
|
|
self.mask = aspect2d.attachNewNode(cm.generate())
|
|
#self.mask.setP(-90)
|
|
self.mask.setTexture(loader.loadTexture(mask),1)
|
|
self.mask.setTransparency(1)
|
|
self.mask.setDepthTest(0)
|
|
else:
|
|
self.mask = None
|
|
|
|
self.stations = []
|
|
for i in range(4):
|
|
station = Station(self,i)
|
|
station.reparentTo(self)
|
|
self.stations.append(station)
|
|
|
|
self.reparentTo(render)
|
|
base.disableMouse()
|
|
self.lens = OrthographicLens()
|
|
self.lens.setFilmSize(totalHeight*base.getAspectRatio(),totalHeight)
|
|
base.cam.node().setLens(self.lens)
|
|
camera.setPosHpr(0,0,10.0, 0,-90,0)
|
|
base.setBackgroundColor(0,0,0)
|
|
|
|
self.audio3d = Audio3DManager(base.sfxManagerList[0],self)
|
|
self.audio3d.setDropOffFactor(0)
|
|
# end __init__
|
|
|
|
def setTableTexture(self,texture,scale=None):
|
|
"""
|
|
sets the background texture on the table
|
|
|
|
@param texture: C{Texture} or image file to show on the table
|
|
@type texture: C{Texture} or string
|
|
@keyword scale: scale of the texture. Default is set for the table_template.psd
|
|
@type scale: float
|
|
"""
|
|
if (not isinstance(texture,Texture)):
|
|
texture = loader.loadTexture(texture)
|
|
self.tableCard.setTexture(texture)
|
|
if (scale):
|
|
self.tableCard.setScale(scale)
|
|
self.showTable()
|
|
# end setTableTexture
|
|
|
|
def showTable(self):
|
|
"""
|
|
displays the table's background texture
|
|
"""
|
|
self.tableCard.show()
|
|
# end showTable
|
|
|
|
def hideTable(self):
|
|
"""
|
|
hides the table's background texture
|
|
"""
|
|
self.tableCard.hide()
|
|
# end hideSpinner
|
|
|
|
def loadSfx(self,file,object=None):
|
|
"""
|
|
load a sound with positional audio support
|
|
|
|
@param file: wav file to load. Must be mono.
|
|
@type file: string
|
|
@keyword object: object to attach sound to
|
|
@type object: C{NodePath}
|
|
@return: a Panda sound object
|
|
@rtype: C{AudioSound}
|
|
"""
|
|
sfx = self.audio3d.loadSfx(file)
|
|
if (object):
|
|
self.attachSoundToObject(sfx,object)
|
|
return sfx
|
|
# loadSfx
|
|
|
|
def attachSoundToObject(self,sound,object):
|
|
"""
|
|
attach a positional sound to an object it will come from
|
|
|
|
@param sound: positional sound object to attach
|
|
@type sound: C{AudioSound}
|
|
@param object: object sound should come from
|
|
@type object: C{NodePath}
|
|
"""
|
|
self.audio3d.attachSoundToObject(sound,object)
|
|
# end attachSoundToObject
|
|
|
|
def detachSound(self,sound):
|
|
"""
|
|
detach a positional sound from it's object. It will no longer move.
|
|
|
|
@param sound: positional sound object to detach
|
|
@type sound: C{AudioSound}
|
|
"""
|
|
self.audio3d.detachSound(sound)
|
|
# end detachSound
|
|
# end class JamoDrum
|
|
|
|
class Station(NodePath):
|
|
"""
|
|
A C{NodePath} to a specific Jam-o-Drum station. This C{NodePath} should contain
|
|
subparts call pad and spinner. This is automatically created by L{JamoDrumNodePath}
|
|
and should not be created by hand.
|
|
|
|
@ivar index: index of this station (0-3)
|
|
@type index: int
|
|
@ivar pad: C{NodePath} to the pad subpart
|
|
@type pad: C{NodePath}
|
|
@ivar spinner: C{NodePath} to the spinner subpart
|
|
@type spinner: C{NodePath}
|
|
"""
|
|
def __init__(self,jod,index):
|
|
"""
|
|
@param jod: containing Jam-o-Drum
|
|
@type jod: L{JamoDrumNodePath}
|
|
@param index: index of the station
|
|
@type index: int
|
|
"""
|
|
NodePath.__init__(self,"station%02d"%index)
|
|
self.jod = jod
|
|
self.index = index
|
|
angle = 45.0-self.index*90.0
|
|
self.setPos(math.cos((angle-90.0)*math.pi/180.0),math.sin((angle-90.0)*math.pi/180.0),0)
|
|
self.setH(angle)
|
|
|
|
cm = CardMaker("card")
|
|
cm.setFrame(-1,1,-1,1)
|
|
|
|
self.spinner = self.attachNewNode("spinner")
|
|
self.spinnerCard = self.spinner.attachNewNode(cm.generate())
|
|
self.spinnerCard.setTransparency(1)
|
|
self.spinnerCard.setBin("background",1)
|
|
self.spinnerCard.node().setAttrib(DepthOffsetAttrib.make(1))
|
|
self.spinnerCard.setScale(1.0/3.0)
|
|
self.spinnerCard.setP(-90)
|
|
self.spinnerCard.setLightOff()
|
|
self.spinnerCard.hide()
|
|
|
|
self.pad = self.attachNewNode("pad")
|
|
self.padCard = self.pad.attachNewNode(cm.generate())
|
|
self.padCard.setTransparency(1)
|
|
self.padCard.setBin("background",2)
|
|
self.padCard.node().setAttrib(DepthOffsetAttrib.make(2))
|
|
self.padCard.setScale(1.0/3.0)
|
|
self.padCard.setP(-90)
|
|
self.padCard.setLightOff()
|
|
self.padCard.hide()
|
|
# end __init__
|
|
|
|
def getParent(self):
|
|
"""
|
|
get the containing L{JamoDrumNodePath}
|
|
|
|
@return: the containing Jam-o-Drum
|
|
@rtype: L{JamoDrumNodePath}
|
|
"""
|
|
return self.jod
|
|
# end getParent
|
|
|
|
def setSpinnerTexture(self,texture,scale=None):
|
|
"""
|
|
sets the background texture on the spinner
|
|
|
|
@param texture: C{Texture} or image file to show on the spinner
|
|
@type texture: C{Texture} or string
|
|
@keyword scale: scale of the texture. Default is set for the spinner_template.psd
|
|
@type scale: float
|
|
"""
|
|
if (not isinstance(texture,Texture)):
|
|
texture = loader.loadTexture(texture)
|
|
self.spinnerCard.setTexture(texture)
|
|
if (scale):
|
|
self.spinnerCard.setScale(scale)
|
|
self.showSpinner()
|
|
# end setSpinnerTexture
|
|
|
|
def setPadTexture(self,texture,scale=None):
|
|
"""
|
|
sets the background texture on the pad
|
|
|
|
@param texture: C{Texture} or image file to show on the pad
|
|
@type texture: C{Texture} or string
|
|
@keyword scale: scale of the texture. Default is set for the spinner_template.psd
|
|
@type scale: float
|
|
"""
|
|
if (not isinstance(texture,Texture)):
|
|
texture = loader.loadTexture(texture)
|
|
self.padCard.setTexture(texture)
|
|
if (scale):
|
|
self.padCard.setScale(scale)
|
|
self.showPad()
|
|
# end setPadTexture
|
|
|
|
def showSpinner(self):
|
|
"""
|
|
displays the spinner's background texture
|
|
"""
|
|
self.spinnerCard.show()
|
|
# end showSpinner
|
|
|
|
def showPad(self):
|
|
"""
|
|
displays the pad's background texture
|
|
"""
|
|
self.padCard.show()
|
|
# end showPad
|
|
|
|
def hideSpinner(self):
|
|
"""
|
|
hides the spinner's background texture
|
|
"""
|
|
self.spinnerCard.hide()
|
|
# end hideSpinner
|
|
|
|
def hidePad(self):
|
|
"""
|
|
hide the pad's background texture
|
|
"""
|
|
self.padCard.hide()
|
|
# end hidePad
|
|
|
|
def loadSfx(self,file,object=None):
|
|
"""
|
|
load a sound with positional audio support and attach it to this station
|
|
|
|
@param file: wav file to load. Must be mono.
|
|
@type file: string
|
|
@keyword object: object to attach sound to. default: this station
|
|
@type object: C{NodePath}
|
|
@return: a Panda sound object
|
|
@rtype: C{AudioSound}
|
|
"""
|
|
return self.jod.loadSfx(file,object or self)
|
|
#end loadSfx
|
|
|
|
def attachSound(self,sound,object=None):
|
|
"""
|
|
attach a positional sound to this station
|
|
|
|
@param sound: positional sound object to attach
|
|
@type sound: C{AudioSound}
|
|
@keyword object: object sound should come from. default: this station
|
|
@type object: C{NodePath}
|
|
"""
|
|
self.jod.attachSoundToObject(sound,object or self)
|
|
# end attachSound
|
|
# end class Station
|
|
|
|
|