def __init__(self):
#Standard title and instruction text
self.title = OnscreenText(
text="Panda3D: Tutorial - Particles",
style=1, fg=(1,1,1,1), pos=(0.8,-0.95), scale = .07)
self.escapeEvent = OnscreenText(
text=HELPTEXT,
style=1, fg=(1,1,1,1), pos=(-1.3, 0.95),
align=TextNode.ALeft, scale = .05)
#More standard initialization
self.accept('escape', sys.exit)
self.accept('1', self.loadParticleConfig , ['steam.ptf'])
self.accept('2', self.loadParticleConfig , ['dust.ptf'])
self.accept('3', self.loadParticleConfig , ['fountain.ptf'])
self.accept('4', self.loadParticleConfig , ['smoke.ptf'])
self.accept('5', self.loadParticleConfig , ['smokering.ptf'])
self.accept('6', self.loadParticleConfig , ['fireish.ptf'])
self.accept('escape', sys.exit)
base.disableMouse()
camera.setPos(0,-20,2)
base.setBackgroundColor( 0, 0, 0 )
#This command is required for Panda to render particles
base.enableParticles()
self.t = loader.loadModel("models/teapot")
self.t.setPos(0,10,0)
self.t.reparentTo(render)
self.setupLights()
self.p = ParticleEffect()
self.loadParticleConfig('steam.ptf')
def createEffect(values):
p = ParticleEffect()
loadValues(values, p)
color_gradient=loader.loadTexture(values["color_gradient"])
size_gradient=loader.loadTexture(values["size_gradient"])
shape_gradient=loader.loadTexture(values["shape_gradient"])
blend_gradient=loader.loadTexture("data/blend.png", minfilter=Texture.FTNearest, magfilter=Texture.FTNearest)
color_gradient.setWrapU(Texture.WMClamp)
color_gradient.setWrapV(Texture.WMClamp)
size_gradient.setWrapU(Texture.WMClamp)
size_gradient.setWrapV(Texture.WMClamp)
shape_gradient.setWrapU(Texture.WMClamp)
shape_gradient.setWrapV(Texture.WMClamp)
blend_gradient.setWrapU(Texture.WMClamp)
blend_gradient.setWrapV(Texture.WMClamp)
for geom in p.findAllMatches('**/+GeomNode'):
geom.setDepthWrite(False)
geom.setBin("transparent", 31)
#need to hide it from the water and shadow camera now... I don't know hot to get the geom later :(
geom.hide(BitMask32.bit(1))
geom.hide(BitMask32.bit(2))
geom.setShader(Shader.load(Shader.SLGLSL, "shaders/vfx_v.glsl","shaders/vfx_f.glsl"), 1)
geom.setShaderInput('distortion',0.9)
#geom.setShaderInput("fog", Vec4(0.4, 0.4, 0.4, 0.002))
geom.setShaderInput("color_gradient", color_gradient)
geom.setShaderInput("size_gradient", size_gradient)
geom.setShaderInput("shape_gradient", shape_gradient)
geom.setShaderInput("blend_gradient", blend_gradient)
#p.start(parent=self.root, renderParent = render)
return p
def createEffectFromGradients(
values, color_gradient, size_gradient, shape_gradient):
p = ParticleEffect()
loadValues(values, p)
blend_gradient = loader.loadTexture(
miscAssetPath + "/blend.png",
minfilter=Texture.FTNearest, magfilter=Texture.FTNearest)
color_gradient.setWrapU(Texture.WMClamp)
color_gradient.setWrapV(Texture.WMClamp)
size_gradient.setWrapU(Texture.WMClamp)
size_gradient.setWrapV(Texture.WMClamp)
shape_gradient.setWrapU(Texture.WMClamp)
shape_gradient.setWrapV(Texture.WMClamp)
blend_gradient.setWrapU(Texture.WMClamp)
blend_gradient.setWrapV(Texture.WMClamp)
for geom in p.findAllMatches('**/+GeomNode'):
geom.setDepthWrite(False)
geom.setBin("transparent", 31)
geom.setShader(
Shader.load(Shader.SLGLSL,
shaderPath + "/vfx_v.glsl",
shaderPath + "/vfx_f.glsl"), 1)
geom.setShaderInput('distortion', 0.51)
geom.setShaderInput("fog", Vec4(0.4, 0.4, 0.4, 0.002))
geom.setShaderInput("color_gradient", color_gradient)
geom.setShaderInput("size_gradient", size_gradient)
geom.setShaderInput("shape_gradient", shape_gradient)
geom.setShaderInput("blend_gradient", blend_gradient)
return p
def Water(self,model):
p1 = ParticleEffect()
p1.cleanup()
p1 = ParticleEffect()
p1.loadConfig(Filename(MYDIRPART+'fountain.ptf'))
p1.start(model)
p1.setPos(3.000, 0.000, 2.250)
def __init__(self, name, fireType):
NodePath.__init__(self, "fire" + str(name))
NodePath.setPythonTag(self, "fireSystem", self)
self.setScale(1, 1, 1)
self.fire = ParticleEffect()
self.fire.loadConfig('fire.ptf')
try:
file = open(fireType + ".txt")
lines = file.readlines()
newFireColor = LColor()
colorLine = lines[0].split(",")
for i in range(4):
newFireColor[i] = float(colorLine[i])
self.fire.getParticlesList()[0].getRenderer().setColor(
newFireColor)
self.lifeSpanSeconds = float(lines[1])
file.close()
except IOError:
print("Firetype not found")
self.lifeRemaining = self.lifeSpanSeconds
fireSphere = CollisionSphere(0, 0, 1.25, 2.5)
self.collisionNodeName = "fire{}Collision".format(self.id)
fireCollisionNode = CollisionNode(self.collisionNodeName)
fireCollisionNode.addSolid(fireSphere)
self.collision = self.attachNewNode(fireCollisionNode)
base.cTrav.addCollider(self.collision, base.handler)
self.fire.start(self, self)
self.fire.softStop()
self.burn = taskMgr.add(self.burnTask, "burnTask")
self.notifier = CollisionHandlerEvent
def loadParticleConfig(self, filename):
self.particle.cleanup()
self.particle = ParticleEffect()
self.particle.loadConfig(Filename(filename))
self.particle.start(self.bullet)
self.particle.setPos(0, 0, 0)
self.particle.setScale(10)
def __init__(self, id, common, node, render, moneyamount=1):
self.id = id
self.common = common
self.node = node
self.message = None
self.moneyamount = moneyamount
self.object = Actor("models/object",
{'rotate': 'models/object-rotate'})
self.object.setScale(0.20)
self.object.setZ(1.5)
self.object.reparentTo(render)
self.object.loop("rotate")
#Get last position of monster
(x, y, z) = self.node.getPos()
self.object.setPos((x, y, z + 0.5))
base.enableParticles()
#Load particles
self.pe = ParticleEffect()
self.pe.loadConfig(Filename("vfx/object.ptf"))
self.pe.start(parent=self.object, renderParent=self.object)
self.ambientLight = AmbientLight('ambientLight')
self.ambientLight.setColor(VBase4(.3, .3, .3, 1))
self.ambientLightNode = render.attachNewNode(self.ambientLight)
self.object.setLight(self.ambientLightNode)
taskMgr.doMethodLater(.1, self.update, 'random-object' + str(self.id))
def loadParticleConfig(self, filename, pos, object):
self.p.cleanup()
self.p = ParticleEffect()
self.p.loadConfig(Filename(filename))
self.p.start(object)
self.p.setPos(pos)
async def loadScene(self, task):
text = OnscreenText("Loading...")
self.terrain = await loader.loadModel(models["terrain"],
blocking=False)
self.terrain.reparentTo(render)
if USE_RENDER_PIPELINE:
rp.prepare_scene(self.terrain)
self.terrain.setScale(18)
modelList = parseMissionFile(self.map)
print(modelList)
for model in modelList:
try:
m = loader.loadModel("models/" + model.modelName)
m.reparentTo(self.terrain)
m.setPos(*model.modelPos)
except:
#Its a particle system
floater = render.attachNewNode("particle floater")
floater.setPos(self.terrain, *model.particlePos)
floater.setScale(5)
self.particles = ParticleEffect()
self.particles.loadConfig(model.ptfFile)
print(model.particlePos)
self.particles.start(parent=floater, renderParent=floater)
#self.particles.setPos(*model.particlePos)
#Once loaded, remove loading text
text.hide()
del text
self.loaded = True
def __init__(self, base):
self.base = base
self.p = Particles()
self.p.setFactory("PointParticleFactory")
self.p.setRenderer("LineParticleRenderer")
self.p.setEmitter("SphereSurfaceEmitter")
self.p.setPoolSize(256)
self.p.setBirthRate(0.01)
self.p.setLitterSize(256)
self.p.setSystemLifespan(2)
self.p.factory.setLifespanBase(5.0000)
self.p.renderer.setTailColor(Vec4(1.0, 1.0, 0.0, 1.0))
self.p.renderer.setHeadColor(Vec4(1.0, 0.0, 0.0, 1.0))
self.p.renderer.setAlphaMode(BaseParticleRenderer.PRALPHAOUT)
self.p.renderer.setUserAlpha(1.00)
self.p.renderer.setLineScaleFactor(32.00)
self.p.emitter.setRadius(2.0000)
self.p.setRenderParent(base.render)
self.p.enable()
self.pn = base.render.attachNewNode("particleExpNode")
# self.pn.setDepthWrite(False)
# self.pn.setBin("fixed", 0)
self.pe = ParticleEffect("exp-effect", self.p)
self.pe.reparentTo(self.pn)
self.pe.enable()
def attachTNT(self):
self.detachTNT()
self.tnt = Actor("phase_5/models/props/tnt-mod.bam",
{"chan": "phase_5/models/props/tnt-chan.bam"})
self.tnt.reparentTo(self.avatar.find('**/def_joint_right_hold'))
self.tntSparks = ParticleEffect()
self.tntSparks.loadConfig("phase_5/etc/tnt.ptf")
def __init__(self, pos, world):
self.id = next(Dorf.idgen)
self.world = world
self.node = loader.loadModel('media/models/dorfPH.egg')
self.text = core.TextNode('dorf')
self.text.setText('Dorf {}'.format(self.id))
self.text.setAlign(core.TextNode.ACenter)
self.text.setTextColor(1, 1, 0.5, 1)
self.text.setShadow(0.1, 0.1)
self.text.setShadowColor(0, 0, 0, 0.8)
self.textnode = self.node.attachNewNode(self.text)
self.textnode.setBillboardPointEye()
self.textnode.setPos(0, 0, 1.1)
self.textnode.setScale(0.4)
self.textnode.setDepthWrite(False)
self.textnode.setDepthTest(False)
self.textnode.setShaderOff()
self.x = int(pos.x)
self.y = int(pos.y)
self.z = 0
self.next = None
self.dir = (1, 0)
taskMgr.doMethodLater(0.5, self.move, 'Move dorf')
self.set_z(int(pos.z))
self.node.setPos(pos.x, pos.y, 0)
self.particles = ParticleEffect()
self.particles.loadConfig('media/sparks.ptf')
self.particles.reparentTo(self.node)
def SmokeRing(self,model):
p1 = ParticleEffect()
p1.cleanup()
p1 = ParticleEffect()
p1.loadConfig(Filename(MYDIRPART+'smokering.ptf'))
p1.start(model)
p1.setPos(0, 0.000, 0)
def test_particle_burst_emission():
effect = ParticleEffect()
system = Particles("testSystem", 10)
effect.add_particles(system)
# Setup some dummy nodes, since it seems to want them
# We might normally call "start", but that calls "enable", which
# seems to assume that "base" exists and has physics and particle managers...
system.setRenderParent(NodePath(PandaNode("test")))
system.setSpawnRenderNodePath(NodePath(PandaNode("test")))
# However, we don't want normal emission, so we now soft-stop it immediately,
# before the system has a chance to update and emit.
effect.softStop()
# Now, a sanity-check: assert that we have no particles,
# Then update the system, and assert again that we
# have no particles. If so, then we're (hopefully)
# not emitting normally!
assert system.getLivingParticles() == 0
system.update(1)
assert system.getLivingParticles() == 0
# Now, the real test: emit a particle-burst!
effect.birthLitter()
# And assert that a particle has, in fact, been emitted.
assert system.getLivingParticles() == 1
# Check the snake-case version, too.
effect.birth_litter()
assert system.getLivingParticles() == 2
def softStop(self):
try:
ParticleEffect.softStop(self)
except:
return
self.__startCleanupTask()
def startInPos(self, pos, level, life=0):
# self.reparentTo(scene.Base.render)
#self.setPos(scene.Base.render,pos)
ParticleEffect.start(self,parent=level.Base.render, renderParent=level.Base.render)
self.setPos(pos)
if life != 0:
level.Base.taskMgr.doMethodLater(life, self.__cleanup, self.name + "+automaticCleanup")
class Application(ShowBase):
def __init__(self):
ShowBase.__init__(self)
self.enableParticles()
particles = Particles()
particles.setPoolSize(1000)
particles.setBirthRate(0.1)
particles.setLitterSize(10)
particles.setLitterSpread(3)
particles.setFactory("PointParticleFactory")
particles.setRenderer("GeomParticleRenderer")
particles.setEmitter("SphereVolumeEmitter")
smiley = loader.loadModel("smiley")
smiley.setScale(0.1)
particles.getRenderer().setGeomNode(smiley.node())
particles.enable()
self.effect = ParticleEffect("peffect", particles)
self.effect.reparentTo(render)
self.effect.enable()
self.cam.setPos(0, -10, 0)
def createEffect(values):
p = ParticleEffect()
loadValues(values, p)
color_gradient = loader.loadTexture(values["color_gradient"])
size_gradient = loader.loadTexture(values["size_gradient"])
shape_gradient = loader.loadTexture(values["shape_gradient"])
blend_gradient = loader.loadTexture("data/vfx/blend.png",
minfilter=Texture.FTNearest,
magfilter=Texture.FTNearest)
color_gradient.setWrapU(Texture.WMClamp)
color_gradient.setWrapV(Texture.WMClamp)
#color_gradient.setFormat(Texture.F_srgb_alpha)
size_gradient.setWrapU(Texture.WMClamp)
size_gradient.setWrapV(Texture.WMClamp)
shape_gradient.setWrapU(Texture.WMClamp)
shape_gradient.setWrapV(Texture.WMClamp)
blend_gradient.setWrapU(Texture.WMClamp)
blend_gradient.setWrapV(Texture.WMClamp)
for geom in p.findAllMatches('**/+GeomNode'):
geom.setDepthWrite(False)
geom.hide(BitMask32.bit(1))
geom.hide(BitMask32.bit(2))
geom.setShader(
Shader.load(Shader.SLGLSL, "data/shaders/vfx_v.glsl",
"data/shaders/vfx_f.glsl"), 1)
geom.setShaderInput('distortion', values['distortion'])
geom.setShaderInput("fog", Vec4(0.4, 0.4, 0.4, 0.002))
geom.setShaderInput("color_gradient", color_gradient)
geom.setShaderInput("size_gradient", size_gradient)
geom.setShaderInput("shape_gradient", shape_gradient)
geom.setShaderInput("blend_gradient", blend_gradient)
p.start(parent=render, renderParent=render)
return p
def createEffect(values):
p = ParticleEffect()
loadValues(values, p)
color_gradient = loader.loadTexture(values["color_gradient"])
size_gradient = loader.loadTexture(values["size_gradient"])
shape_gradient = loader.loadTexture(values["shape_gradient"])
blend_gradient = loader.loadTexture("data/blend.png",
minfilter=Texture.FTNearest,
magfilter=Texture.FTNearest)
color_gradient.setWrapU(Texture.WMClamp)
color_gradient.setWrapV(Texture.WMClamp)
color_gradient.setFormat(Texture.F_srgb_alpha)
size_gradient.setWrapU(Texture.WMClamp)
size_gradient.setWrapV(Texture.WMClamp)
shape_gradient.setWrapU(Texture.WMClamp)
shape_gradient.setWrapV(Texture.WMClamp)
blend_gradient.setWrapU(Texture.WMClamp)
blend_gradient.setWrapV(Texture.WMClamp)
for geom in p.findAllMatches('**/+GeomNode'):
geom.setDepthWrite(False)
#geom.setBin("transparent", 31)
#need to hide it from the water and shadow camera now... I don't know hot to get the geom later :(
geom.hide(BitMask32.bit(1))
geom.hide(BitMask32.bit(2))
geom.setShader(
Shader.load(Shader.SLGLSL, "shaders/vfx_v.glsl",
"shaders/vfx_f.glsl"), 1)
geom.setShaderInput('distortion', values['distortion'])
#geom.setShaderInput("fog", Vec4(0.4, 0.4, 0.4, 0.002))
geom.setShaderInput("color_gradient", color_gradient)
geom.setShaderInput("size_gradient", size_gradient)
geom.setShaderInput("shape_gradient", shape_gradient)
geom.setShaderInput("blend_gradient", blend_gradient)
#p.start(parent=self.root, renderParent = render)
return p
def __createToonInterval(self, delay):
track = Sequence(Wait(delay))
sprayEffect = ParticleEffect()
sprayEffect.loadConfig('phase_5/etc/soundWave.ptf')
sprayEffect.setDepthWrite(0)
sprayEffect.setDepthTest(0)
sprayEffect.setTwoSided(1)
I1 = 2.8
track.append(
ActorInterval(self.avatar,
'sound',
playRate=1.0,
startTime=0.0,
endTime=I1))
track.append(
Func(self.setPosFromOther, sprayEffect, self.gag,
Point3(0, 1.6, -0.18)))
track.append(
self.__getPartTrack(sprayEffect,
0.0,
6.0, [sprayEffect, self.avatar, 0],
softStop=-3.5))
track.append(
ActorInterval(self.avatar, 'sound', playRate=1.0, startTime=I1))
return track
def __init__(self, identifiantLanceur,mondePhysique):
self.mondePhysique = mondePhysique
self.lanceurId = identifiantLanceur
self.balleId = Balle.balleID
Balle.balleID += 1
self.forceApplique = Vec3(0,0,0)
# On charge le modèles
self.modele = loader.loadModel("../asset/Balle/ball")
self.modele.reparentTo(render)
#On réduit sa taille un peu...
self.modele.setScale(0.5,0.5,0.5)
#On ajoute une sphere de physique
forme = BulletSphereShape(0.2)
noeud = BulletRigidBodyNode("Balle")
noeud.addShape(forme)
self.noeudPhysique = render.attachNewNode(noeud)
self.noeudPhysique.node().setMass(1.0)
self.modele.reparentTo(self.noeudPhysique)
self.accept("detonateur-explosion",self.detonateurDistance)
self.noeudPhysique.setTag("EntiteTankem","Balle")
self.noeudPhysique.setTag("balleId",str(self.balleId))
self.noeudPhysique.setTag("lanceurId",str(self.lanceurId))
self.pftExplosion = ParticleEffect()
self.pftExplosion.loadConfig("../asset/Particle/tankemExplode.ptf")
self.pftRacine = NodePath("Racine pfx expolision")
self.pftRacine.reparentTo(render)
def explode(self):
self.ignoreAll()
self.cNode.setIntoCollideMask(BitMask32.allOff())
taskMgr.remove(self.moveTask)
taskMgr.remove(self.mouseTask)
taskMgr.remove(self.zoomTaskPointer)
self.moveTask = 0
self.mouseTask = 0
if self.contrail != 0:
self.contrail.cleanup()
self.modelNode.hide()
self.contrail = ParticleEffect()
self.contrail.loadConfig('media/explosion.ptf')
self.contrail.start(self.node)
self.contrail.setLightOff()
self.contrail2.cleanup()
#add explosion sound
#------------------------------------------------------------------------------
self.audio3d = Audio3DManager.Audio3DManager(base.sfxManagerList[0],
base.camera)
self.audio3d.setDropOffFactor(0.2)
self.Sound = self.audio3d.loadSfx('explosion.mp3')
self.audio3d.detachSound(self.Sound)
self.audio3d.attachSoundToObject(self.Sound, self.node)
#self.Sound.play()
#------------------------------------------------------------------------------
self.deleteTask = taskMgr.doMethodLater(4, self.deleteTask,
'delete task')
def __init__(self, model, id_, y_positions, enemy_handler, class_data):
EnemyMotorcyclist.__init__(self, id_, "Kamikaze", class_data, model,
y_positions, enemy_handler)
self._train_captured = False
self._explosion_col_np = None
self.is_jumping = False
self._side = "left" if self._y_pos > 0 else "right"
self._jump_path = Mopath.Mopath(
objectToLoad=loader.loadModel( # noqa: F821
address(self._side[0] + "_kamikaze_jump")))
self._jump_path.fFaceForward = True
self._jump_snd = base.sound_mgr.loadSfx(
"sounds/moto_jump.ogg") # noqa: F821
base.sound_mgr.attachSoundToObject(self._jump_snd,
self.model) # noqa: F821
self._wick_snd = base.sound_mgr.loadSfx(
"sounds/combat/wick.ogg") # noqa: F821
base.sound_mgr.attachSoundToObject(self._wick_snd,
self.model) # noqa: F821
self._wick = ParticleEffect()
self._fire_ring = ParticleEffect()
self._fire_ring.loadConfig("effects/fire_ring.ptf")
self._fire_ring.setZ(0.2)
def Smoke(self,model):
p1 = ParticleEffect()
p1.cleanup()
p1 = ParticleEffect()
p1.loadConfig(Filename(MYDIRPART+'smoke.ptf'))
p1.start(model)
p1.setPos(3.000, 0.000, 2.250)
def __init__(self):
ParticleEffect.__init__(self)
self.reset()
self.setPos(0.000, 0.000, 0.000)
self.setHpr(0.000, 0.000, 0.000)
self.setScale(1.000, 1.000, 1.000)
p0 = Particles('particles-1')
# Particles parameters
p0.setFactory("PointParticleFactory")
p0.setRenderer("SpriteParticleRenderer")
p0.setEmitter("SphereVolumeEmitter")
p0.setPoolSize(1024)
p0.setBirthRate(0.0200)
p0.setLitterSize(1)
p0.setLitterSpread(0)
p0.setSystemLifespan(0.0000)
p0.setLocalVelocityFlag(1)
p0.setSystemGrowsOlderFlag(0)
# Factory parameters
p0.factory.setLifespanBase(3.0000)
p0.factory.setLifespanSpread(0.0000)
p0.factory.setMassBase(1.0000)
p0.factory.setMassSpread(0.0000)
p0.factory.setTerminalVelocityBase(400.0000)
p0.factory.setTerminalVelocitySpread(0.0000)
# Point factory parameters
# Renderer parameters
p0.renderer.setAlphaMode(BaseParticleRenderer.PRALPHAUSER)
p0.renderer.setUserAlpha(1.00)
# Sprite parameters
p0.renderer.addTextureFromFile('./image/particle.png')
p0.renderer.setColor(Vec4(0.40, 0.40, 1.00, 0.50))
p0.renderer.setXScaleFlag(0)
p0.renderer.setYScaleFlag(0)
p0.renderer.setAnimAngleFlag(0)
p0.renderer.setInitialXScale(0.03000)
p0.renderer.setFinalXScale(1.0000)
p0.renderer.setInitialYScale(0.03000)
p0.renderer.setFinalYScale(1.0000)
p0.renderer.setNonanimatedTheta(0.0000)
p0.renderer.setAlphaBlendMethod(BaseParticleRenderer.PPBLENDLINEAR)
p0.renderer.setAlphaDisable(0)
# Emitter parameters
p0.emitter.setEmissionType(BaseParticleEmitter.ETRADIATE)
p0.emitter.setAmplitude(0.5000)
p0.emitter.setAmplitudeSpread(0.0000)
p0.emitter.setOffsetForce(Vec3(0.0000, 0.0000, 0.0000))
p0.emitter.setExplicitLaunchVector(Vec3(1.0000, 0.0000, 0.0000))
p0.emitter.setRadiateOrigin(Point3(0.0000, 0.0000, 0.0000))
# Sphere Volume parameters
p0.emitter.setRadius(0.0100)
self.addParticles(p0)
f0 = ForceGroup('force-1')
# Force parameters
force0 = LinearVectorForce(Vec3(0.0000, 0.0000, -1.0000), 3.0000, 0)
force0.setVectorMasks(1, 1, 1)
force0.setActive(1)
f0.addForce(force0)
self.addForceGroup(f0)
def __init__(self):
#sys.path.append('../game')
#Standard title and instruction text
self.title = OnscreenText(
text="PSG: Test - Explosion",
style=1, fg=(1,1,1,1), pos=(0.9,-0.95), scale = .07)
self.escapeEvent = OnscreenText(
text=HELPTEXT,
style=1, fg=(1,1,1,1), pos=(-1.3, 0.95),
align=TextNode.ALeft, scale = .05)
#More standard initialization
self.accept('escape', sys.exit)
self.accept('1', self.loadParticleConfig , ['explosion1.ptf'])
self.accept('2', self.loadParticleConfig , ['explosion2.ptf'])
self.accept('3', self.loadParticleConfig , ['explosion3.ptf'])
self.accept('4', self.loadParticleConfig , ['explosion4.ptf'])
self.accept('5', self.loadParticleConfig , ['explosion5.ptf'])
self.accept('6', self.loadParticleConfig , ['explosion6.ptf'])
self.accept('escape', sys.exit)
base.disableMouse()
camera.setPos(0,-20,2)
base.setBackgroundColor( 0, 0, 0 )
#This command is required for Panda to render particles
base.enableParticles()
self.t = loader.loadModel("../data/models/ship_03.egg")
self.t.setScale(0.5)
self.t.setHpr(180, 0, 0)
self.t.setPos(0,10,0)
self.t.reparentTo(render)
self.setupLights()
self.p = ParticleEffect()
self.loadParticleConfig('explosion1.ptf')
def __init__(self):
self.node = 0 #the player main node
self.gnodePath = 0 #node to phisics
self.gNode = 0 #node of gravity
self.gNodePath = 0 #node path to actorNode
self.modelNode = 0 #the node of the actual model
self.cNode = 0 #the player collision node attached to node
self.cNodePath = 0 #node path to cNode
self.contrail = ParticleEffect(
) #QUANDO BATE, CRIA EFEITO (LINHA DE BAIXO TB)
self.contrail.setTransparency(TransparencyAttrib.MDual)
self.contrail2 = ParticleEffect(
) #QUANDO ACIONA TURBO, CRIA EFEITO (LINHA DE BAIXO TB)
self.contrail2.setTransparency(TransparencyAttrib.MDual)
self.landing = False
self.freeLook = False
self.speed = 10
self.speedMax = 100
self.agility = 3
self.HP = 10
self.collisionHandler = CollisionHandlerEvent(
) # the collision handlers
self.collisionHandlerQueue = CollisionHandlerQueue()
self.zoom = -5
#self
self.textSpeed = OnscreenText(text='Speed: ' + str(self.speed),
pos=(-1.34, 0.95),
scale=0.07,
fg=(1, 1, 1, 1),
bg=(0.2, 0.2, 0.2, 0.4),
align=TextNode.ALeft)
self.textHP = OnscreenText(text='Health: ' + str(self.HP),
pos=(-1.33, 0.85),
scale=0.07,
fg=(1, 1, 1, 1),
bg=(0.2, 0.2, 0.2, 0.4),
align=TextNode.ALeft)
self.roll = 0
self.camHeight = 0
base.win.movePointer(0,
base.win.getXSize() / 2,
base.win.getYSize() / 2)
self.myImage = OnscreenImage(image='cursor.png',
pos=(0, 0, -0.02),
scale=(0.05))
self.myImage.setTransparency(TransparencyAttrib.MAlpha)
self.loadModel()
self.addCamera()
self.addEvents()
self.addCollisions()
self.addSound()
self.moveTask = taskMgr.add(self.moveUpdateTask, 'move-task')
self.mouseTask = taskMgr.add(self.mouseUpdateTask, 'mouse-task')
self.zoomTaskPointer = taskMgr.add(self.zoomTask, 'zoom-task')
def Flame(self,model):
p1 = ParticleEffect()
p1.cleanup()
p1 = ParticleEffect()
p1.loadConfig(Filename('ee.ptf'))#'fireish.ptf'))
p1.start(model)
p1.setPos(3.000, 0.000, 2.250)
setupLights(self,model)
def loadParticleConfig(self,file): #Start of the code from steam.ptf self.p.cleanup() self.p = ParticleEffect() self.p.loadConfig(Filename(file)) #Sets particles to birth relative to the teapot, but to render at toplevel self.p.start(self.t) self.p.setPos(0.000, 0.000, 0.00)
def loadParticleConfig(self, filename):
# Start of the code from steam.ptf
self.p.cleanup()
self.p = ParticleEffect()
self.p.loadConfig(Filename(filename))
self.p.start(self.t)
self.p.setPos(3.000, 0.000, 2.250)
def __init__(self): #Class constructor
self.node = 0 #the player main node
self.modelNode = 0 #the node of the actual model
self.cNode = 0 #the player collision node attached to node
self.cNodePath = 0 #node path to cNode
self.contrail = ParticleEffect(
) #QUANDO BATE, CRIA EFEITO (LINHA DE BAIXO TB)
self.contrail.setTransparency(TransparencyAttrib.MDual)
self.contrail2 = ParticleEffect(
) #QUANDO ACIONA TURBO, CRIA EFEITO (LINHA DE BAIXO TB)
self.contrail2.setTransparency(TransparencyAttrib.MDual)
self.landing = False
self.freeLook = False
self.speed = 70
self.speedMax = 100
self.agility = 5
self.HP = 10
self.collisionHandler = CollisionHandlerEvent(
) # the collision handlers
self.collisionHandlerQueue = CollisionHandlerQueue()
self.zoom = -5
self.gnodePath = 0 #node to phisics
self.gNode = 0 #node of gravity
self.gNodePath = 0 #node path to actorNode
self.msg = MessageManager()
self.roll = 0
self.camHeight = 0
global actualScore
global firstRun
firstRun = 0
self.thisScore = OnscreenText(text='Score: ' + str(actualScore),
pos=(1.32, 0.95),
scale=0.07,
fg=(1, 1, 1, 1),
bg=(0.2, 0.2, 0.2, 0.4),
align=TextNode.ARight)
self.death = 0
self.ultimaColisao = "InicioUltimaColisao"
self.atualColisao = "InicioAtualColisao"
base.win.movePointer(0,
base.win.getXSize() / 2,
base.win.getYSize() / 2)
self.myImage = OnscreenImage(image='cursor.png',
pos=(0, 0, -0.02),
scale=(0.05))
self.myImage.setTransparency(TransparencyAttrib.MAlpha)
self.loadModel()
self.addCamera()
self.addEvents()
self.addCollisions()
self.addSound()
self.moveTask = taskMgr.add(self.moveUpdateTask, 'move-task')
self.mouseTask = taskMgr.add(self.mouseUpdateTask, 'mouse-task')
self.zoomTaskPointer = taskMgr.add(self.zoomTask, 'zoom-task')
def createMyParticle(self, size):
particle = ParticleEffect()
smokeEffect = self.path + "smoke.ptf"
particle.loadConfig(Filename(smokeEffect))
p0 = particle.particlesDict['particles']
p0.emitter.setOffsetForce(Vec3(0.0, 0.0, 0.0))
p0.factory.setLifespanBase(0.3 * size)
p0.setPoolSize(200)
return particle
def __init__(self):
ParticleEffect.__init__(self)
self.reset()
self.setPos(0.000, 0.000, 0.000)
self.setHpr(0.000, 0.000, 0.000)
self.setScale(1.000, 1.000, 1.000)
p0 = Particles('particles-1')
# Particles parameters
p0.setFactory("ZSpinParticleFactory")
p0.setRenderer("SpriteParticleRenderer")
p0.setEmitter("LineEmitter")
p0.setPoolSize(1024)
p0.setBirthRate(0.3000)
p0.setLitterSize(1)
p0.setLitterSpread(0)
p0.setSystemLifespan(0.0000)
p0.setLocalVelocityFlag(0)
p0.setSystemGrowsOlderFlag(0)
# Factory parameters
p0.factory.setLifespanBase(15.0000)
p0.factory.setLifespanSpread(0.0000)
p0.factory.setMassBase(1.0000)
p0.factory.setMassSpread(0.0000)
p0.factory.setTerminalVelocityBase(400.0000)
p0.factory.setTerminalVelocitySpread(0.0000)
# Z Spin factory parameters
p0.factory.setInitialAngle(0.0000)
p0.factory.setInitialAngleSpread(0.0000)
p0.factory.enableAngularVelocity(1)
p0.factory.setAngularVelocity(60.0000)
p0.factory.setAngularVelocitySpread(10.0000)
# Renderer parameters
p0.renderer.setAlphaMode(BaseParticleRenderer.PRALPHAUSER)
p0.renderer.setUserAlpha(0.20)
# Sprite parameters
p0.renderer.addTextureFromFile('./image/star_particle.png')
p0.renderer.setColor(Vec4(1.00, 1.00, 1.00, 1.00))
p0.renderer.setXScaleFlag(0)
p0.renderer.setYScaleFlag(0)
p0.renderer.setAnimAngleFlag(1)
p0.renderer.setInitialXScale(0.0500)
p0.renderer.setInitialYScale(0.0500)
p0.renderer.setNonanimatedTheta(0.0000)
p0.renderer.setAlphaBlendMethod(BaseParticleRenderer.PPBLENDLINEAR)
p0.renderer.setAlphaDisable(0)
# Emitter parameters
p0.emitter.setEmissionType(BaseParticleEmitter.ETEXPLICIT)
p0.emitter.setAmplitude(0.1500)
p0.emitter.setAmplitudeSpread(0.0500)
p0.emitter.setOffsetForce(Vec3(0.0000, 0.0000, 0.0000))
p0.emitter.setExplicitLaunchVector(Vec3(0.0000, 0.0000, -1.0000))
p0.emitter.setRadiateOrigin(Point3(0.0000, 0.0000, 0.0000))
# Line parameters
p0.emitter.setEndpoint1(Point3(-1.0000, 0.0000, 0.0000))
p0.emitter.setEndpoint2(Point3(1.0000, 0.0000, 0.0000))
self.addParticles(p0)
def initialize(self):
smokeEffect = self.warsim.path + "smoke.ptf"
self.particle = ParticleEffect()
self.particle.loadConfig(Filename(smokeEffect))
self.litterMin = 1.0
# rough estimate based on masses that are around 50000->120000. gets the max litter down to 25 -> 60
self.litterMax = self.warsim.myShip.mass / 2500.0
self.litterSize = self.litterMin
self.particleStarted = False
def __init__(self, parent=None, name=None):
global PARTICLES_ENABLED
if not PARTICLES_ENABLED:
base.enableParticles()
PARTICLES_ENABLED = True
# define the name of this object
VirtualNodeWrapper.__init__(self, parent, name,
PARTICLE_WRAPPER_DUMMYOBJECT)
self.particleSystem = ParticleEffect()
def init_player(self, left_btn, right_btn, player_number ,pos=(0,0,0), heading=0):
color = (configs.COLORS_MAP[player_number][0])
nodePath = loadObject()
nodePath.setPos(pos)
nodePath.setScale(configs.SCALE*0.004)
nodePath.setColor(color)
p = ParticleEffect()
p.loadConfig('textures/flare.ptf')
p.start(parent = nodePath, renderParent = render)
p0 = p.getParticlesList()[0]
p0.emitter.setRadiateOrigin(Point3(0.05*cos(heading* pi/180), 0.0, 0.05*sin(heading* pi/180)))
p.setPos(0,-1,0)
# p.setBin("unsorted", 0)
# p.setDepthTest(False)
p.setTwoSided(True)
text= TextNode('text')
text.setText(str("%s" % player_number))
text.setTextColor(color)
text.setAlign(TextNode.ACenter)
# text.font = self.font
text3d = NodePath(text)
text3d.setTwoSided(True)
text3d.setPos(nodePath, -1,-3,-4)
text3d.reparentTo(render)
circle = loadObject(tex='circle.png')
circle.reparentTo(render)
circle.setPos(nodePath, 0,-2,0)
text3d.setScale(0.13)
circle.setScale(0.09)
text3d.setColorScale(color)
circle.setColorScale(color)
new_line, line_vertex, line_node = start_new_line(self, pos[0], pos[2], color)
line_id = configs.ENTITY_ID
configs.ENTITIES[configs.ENTITY_ID] = {'CATEGORY':'line', 'GEOM':new_line, 'VERTEX':line_vertex, "NODE": line_node}
configs.ENTITY_ID += 1
speed = configs.FORWARD_SPEED
right_angle = configs.FORCE_RIGHT_ANGLE_TURN
# print left_btn
# print right_btn
self.accept(("%s" % left_btn), player_controls, [configs.ENTITY_ID, 'TURN_LEFT', 1])
self.accept(("%s-up" % left_btn), player_controls, [configs.ENTITY_ID, 'TURN_LEFT', 0])
self.accept(("%s" % right_btn), player_controls, [configs.ENTITY_ID, 'TURN_RIGHT', 1])
self.accept(("%s-up" % right_btn), player_controls, [configs.ENTITY_ID, 'TURN_RIGHT', 0])
configs.ENTITIES[configs.ENTITY_ID] = {'CATEGORY':'player','ALIVE':True, 'NODE':nodePath,'PARTICLE_PARENT':p, 'PARTICLE':p0,
'HEADING':heading, 'CURRENT_LINE':line_id, 'TICKNESS':configs.SCALE, 'TURN_LEFT':0, 'TURN_RIGHT':0, 'COLOR':color,
'PLAYER_ID':text3d, 'CIRCLE_NODE':circle, 'LEFT_ARMED':True, 'RIGHT_ARMED':True, 'PLAYER_NUMBER': player_number, 'SPEED':speed,
'RIGHT_ANGLE_TURN':right_angle }
configs.ENTITY_ID += 1
class ParticleDemo(ShowBase):
def __init__(self):
ShowBase.__init__(self)
# Standard title and instruction text
self.title = OnscreenText(
text="Panda3D: Tutorial - Particles",
parent=base.a2dBottomCenter,
style=1, fg=(1, 1, 1, 1), pos=(0, 0.1), scale=.08)
self.escapeEvent = OnscreenText(
text=HELP_TEXT, parent=base.a2dTopLeft,
style=1, fg=(1, 1, 1, 1), pos=(0.06, -0.06),
align=TextNode.ALeft, scale=.05)
# More standard initialization
self.accept('escape', sys.exit)
self.accept('1', self.loadParticleConfig, ['steam.ptf'])
self.accept('2', self.loadParticleConfig, ['dust.ptf'])
self.accept('3', self.loadParticleConfig, ['fountain.ptf'])
self.accept('4', self.loadParticleConfig, ['smoke.ptf'])
self.accept('5', self.loadParticleConfig, ['smokering.ptf'])
self.accept('6', self.loadParticleConfig, ['fireish.ptf'])
self.accept('escape', sys.exit)
base.disableMouse()
base.camera.setPos(0, -20, 2)
base.camLens.setFov(25)
base.setBackgroundColor(0, 0, 0)
# This command is required for Panda to render particles
base.enableParticles()
self.t = loader.loadModel("teapot")
self.t.setPos(0, 10, 0)
self.t.reparentTo(render)
self.setupLights()
self.p = ParticleEffect()
self.loadParticleConfig('steam.ptf')
def loadParticleConfig(self, filename):
# Start of the code from steam.ptf
self.p.cleanup()
self.p = ParticleEffect()
self.p.loadConfig(Filename(filename))
# Sets particles to birth relative to the teapot, but to render at
# toplevel
self.p.start(self.t)
self.p.setPos(3.000, 0.000, 2.250)
# Setup lighting
def setupLights(self):
ambientLight = AmbientLight("ambientLight")
ambientLight.setColor((.4, .4, .35, 1))
directionalLight = DirectionalLight("directionalLight")
directionalLight.setDirection(LVector3(0, 8, -2.5))
directionalLight.setColor((0.9, 0.8, 0.9, 1))
# Set lighting on teapot so steam doesn't get affected
self.t.setLight(self.t.attachNewNode(directionalLight))
self.t.setLight(self.t.attachNewNode(ambientLight))
def drain(self, task):
if self.draining and task.time - self.drainTime > DRAIN_DELAY:
carpos = self.staticCars[self.target].getPos()
playerpos = self.player.getPos()
dist = math.sqrt( (carpos[0] - playerpos[0])**2 + (carpos[1] - playerpos[1])**2 + (carpos[2] - playerpos[2])**2 )
if self.gasList[self.target] > 0 and dist < DRAIN_DIST:
if not self.gasPlaying:
self.gasP.reset()
self.gasP = ParticleEffect()
self.gasP.loadConfig(Filename('oil.ptf'))
self.gasP.start(self.player)
self.gasNode.lookAt(self.staticCars[self.target])
self.gasP.setPos(0,0,2)
self.gasP.setScale(1.5)
self.gasP.setLightOff()
self.gasPlaying = True
self.alan_var = False
self.gasNode.lookAt(self.staticCars[self.target])
self.gasP.setHpr(self.gasNode.getH() + 180, 90, 0)
self.player.totalGas = self.player.totalGas + 1
self.gasList[self.target] = self.gasList[self.target] - 1
else:
self.alan_var = True
# print "TotalGas: " + str(self.player.totalGas)
self.drainTime = task.time
elif not self.draining or self.alan_var:
self.gasP.softStop()
self.drainSound.stop()
self.gasPlaying = False
return Task.cont
def load_config(self, file_name):
self.p.cleanup()
self.p = ParticleEffect()
self.p.loadConfig(file_name)
self.p.start(render)
self.p.setPos(self.x, self.y, self.z)
self.p.reparentTo(self.parent)
def addParticle(self, pipe):
#Particle Effect: VERY SLOW
self.particle = ParticleEffect()
self.particle.loadConfig("../models/steam.ptf")
self.particle.start(pipe)
self.particle.setPos(100.00, 0.000, 0)
self.particle.setScale(100.00, 80.00, 80.00)
def useThunder(self):
self.onThunder = True
self.pokeCandyCount -= 1
self.thunder = ParticleEffect()
self.thunder.loadConfig("thunder.ptf")
self.thunder.start(parent=render, renderParent=render)
self.use.play()
def __init__(self, main, username, pos = LVecBase3(-5, -5, 1), isCurrentPlayer = False, carId=3):
self.username = username
self.main = main
self.isCurrentPlayer = isCurrentPlayer
self.boostCount = 0
self.boostActive = False
self.boostStep = 2
self.boostDuration = 0
self.moveStartTime = self.startTime = self.boostStartTime = time.time()
self.pos = pos
self.boostFactor = 1.2
self.specs = {"mass": 800.0,
"maxWheelForce": 2000.0,
"brakeForce": 100.0,
"steeringLock": 45.0,
"maxSpeed": 33.0,
"maxReverseSpeed": 10.0}
self.vehicleControlState = {"throttle": 0, "reverse": False, "brake": 0.0, "steering": 0.0, "health": 1}
# Steering change per second, normalised to steering lock
# Eg. 45 degrees lock and 1.0 rate means 45 degrees per second
self.steeringRate = 0.8
self.centreingRate = 1.2
self.speed = 0
self.setupVehicle(main)
self.props = VehicleProps(carId)
self.currentPowerups = {"powerup1": None, "powerup2": None, "powerup3": None}
if isCurrentPlayer:
#This command is required for Panda to render particles
base.enableParticles()
self.p = ParticleEffect()
def __init__(self, pos, world):
self.id = next(Dorf.idgen)
self.world = world
self.node = loader.loadModel('media/models/dorfPH.egg')
self.text = core.TextNode('dorf')
self.text.setText('Dorf {}'.format(self.id))
self.text.setAlign(core.TextNode.ACenter)
self.text.setTextColor(1, 1, 0.5, 1)
self.text.setShadow(0.1, 0.1)
self.text.setShadowColor(0, 0, 0, 0.8)
self.textnode = self.node.attachNewNode(self.text)
self.textnode.setBillboardPointEye()
self.textnode.setPos(0, 0, 1.1)
self.textnode.setScale(0.4)
self.textnode.setDepthWrite(False)
self.textnode.setDepthTest(False)
self.textnode.setShaderOff()
self.x = int(pos.x)
self.y = int(pos.y)
self.z = 0
self.next = None
self.dir = (1, 0)
taskMgr.doMethodLater(0.5, self.move, 'Move dorf')
self.set_z(int(pos.z))
self.node.setPos(pos.x, pos.y, 0)
self.particles = ParticleEffect()
self.particles.loadConfig('media/sparks.ptf')
self.particles.reparentTo(self.node)
def fire(self):
self.fire = ParticleEffect()
self.fire.reset()
self.fire.setPos(0.000, 0.000, 0.000)
self.fire.setHpr(0.000, 0.000, 0.000)
self.fire.setScale(10.000, 10.000, 10.000)
p0 = Particles('particles-1')
# Particles parameters
p0.setFactory("PointParticleFactory")
p0.setRenderer("SpriteParticleRenderer")
p0.setEmitter("DiscEmitter")
p0.setPoolSize(1024)
p0.setBirthRate(0.0200)
p0.setLitterSize(10)
p0.setLitterSpread(0)
p0.setSystemLifespan(1200.0000)
p0.setLocalVelocityFlag(1)
p0.setSystemGrowsOlderFlag(0)
# Factory parameters
p0.factory.setLifespanBase(2.0000)
p0.factory.setLifespanSpread(0.0000)
p0.factory.setMassBase(1.0000)
p0.factory.setMassSpread(0.0000)
p0.factory.setTerminalVelocityBase(400.0000)
p0.factory.setTerminalVelocitySpread(0.0000)
# Point factory parameters
# Renderer parameters
p0.renderer.setAlphaMode(BaseParticleRenderer.PRALPHAOUT)
p0.renderer.setUserAlpha(0.22)
# Sprite parameters
p0.renderer.addTextureFromFile('models/gamedev/sparkle.png')
p0.renderer.setColor(Vec4(1.00, 1.00, 1.00, 1.00))
p0.renderer.setXScaleFlag(1)
p0.renderer.setYScaleFlag(1)
p0.renderer.setAnimAngleFlag(0)
p0.renderer.setInitialXScale(0.5000)
p0.renderer.setFinalXScale(2.0000)
p0.renderer.setInitialYScale(1.0000)
p0.renderer.setFinalYScale(2.0000)
p0.renderer.setNonanimatedTheta(0.0000)
p0.renderer.setAlphaBlendMethod(BaseParticleRenderer.PPNOBLEND)
p0.renderer.setAlphaDisable(0)
# Emitter parameters
p0.emitter.setEmissionType(BaseParticleEmitter.ETRADIATE)
p0.emitter.setAmplitude(1.0000)
p0.emitter.setAmplitudeSpread(0.0000)
p0.emitter.setOffsetForce(Vec3(0.0000, 0.0000, 3.0000))
p0.emitter.setExplicitLaunchVector(Vec3(1.0000, 0.0000, 0.0000))
p0.emitter.setRadiateOrigin(Point3(0.0000, 0.0000, 0.0000))
# Disc parameters
p0.emitter.setRadius(0.5000)
self.fire.addParticles(p0)
self.fire.setPos(self.playerModel2.getPos())
t = Sequence(Func(self.fire.start, render, render),Wait(20),Func(self.cleanFire))
t.start()
def __createToonInterval(self, delay):
track = Sequence(Wait(delay))
sprayEffect = ParticleEffect()
sprayEffect.loadConfig('phase_5/etc/soundWave.ptf')
sprayEffect.setDepthWrite(0)
sprayEffect.setDepthTest(0)
sprayEffect.setTwoSided(1)
I1 = 2.8
track.append(ActorInterval(self.avatar, 'sound', playRate=1.0, startTime=0.0, endTime=I1))
track.append(Func(self.setPosFromOther, sprayEffect, self.gag, Point3(0, 1.6, -0.18)))
track.append(self.__getPartTrack(sprayEffect, 0.0, 6.0, [sprayEffect, self.avatar, 0], softStop=-3.5))
track.append(ActorInterval(self.avatar, 'sound', playRate=1.0, startTime=I1))
return track
def loadParticleConfig(self, filename):
self.particle.cleanup()
self.particle = ParticleEffect()
self.particle.loadConfig("/e/Panda3D-1.9.2-x64/samples/particles/"+filename)
#self.particle.start(self.teapot)
self.particle.setPos(3, 0, 2.225)
def loadParticleConfig(self, file):
self.p1.reset()
self.p1 = ParticleEffect()
self.p1.loadConfig(Filename(file))
self.p1.start(self.player)
self.p1.setPos(-1.75, -10, 1.375)
self.p1.setHpr(0, 90, 0)
self.p1.setScale(2.0)
self.p1.setLightOff()
self.p2.reset()
self.p2 = ParticleEffect()
self.p2.loadConfig(Filename(file))
self.p2.start(self.player)
self.p2.setPos(1.75, -10, 1.375)
self.p2.setHpr(0, 90, 0)
self.p2.setScale(2.0)
self.p2.setLightOff()
def loadParticleConfig(self, file):
self.p1.reset()
self.p1 = ParticleEffect()
self.p1.loadConfig(Filename(file))
self.p1.start(self.player)
self.p1.setPos(-250, -700, 275)
self.p1.setHpr(0, 90, 0)
self.p1.setScale(200)
self.p1.setLightOff()
self.p2.reset()
self.p2 = ParticleEffect()
self.p2.loadConfig(Filename(file))
self.p2.start(self.player)
self.p2.setPos(250, -700, 275)
self.p2.setHpr(0, 90, 0)
self.p2.setScale(200)
self.p2.setLightOff()
def loadParticleConfig(self, file):
#Start of the code from spark.ptf
self.p.cleanup()
self.p = ParticleEffect()
self.p.loadConfig(Filename(file))
#Sets particles to birth relative to the teapot, but to render at toplevel
self.p.start(self.t)
self.p.setPos(-2.00, 0.000, 3.150)
def __init__(self, parent, _x, _y, _z):
self.x = _x
self.y = _y
self.z = _z
self.parent = parent
self.p = ParticleEffect()
self.load_config('steam.ptf')
self.p.setScale(200)
def __init__( self, parent=None, name=None ):
global PARTICLES_ENABLED
if not PARTICLES_ENABLED:
base.enableParticles()
PARTICLES_ENABLED = True
# define the name of this object
VirtualNodeWrapper.__init__(self, parent, name, PARTICLE_WRAPPER_DUMMYOBJECT)
self.particleSystem = ParticleEffect()
def loadParticleConfig(self, path, file):
#Start of the code from steam.ptf
self.particle.cleanup()
self.particle = ParticleEffect()
self.particle.loadConfig(Filename(path, file))
#Sets particles to birth relative to the teapot, but to render at toplevel
self.particle.start(self.model)
self.particle.setScale(100)
self.particle.setPos(0.00, -200.000, -200.00)
def loadParticleConfig(self, position):
self.p.cleanup()
self.p = ParticleEffect()
self.p.loadConfig(os.path.join("models", "smokering.ptf"))
self.p.accelerate(.25)
self.p.setPos(position)
self.p.reparentTo(render)
self.p.setScale(30)
self.p.start()
def useFlame(self):
self.onFire = True # on fire
self.playerCandyCount -= 1
self.pokeStatus = 1
self.flame = ParticleEffect()
self.flame.loadConfig("fireish.ptf")
self.flame.setPos(self.pikachu.getPos())
self.flame.start(parent=render, renderParent=render)
self.updateTwoD()
def _start_pfx (self, enode, rnode, pos, radius, scale1, scale2,
lifespan, poolsize, amplitude,
texpath, color, alphamode, starttime):
pfx = ParticleEffect()
pfx.setPos(pos)
p0 = make_particles()
p0.setPoolSize(16)
p0.setPoolSize(poolsize)
p0.setBirthRate(starttime or 1e-5)
p0.setLitterSize(poolsize)
p0.setLitterSpread(0)
#p0.setSystemLifespan(1.0)
#p0.setLocalVelocityFlag(1)
#p0.setSystemGrowsOlderFlag(0)
p0.setFactory("PointParticleFactory")
p0.factory.setLifespanBase(lifespan)
p0.factory.setLifespanSpread(0.0)
#p0.factory.setMassBase(1.00)
#p0.factory.setMassSpread(0.00)
#p0.factory.setTerminalVelocityBase(400.0000)
#p0.factory.setTerminalVelocitySpread(0.0000)
p0.setRenderer("SpriteParticleRenderer")
p0.renderer.setAlphaMode(alphamode)
texture = base.load_texture("data", texpath)
p0.renderer.setTexture(texture)
# p0.renderer.setUserAlpha(alpha)
p0.renderer.setColor(color)
p0.renderer.setXScaleFlag(1)
p0.renderer.setYScaleFlag(1)
p0.renderer.setInitialXScale(scale1)
p0.renderer.setFinalXScale(scale2)
p0.renderer.setInitialYScale(scale1)
p0.renderer.setFinalYScale(scale2)
p0.setEmitter("SphereVolumeEmitter")
p0.emitter.setRadius(radius)
p0.emitter.setEmissionType(BaseParticleEmitter.ETRADIATE)
p0.emitter.setAmplitude(amplitude)
#p0.emitter.setAmplitudeSpread(0.0)
#p0.emitter.setOffsetForce(Vec3(0.0000, 0.0000, 0.0000))
#p0.emitter.setExplicitLaunchVector(Vec3(1.0000, 0.0000, 0.0000))
#p0.emitter.setRadiateOrigin(Point3(0.0000, 0.0000, 0.0000))
#f0 = ForceGroup("vertex")
#force0 = LinearVectorForce(Vec3(0.0, 0.0, -amplitude * 2))
#force0.setActive(1)
#f0.addForce(force0)
p0.setRenderParent(rnode)
#pfx.addForceGroup(f0)
pfx.addParticles(p0)
pfx.start(enode)
self._pfxes.append((pfx, lifespan, starttime))
def addEffects(self):
if self.mp.has_key('effects'):
base.enableParticles()
for effect in self.mp['effects']:
p = ParticleEffect()
p.loadConfig(GAME+'/particles/'+effect['file']+'.ptf')
p.start(render)
p.setPos(self.logic2terrain( effect['position'] ))
def __init__(self):
self.ship = loader.loadModel("Art\ufo.egg")
self.beam = loader.loadModel("Art\eam.egg")
self.health = 100
#Dummy is used to position the tractor beam collisionsphere
self.dummy = NodePath('dummy')
self.dummy.reparentTo(render)
#Dummy2 used to position abductees
self.dummy2 = NodePath('dummy2')
self.dummy2.reparentTo(render)
self.beam.reparentTo(self.dummy2)
self.glownode = self.ship.find("**/l_glownode")
self.glownode.setColor(0,0,.5,1)
self.glownode2 = self.ship.find("**/r_glownode")
self.glownode2.setColor(0,0,.5,1)
self.ship.reparentTo(render)
self.ship.setScale(1)
#self.ship.setH(180)
self.ship.setPos(0,0,25)
self.dummy.setPos(0,0,25)
self.dummy2.setPos(0,0,25)
#list of things currently abducting
self.abductlist = []
self.animals = []
self.inanimates = []
taskMgr.add(self.abductTask, "abductTask")
taskMgr.add(self.lightTask, "lightTask")
self.stuntime = 30
self.stunbase = 30
self.updown = False
self.beamspeed = 1
self.basebeamspeed = 2
self.collected = 0
self.beamon = True
taskMgr.add(self.particleTask, "shipparticleTask")
self.mydir = os.path.abspath(sys.path[0])
self.mydir = Filename.fromOsSpecific(self.mydir).getFullpath()
self.mydir = Filename(self.mydir)
#self.mydir = self.mydir.toOsSpecific()
self.abductp = ParticleEffect()
self.abductp.loadConfig(self.mydir + '/abduct.ptf')
self.pcount = 0
self.particletime = 60 #Must be integer
class World(DirectObject):
def __init__(self):
#More standard initialization
self.accept('escape', sys.exit)
self.accept('1', self.loadParticleConfig , ['spark.ptf'])
self.accept('escape', sys.exit)
base.disableMouse()
camera.setPos(0,-20,2)
base.setBackgroundColor( 0, 0, 0 )
#This command is required for Panda to render particles
base.enableParticles()
self.t = loader.loadModel("models/stepipe")
self.t.setPos(0,0,0)
self.t.reparentTo(render)
self.setupLights()
self.p = ParticleEffect()
self.loadParticleConfig('spark.ptf')
self.p.setScale(3)
def loadParticleConfig(self, file):
#Start of the code from spark.ptf
self.p.cleanup()
self.p = ParticleEffect()
self.p.loadConfig(Filename(file))
#Sets particles to birth relative to the teapot, but to render at toplevel
self.p.start(self.t)
self.p.setPos(-2.00, 0.000, 3.150)
#Setup lighting
def setupLights(self):
ambientLight = AmbientLight("ambientLight")
ambientLight.setColor(Vec4(.4, .4, .35, 1))
directionalLight = DirectionalLight("directionalLight")
directionalLight.setDirection(Vec3( 0, 8, -2.5 ) )
directionalLight.setColor(Vec4( 0.9, 0.8, 0.9, 1 ) )
#Set lighting on teapot so spark doesn't get affected
self.t.setLight(self.t.attachNewNode(directionalLight))
self.t.setLight(self.t.attachNewNode(ambientLight))
