def __init__(self):
""" Constructs a new Light, subclasses have to call this """
DebugObject.__init__(self, "AbstractLight")
ShaderStructElement.__init__(self)
self.debugNode = NodePath("LightDebug")
self.visualizationNumSteps = 32
self.dataNeedsUpdate = False
self.castShadows = False
self.debugEnabled = False
self.bounds = OmniBoundingVolume()
self.shadowSources = []
self.lightType = self.getLightType()
self.position = Vec3(0)
self.color = Vec3(1)
self.posterIndex = -1
self.radius = 10.0
self.typeName = ""
self.sourceIndexes = PTAInt.emptyArray(6)
self.attached = False
self.shadowResolution = 512
self.index = -1
self.iesProfile = -1
self.iesProfileName = None
self.mvp = Mat4()
# A light can have up to 6 sources
for i in range(6):
self.sourceIndexes[i] = -1
def startDrop(self, entity):
if entity and self.dropLoc:
endPos = self.dropLoc
dropMdl = entity.find('**/DropMdl')
startPos = Point3(endPos.getX(), endPos.getY(), endPos.getZ() + 20)
entity.setPos(startPos.getX(),
startPos.getY() + 2, startPos.getZ())
dropMdl.setScale(5 * 0.85)
entity.node().setBounds(OmniBoundingVolume())
entity.node().setFinal(1)
entity.headsUp(self.avatar)
self.buildCollisions(entity)
objectTrack = Sequence()
animProp = LerpPosInterval(entity,
self.fallDuration,
endPos,
startPos=startPos)
bounceProp = Effects.createZBounce(entity, 2, endPos, 0.5, 1.5)
objAnimShrink = Sequence(Func(dropMdl.setScale, 5), Wait(0.5),
Func(entity.reparentTo, render), animProp,
bounceProp)
objectTrack.append(objAnimShrink)
dropShadow = CIGlobals.makeDropShadow(1.0)
dropShadow.reparentTo(hidden)
dropShadow.setPos(endPos)
shadowTrack = Sequence(
Func(dropShadow.reparentTo, render),
LerpScaleInterval(dropShadow,
self.fallDuration + 0.1, (1, 1, 1),
startScale=Point3(0.01, 0.01, 0.01)),
Wait(0.8), Func(dropShadow.removeNode))
Parallel(
Sequence(Wait(self.fallDuration), Func(self.completeDrop)),
objectTrack, shadowTrack).start()
self.dropLoc = None
def equip(self):
Gag.equip(self)
base.audio3d.attachSoundToObject(self.fireSound, self.avatar)
base.audio3d.attachSoundToObject(self.dblFireSound, self.avatar)
base.audio3d.attachSoundToObject(self.pumpSound, self.avatar)
base.audio3d.attachSoundToObject(self.emptySound, self.avatar)
for s in self.reloadSounds:
base.audio3d.attachSoundToObject(s, self.avatar)
if self.isLocal():
self.sgViewModel = Actor(self.sgActorDef[0], self.sgActorDef[1])
self.sgViewModel.node().setBounds(OmniBoundingVolume())
self.sgViewModel.node().setFinal(1)
self.sgViewModel.setBlend(
frameBlend=base.config.GetBool('interpolate-frames', False))
self.sgViewModel.setH(180)
self.sgViewModel.find("**/shell").setBSPMaterial(
'phase_14/hl2/casing01.mat')
fpsCam = self.getFPSCam()
fpsCam.swapViewModel(self.sgViewModel, 54.0)
self.setAction(self.actionDraw)
self.accept('r', self.__doReload)
taskMgr.add(self.__tick, "HL2ShotgunTick")
self.gag.setPosHprScale(-0.03, 1.19, -0.14, 2.29, 347.01, 45, 2, 2, 2)
toonTrack = Sequence(Func(self.avatar.setForcedTorsoAnim, 'firehose'),
self.getAnimationTrack('firehose', endFrame=30),
Func(self.__doBob))
self.setAnimTrack(toonTrack, startNow=True)
def __init__(self, whl_pos, whl_radius, car_h):
GameObject.__init__(self)
self.radius = whl_radius
v_f = GeomVertexFormat.getV3()
vdata = GeomVertexData('skid', v_f, Geom.UHDynamic)
prim = GeomTriangles(Geom.UHStatic)
self.vtx_cnt = 1
self.last_pos = whl_pos
geom = Geom(vdata)
geom.add_primitive(prim)
self.node = GeomNode('gnode')
self.node.add_geom(geom)
nodepath = self.eng.gfx.root.attach_node(self.node)
nodepath.set_transparency(True)
nodepath.set_depth_offset(1)
nodepath.node.set_two_sided(True) # for self-shadowing issues
self.__set_material(nodepath)
nodepath.p3dnode.set_bounds(OmniBoundingVolume())
self.add_vertices(whl_radius, car_h)
self.add_vertices(whl_radius, car_h)
def alpha(time, n_p):
if not n_p.is_empty:
n_p.node.set_shader_input('alpha', time)
# this if seems necessary since, if there are skidmarks and you
# exit from the race (e.g. back to the menu), then alpha is being
# called from the interval manager even if the interval manager
# correctly says that there are 0 intervals.
self.remove_seq = Sequence(
Wait(8), LerpFunc(alpha, 8, .5, 0, 'easeInOut', [nodepath]),
Func(nodepath.remove_node))
self.remove_seq.start()
def load(self):
Entity.load(self)
scale = self.getEntityValueFloat("spriteScale")
color = self.getEntityValueColor("spriteColor")
sunVec = base.shaderGenerator.getSunVector()
self.pivotNode = camera.attachNewNode('env_sun-pivot')
self.pivotNode.lookAt(sunVec)
self.pivotNode.setCompass()
cm = CardMaker('sun_sprite')
cm.setFrame(-0.5, 0.5, -0.5, 0.5)
self.sunSprite = self.pivotNode.attachNewNode(
GlowNode(cm.generate(), 32.0 * scale))
self.sunSprite.setAttrib(
ColorBlendAttrib.make(ColorBlendAttrib.MAdd, ColorBlendAttrib.OOne,
ColorBlendAttrib.OOne), 1)
self.sunSprite.setBSPMaterial("phase_14/materials/sun/sunsprite.mat",
1)
self.sunSprite.setFogOff(10)
self.sunSprite.setBillboardPointEye()
self.sunSprite.setDepthTest(False)
self.sunSprite.setDepthWrite(False)
self.sunSprite.setScale(scale * 100)
self.sunSprite.setColorScale(color, 1)
self.sunSprite.setY(1000)
self.sunSprite.node().setBounds(OmniBoundingVolume())
self.sunSprite.node().setFinal(True)
def __init__(self, wheel_pos, radius, heading):
self.radius = radius
v_f = GeomVertexFormat.getV3()
self.vdata = GeomVertexData('skid', v_f, Geom.UHDynamic)
self.vdata.setNumRows(1)
self.vertex = GeomVertexWriter(self.vdata, 'vertex')
self.prim = GeomTriangles(Geom.UHStatic)
self.cnt = 1
self.last_pos = wheel_pos
geom = Geom(self.vdata)
geom.addPrimitive(self.prim)
node = GeomNode('gnode')
node.addGeom(geom)
nodePath = render.attachNewNode(node)
nodePath.setTransparency(True)
nodePath.setDepthOffset(1)
self.__set_material(nodePath)
nodePath.node().setBounds(OmniBoundingVolume())
self.add_vertices(radius, heading)
self.add_vertices(radius, heading)
self.remove_seq = Sequence(
Wait(8),
LerpFunc(nodePath.setAlphaScale, 8, 1, 0, 'easeInOut'),
Func(nodePath.remove_node))
self.remove_seq.start()
def end_loading(self, model=None):
if model:
self.model = model
anim_name = '**/%s*%s*' % (self.props.empty_name, self.props.anim_name)
for model in self.model.findAllMatches(anim_name):
# bam files don't contain actor info
new_root = NodePath(model.get_name())
new_root.reparent_to(model.get_parent())
new_root.set_pos(model.get_pos())
new_root.set_hpr(model.get_hpr())
new_root.set_scale(model.get_scale())
model_subname = model.get_name()[len(self.props.empty_name):]
path = '%s/%s' % (self.props.path, model_subname)
if '.' in path:
path = path.split('.')[0]
anim_path = '%s-%s' % (path, self.props.anim_name)
self.__actors += [Actor(path, {'anim': anim_path})]
self.__actors[-1].loop('anim')
self.__actors[-1].setPlayRate(.5, 'anim')
self.__actors[-1].reparent_to(new_root)
has_omni = model.has_tag(self.props.omni_tag)
if has_omni and model.get_tag(self.props.omni_tag):
new_root.set_tag(self.props.omni_tag, 'True')
a_n = self.__actors[-1].get_name()
LogMgr().log('set omni for ' + a_n)
self.__actors[-1].node().setBounds(OmniBoundingVolume())
self.__actors[-1].node().setFinal(True)
model.remove_node()
self.signs = Signs(self.model, self.props.sign_name, self.props.thanks)
self.signs.set_signs()
self.model.prepareScene(eng.base.win.getGsg())
self.model.premungeScene(eng.base.win.getGsg())
Gfx.async_bld(self)
def loadLevelData(self, inputData):
"""
processes the level asloaded from the file. it seperates the input data until the data for each tile is ready.
"""
rigidNode = RigidBodyCombiner("LevelNode")
levelNode = NodePath(rigidNode)
#deleting whitespaces and seperating the content for each tile into a list.
inputData = inputData.replace("\n", "").strip().replace(
" ", "").lstrip("<").rstrip(">").split("><")
for tileData in inputData:
tile = self.loadTile(tileData)
if tile != None:
tile.reparentTo(levelNode)
tile.setPos(self.getPosFromTile(tile))
tile.setZ(
tile, 0.00000001
) # workaround for rigid body combiner so it does not assume the (0,0) tile as static
else:
print("ERROR, could not load tile with data: ", tileData)
rigidNode.collect()
inode = rigidNode.getInternalScene().node(
) # workaround for a boundingvolume issue with rigidbodycombiner
inode.setBounds(OmniBoundingVolume()) # still workaround
inode.setFinal(True) # still workaround
return levelNode
def load(self):
DistributedPartyFireworksActivity.notify.debug('load')
DistributedPartyActivity.load(self)
self.eventId = PartyGlobals.FireworkShows.Summer
self.launchPadModel = loader.loadModel('phase_13/models/parties/launchPad')
self.launchPadModel.setH(90.0)
self.launchPadModel.setPos(0.0, -18.0, 0.0)
self.launchPadModel.reparentTo(self.root)
railingsCollection = self.launchPadModel.findAllMatches('**/launchPad_mesh/*railing*')
for i in xrange(railingsCollection.getNumPaths()):
railingsCollection[i].setAttrib(AlphaTestAttrib.make(RenderAttrib.MGreater, 0.75))
leverLocator = self.launchPadModel.find('**/RocketLever_locator')
self.lever.setPosHpr(Vec3.zero(), Vec3.zero())
self.lever.reparentTo(leverLocator)
self.toonPullingLeverInterval = None
self.sign.reparentTo(self.launchPadModel.find('**/launchPad_sign_locator'))
self.rocketActor = Actor('phase_13/models/parties/rocket_model', {'launch': 'phase_13/models/parties/rocket_launch'})
rocketLocator = self.launchPadModel.find('**/rocket_locator')
self.rocketActor.reparentTo(rocketLocator)
self.rocketActor.node().setBound(OmniBoundingVolume())
self.rocketActor.node().setFinal(True)
effectsLocator = self.rocketActor.find('**/joint1')
self.rocketExplosionEffect = RocketExplosion(effectsLocator, rocketLocator)
self.rocketParticleSeq = None
self.launchSound = base.loader.loadSfx('phase_13/audio/sfx/rocket_launch.ogg')
self.activityFSM = FireworksActivityFSM(self)
self.activityFSM.request('Idle')
return
def __init__(self, name, format = GeomVertexFormat.getV3()):
self.views = []
self.vertexBuffer = GeomVertexData(name + "-vdata", format, GeomEnums.UHDynamic)
self.np = NodePath(name)
self.np.node().setBounds(OmniBoundingVolume())
self.np.node().setFinal(1)
def _make_fullscreen_tri(self):
""" Creates the oversized triangle used for rendering """
vformat = GeomVertexFormat.get_v3()
vdata = GeomVertexData("vertices", vformat, Geom.UH_static)
vdata.set_num_rows(3)
vwriter = GeomVertexWriter(vdata, "vertex")
vwriter.add_data3f(-1, 0, -1)
vwriter.add_data3f(3, 0, -1)
vwriter.add_data3f(-1, 0, 3)
gtris = GeomTriangles(Geom.UH_static)
gtris.add_next_vertices(3)
geom = Geom(vdata)
geom.add_primitive(gtris)
geom_node = GeomNode("gn")
geom_node.add_geom(geom)
geom_node.set_final(True)
geom_node.set_bounds(OmniBoundingVolume())
tri = NodePath(geom_node)
tri.set_depth_test(False)
tri.set_depth_write(False)
tri.set_attrib(TransparencyAttrib.make(TransparencyAttrib.M_none), 10000)
tri.set_color(Vec4(1))
tri.set_bin("unsorted", 10)
tri.reparent_to(self._node)
self._tri = tri
def __init__(self,manager,xml):
self.updateTask = None
self.sun = base.cam.attachNewNode('sun')
loader.loadModel(manager.get('paths').getConfig().find('misc').get('path')+'/sphere').reparentTo(self.sun)
self.sun.setScale(0.1)
self.sun.setTwoSided(True)
self.sun.setColorScale(10.0, 10.0, 10.0, 1.0, 10001)
self.sun.setLightOff(1)
self.sun.setShaderOff(1)
self.sun.setFogOff(1)
self.sun.setCompass()
self.sun.setBin('background', 10)
self.sun.setDepthWrite(False)
self.sun.setDepthTest(False)
# Workaround an annoyance in Panda. No idea why it's needed.
self.sun.node().setBounds(OmniBoundingVolume())
isa = xml.find('isa')
inst = xml.find('instance')
if isa != None or inst != None:
if inst != None:
orig = Vec3(float(inst.get('x', '0')), float(inst.get('y', '0')), float(inst.get('z', '0')))
else:
level = manager.get(isa.get('source'))
orig = Vec3(level.getByIsA(isa.get('name'))[0].getPos(render))
orig.normalize()
self.sun.setPos(orig)
godrays = xml.find('godrays')
if godrays != None:
self.vlbuffer = base.win.makeTextureBuffer('volumetric-lighting', base.win.getXSize()/2, base.win.getYSize()/2)
self.vlbuffer.setClearColor(Vec4(0, 0, 0, 1))
cam = base.makeCamera(self.vlbuffer)
cam.node().setLens(base.camLens)
cam.reparentTo(base.cam)
initstatenode = NodePath('InitialState')
initstatenode.setColorScale(0, 0, 0, 1, 10000)
initstatenode.setShaderOff(10000)
initstatenode.setLightOff(10000)
initstatenode.setMaterialOff(10000)
initstatenode.setTransparency(TransparencyAttrib.MBinary, 10000)
cam.node().setCameraMask(BitMask32.bit(2))
cam.node().setInitialState(initstatenode.getState())
self.vltexture = self.vlbuffer.getTexture()
self.vltexture.setWrapU(Texture.WMClamp)
self.vltexture.setWrapV(Texture.WMClamp)
card = CardMaker('VolumetricLightingCard')
card.setFrameFullscreenQuad()
self.finalQuad = render2d.attachNewNode(card.generate())
self.finalQuad.setAttrib(ColorBlendAttrib.make(ColorBlendAttrib.MAdd, ColorBlendAttrib.OIncomingColor, ColorBlendAttrib.OFbufferColor))
self.finalQuad.setShader(Shader.load(posixpath.join(manager.get('paths').getConfig().find('shaders').get('path'), 'filter-vlight.cg')))
self.finalQuad.setShaderInput('src', self.vltexture)
self.finalQuad.setShaderInput('vlparams', 32, 0.9/32.0, 0.97, 0.5) # Note - first 32 is now hardcoded into shader for cards that don't support variable sized loops.
self.finalQuad.setShaderInput('casterpos', 0.5, 0.5, 0, 0)
# Last parameter to vlcolor is the exposure
vlcolor = Vec4(float(godrays.get('r', '1')), float(godrays.get('g', '1')), float(godrays.get('b', '1')), 0.04)
self.finalQuad.setShaderInput('vlcolor', vlcolor)
else:
self.finalQuad = None
def __init__(self):
Light.__init__(self)
DebugObject.__init__(self, "DirectionalLight")
self._spacing = 0.6
self.radius = 99999999999.0
self.position = Vec3(0)
self.bounds = OmniBoundingVolume()
def create_holder_instance(self):
self.holder = NodePath('tile')
self.holder.set_pos(self.x0, self.y0, 0.0)
self.holder.set_scale(*self.get_scale())
if settings.debug_lod_show_bb:
self.bounds_shape.create_instance()
self.holder.node().setBounds(OmniBoundingVolume())
self.holder.node().setFinal(1)
def precacheScene(scene, reset=True):
if reset:
oldp = scene.getParent()
rHidden = False
if render.isHidden():
rHidden = True
render.show()
stashed = NodePathCollection()
for np in scene.findAllMatches("**;+s"):
if np.isStashed():
stashed.addPath(np)
np.unstash()
if not scene.isAncestorOf(render):
# if it's parented to camera,
# camera will always see it
scene.reparentTo(render)
# this says that the scene takes up infinite space,
# making it always intersect the view frustum,
# guaranteed to be rendered
scene.node().setBounds(OmniBoundingVolume())
scene.node().setFinal(1)
# Always render if it's a BSP level, even if outside of PVS
scene.setAttrib(BSPFaceAttrib.makeIgnorePvs(), 1)
try:
scene.premungeScene(base.win.getGsg())
scene.prepareScene(base.win.getGsg())
base.graphicsEngine.renderFrame()
base.graphicsEngine.renderFrame()
base.graphicsEngine.syncFrame()
base.musicManager.update()
if reset:
scene.node().setFinal(0)
scene.node().clearBounds()
scene.reparentTo(oldp)
if rHidden:
render.hide()
# restash
for np in stashed:
np.stash()
except:
# The program might have exited prematurely.
# This will prevent the game from yelling at us.
print("precacheScene failed")
scene.clearAttrib(BSPFaceAttrib)
return rHidden
def _makeFullscreenCam(self):
bufferCam = Camera("BufferCamera")
lens = OrthographicLens()
lens.setFilmSize(2, 2)
lens.setFilmOffset(0, 0)
lens.setNearFar(-1000, 1000)
bufferCam.setLens(lens)
bufferCam.setCullBounds(OmniBoundingVolume())
return bufferCam
def create_instance(self, patch):
if self.template is None:
GpuPatchTerrainLayer.template = geometry.Patch(0.5)
self.instance = NodePath('tile')
bounds = OmniBoundingVolume()
self.instance.node().setBounds(bounds)
self.instance.node().setFinal(1)
self.template.instanceTo(self.instance)
self.instance.reparent_to(patch.instance)
def __init__(self):
""" Constructs a new directional light. You have to set a
direction for this light to work properly"""
Light.__init__(self)
DebugObject.__init__(self, "GIHelperLight")
self.typeName = "GIHelperLight"
self.targetLight = None
self.filmSize = 50
self.bounds = OmniBoundingVolume()
def create_instance(self):
self.instance = NodePath("card")
card_maker = CardMaker("card")
card_maker.set_frame(-1, 1, -1, 1)
node = card_maker.generate()
self.card_instance = self.instance.attach_new_node(node)
self.card_instance.setBillboardPointWorld()
TransparencyBlend.apply(self.blend, self.instance)
self.instance.node().setBounds(OmniBoundingVolume())
self.instance.node().setFinal(True)
return self.instance
def __node(self):
# this function creates and returns particles' GeomNode
points = GeomPoints(GeomEnums.UH_static)
points.addNextVertices(self.__numPart)
format_ = GeomVertexFormat.getEmpty()
geom = Geom(GeomVertexData("abc", format_, GeomEnums.UH_static))
geom.addPrimitive(points)
geom.setBounds(OmniBoundingVolume()) # always render it
node = GeomNode("node")
node.addGeom(geom)
return node
def _make_fullscreen_cam(self):
""" Creates an orthographic camera for the buffer """
buffer_cam = Camera("BufferCamera")
lens = OrthographicLens()
lens.set_film_size(2, 2)
lens.set_film_offset(0, 0)
lens.set_near_far(-100, 100)
buffer_cam.set_lens(lens)
buffer_cam.set_cull_bounds(OmniBoundingVolume())
self._camera = self._node.attach_new_node(buffer_cam)
self._region.set_camera(self._camera)
def __init__(self, water_options):
self.water_options = water_options
self.water_level = 0.0
self.model = Globals.base.loader.load_model(
"/$$rp/data/builtin_models/water/water_grid.bam")
self.model.reparent_to(Globals.base.render)
self.model.node().set_final(True)
self.model.node().set_bounds(OmniBoundingVolume())
self.model.set_two_sided(True)
self.model.set_shader_input("waterHeight", self.water_level)
self.model.set_mat(Mat4.identMat())
self.model.clear_transform()
def __init__(self, pipeline):
DebugObject.__init__(self, "ProjectedWaterGrid")
self.debug("Creating water grid")
self.waterLevel = 0.0
self.model = Globals.loader.loadModel(
"Data/InternalModels/ScreenSpaceGrid.bam")
self.model.reparentTo(Globals.base.render)
self.model.node().setFinal(True)
self.model.node().setBounds(OmniBoundingVolume())
self.model.setTwoSided(True)
self.model.setShaderInput("waterHeight", self.waterLevel)
self.model.setMat(Mat4.identMat())
self.model.clearTransform()
foam = Globals.loader.loadTexture("Data/Textures/WaterFoam.png")
self.model.setShaderInput("waterFoam", foam)
self.manager = WaterManager()
self.manager.setup()
self.manager.update()
self.model.setShaderInput("waterHeightfield",
self.manager.getDisplacementTexture())
self.model.setShaderInput("waterNormal",
self.manager.getNormalTexture())
# Set texture filter modes
for tex in [
foam,
self.manager.getDisplacementTexture(),
self.manager.getNormalTexture()
]:
tex.setWrapU(SamplerState.WMRepeat)
tex.setWrapU(SamplerState.WMRepeat)
tex.setMinfilter(SamplerState.FTLinearMipmapLinear)
tex.setMagfilter(SamplerState.FTLinearMipmapLinear)
self.pipeline = pipeline
self.pipeline.setEffect(
self.model,
"Effects/Water/ProjectedWater.effect",
{
# "transparent": True
"castShadows": False
# "tesselated": True
})
# pipeline.convertToPatches(self.model)
pipeline.showbase.addTask(self.updateTask, "updateWater")
def _makeFullscreenQuad(self):
cm = CardMaker("BufferQuad")
cm.setFrameFullscreenQuad()
quad = NodePath(cm.generate())
quad.setDepthTest(0)
quad.setDepthWrite(0)
quad.setAttrib(TransparencyAttrib.make(TransparencyAttrib.MNone))
quad.setColor(Vec4(1, 0.5, 0.5, 1))
# No culling check
quad.node().setFinal(True)
quad.node().setBounds(OmniBoundingVolume())
quad.setBin("unsorted", 10)
return quad
def loadViewModel(self):
self.unloadViewModel()
if self.SpecialVM and self.SpecialVMActor:
modelName, anims = self.SpecialVMActor
self.specialViewModel = Actor(modelName, anims)
self.specialViewModel.setPos(self.SpecialVMOrigin)
self.specialViewModel.setHpr(self.SpecialVMAngles)
self.specialViewModel.setScale(self.SpecialVMScale)
self.specialViewModel.setBlend(
frameBlend=base.config.GetBool('interpolate-frames', False))
if not self.SpecialVMCull:
self.specialViewModel.node().setBounds(OmniBoundingVolume())
self.specialViewModel.node().setFinal(1)
def __init__(self):
""" Constructs a new directional light. You have to set a
direction for this light to work properly"""
Light.__init__(self)
DebugObject.__init__(self, "DirectionalLight")
self.typeName = "DirectionalLight"
self.splitCount = 4
self.pssmTargetCam = None
self.pssmTargetLens = None
self.pssmFarPlane = 100.0
self.pssmSplitPow = 2.0
self.updateIndex = 0
# A directional light is always visible
self.bounds = OmniBoundingVolume()
def _makeFullscreenQuad(self):
""" Create a quad which fills the whole screen """
cm = CardMaker("BufferQuad")
cm.setFrameFullscreenQuad()
quad = NodePath(cm.generate())
quad.setDepthTest(False)
quad.setDepthWrite(False)
quad.setAttrib(TransparencyAttrib.make(TransparencyAttrib.MNone), 1000)
quad.setColor(Vec4(1, 0.5, 0.5, 1))
# Disable culling
quad.node().setFinal(True)
quad.node().setBounds(OmniBoundingVolume())
quad.setBin("unsorted", 10)
return quad
def load(self):
self.fireSound = base.audio3d.loadSfx(self.sgFirePath)
self.emptySound = base.audio3d.loadSfx(self.sgEmptyPath)
self.reloadSound = base.audio3d.loadSfx(self.sgReloadPath)
base.audio3d.attachSoundToObject(self.fireSound, self.avatar)
base.audio3d.attachSoundToObject(self.emptySound, self.avatar)
base.audio3d.attachSoundToObject(self.reloadSound, self.avatar)
if self.isLocal():
self.sgViewModel = Actor(self.sgActorDef[0], self.sgActorDef[1])
self.sgViewModel.setPlayRate(self.Speed, "idle")
self.sgViewModel.node().setBounds(OmniBoundingVolume())
self.sgViewModel.node().setFinal(1)
self.sgViewModel.setBlend(
frameBlend=base.config.GetBool('interpolate-frames', False))
self.sgViewModel.setH(180)
self.fpMuzzleAttach = self.sgViewModel.exposeJoint(
None, "modelRoot", "ValveBiped.muzzle")
def __init__(self,
use_sprites=True,
use_sizes=True,
points_size=2,
sprite=None,
background=None,
shader=None):
self.gnode = GeomNode('starfield')
self.use_sprites = use_sprites
self.use_sizes = use_sizes
self.background = background
if shader is None:
shader = BasicShader(lighting_model=FlatLightingModel(),
point_shader=False)
self.shader = shader
self.reset()
self.geom = self.makeGeom([], [], [])
self.gnode.addGeom(self.geom)
self.instance = NodePath(self.gnode)
if self.use_sprites:
if sprite is None:
sprite = RoundDiskPointSprite()
self.sprite = sprite
else:
self.sprite = SimplePoint(points_size)
self.min_size = self.sprite.get_min_size()
self.sprite.apply(self.instance)
self.instance.setCollideMask(GeomNode.getDefaultCollideMask())
self.instance.node().setPythonTag('owner', self)
#TODO: Should not use ModelAppearance !
self.appearance = ModelAppearance(vertex_color=True)
if self.appearance is not None:
self.appearance.bake()
self.appearance.apply(self, self)
if self.shader is not None:
self.shader.apply(self, self.appearance)
if self.use_sprites:
self.instance.node().setBounds(OmniBoundingVolume())
self.instance.node().setFinal(True)
if self.background is not None:
self.instance.setBin('background', self.background)
self.instance.set_depth_write(False)
def apply_instance(self, instance):
#print("Apply", self.get_name())
if instance != self.instance:
if self.instance is not None:
self.instance.remove_node()
self.instance = instance
self.shape.set_clickable(self.clickable)
self.shape.apply_owner()
self.instance.reparentTo(self.context.world)
instance.hide(self.AllCamerasMask)
instance.show(self.default_camera_mask)
if self.appearance is not None:
#TODO: should be done somewhere else
self.appearance.bake()
if self.context.observer.has_scattering:
self.context.observer.scattering.add_attenuated_object(self)
self.instance.node().setBounds(OmniBoundingVolume())
self.instance.node().setFinal(True)
self.schedule_jobs()