Example #1
0
    def destroy(self):
        if self.card:
            self.card.removeNode()
            self.card = None

        EffectController.destroy(self)
        PooledEffect.destroy(self)
Example #2
0
 def cleanUpEffect(self):
     if self.soundIval:
         self.soundIval.stop()
         self.soundIval = None
     
     EffectController.cleanUpEffect(self)
     self.checkInEffect(self)
 def __init__(self):
     PooledEffect.__init__(self)
     EffectController.__init__(self)
     self.useRay = 0
     self.useSpark = 1
     self.rayAngle = 0.0
     self.rayFlareValue = 0.34999999999999998
     self.setColorScaleOff()
     self.startCol = Vec4(1.0, 1.0, 1.0, 1)
     self.fadeTime = 0.59999999999999998
     self.startScale = 2.0
     self.splatScale = 10.0
     self.flashDummy = self.attachNewNode('FlashDummy')
     self.flashDummy.reparentTo(self)
     self.flashDummy.hide()
     self.flashDummy.node().setAttrib(ColorBlendAttrib.make(ColorBlendAttrib.MAdd, ColorBlendAttrib.OIncomingAlpha, ColorBlendAttrib.OOne))
     self.flash = loader.loadModel('models/effects/combat_hit_spark')
     self.flash.setDepthWrite(0)
     self.flash.setFogOff()
     self.flash.setLightOff()
     self.flash.setScale(self.splatScale)
     self.flash.reparentTo(self.flashDummy)
     self.flash.setBillboardPointEye(1.0)
     self.spark = loader.loadModel('models/effects/hitSplats')
     self.spark.reparentTo(self.flash)
     flash2 = loader.loadModel('models/effects/hitSplats')
     flash2.reparentTo(self.spark)
     self.slashRay = loader.loadModel('models/effects/hitSplats')
     self.slashRay.setDepthWrite(0)
     self.slashRay.setFogOff()
     self.slashRay.setLightOff()
     self.slashRay.setScale(self.splatScale)
     self.slashRay.reparentTo(self.flashDummy)
     self.slashRay.setTwoSided(1)
Example #4
0
 def cleanUpEffect(self):
     if self.disturb:
         self.disturb.pause()
         self.disturb = None
     
     EffectController.cleanUpEffect(self)
     self.checkInEffect(self)
 def __init__(self):
     PooledEffect.__init__(self)
     EffectController.__init__(self)
     self.target = None
     self.initialVelocity = Vec3(1, 1, 1)
     self.targetOffset = Vec3(0, 0, 0)
     self.duration = 3.0
     self.wantTrail = 1
     self.particleEffect = None
     self.motion_color = [
         Vec4(0.5, 0.59999999999999998, 0.80000000000000004, 1.0),
         Vec4(0.5, 0.59999999999999998, 0.80000000000000004, 1.0),
     ]
     vertex_list = [Vec4(0.0, 1.0, 0.0, 1.0), Vec4(0.0, -1.0, 0.0, 1.0)]
     self.motion_trail = PolyTrail.PolyTrail(None, vertex_list, self.motion_color, 1.5)
     self.motion_trail.reparentTo(self)
     vertex_list = [Vec4(1.0, 0.0, 0.0, 1.0), Vec4(-1.0, 0.0, 0.0, 1.0)]
     self.motion_trail2 = PolyTrail.PolyTrail(None, vertex_list, self.motion_color, 1.5)
     self.motion_trail2.reparentTo(self)
     self.motion_trail.node().setAttrib(
         ColorBlendAttrib.make(
             ColorBlendAttrib.MAdd, ColorBlendAttrib.OIncomingColor, ColorBlendAttrib.OOneMinusIncomingAlpha
         )
     )
     self.motion_trail2.node().setAttrib(
         ColorBlendAttrib.make(
             ColorBlendAttrib.MAdd, ColorBlendAttrib.OIncomingColor, ColorBlendAttrib.OOneMinusIncomingAlpha
         )
     )
Example #6
0
 def __init__(self):
     PooledEffect.__init__(self)
     EffectController.__init__(self)
     self.objects = []
     self.objIvals = Parallel()
     self.effectScale = 1.0
     self.effectDummy = self.attachNewNode("effectDummy")
Example #7
0
 def cleanUpEffect(self):
     if self.expandIval:
         self.expandIval.pause()
         self.expandIval = None
     
     EffectController.cleanUpEffect(self)
     self.checkInEffect(self)
Example #8
0
 def __init__(self):
     PooledEffect.__init__(self)
     EffectController.__init__(self)
     model = loader.loadModel('models/effects/particleMaps')
     self.card = model.find('**/particleFlameSmoke')
     self.speed = 20.0
     if not ExplosionCloud.particleDummy:
         ExplosionCloud.particleDummy = render.attachNewNode(ModelNode('ExplosionCloudParticleDummy'))
         ExplosionCloud.particleDummy.setDepthWrite(0)
         ExplosionCloud.particleDummy.setLightOff()
         ExplosionCloud.particleDummy.setColorScaleOff()
         ExplosionCloud.particleDummy.setFogOff()
     
     self.f = ParticleEffect.ParticleEffect('ExplosionCloud')
     self.f.reparentTo(self)
     self.p0 = Particles.Particles('particles-1')
     self.p0.setFactory('PointParticleFactory')
     self.p0.setRenderer('SpriteParticleRenderer')
     self.p0.setEmitter('SphereSurfaceEmitter')
     self.f.addParticles(self.p0)
     f0 = ForceGroup.ForceGroup('Noise')
     force0 = LinearNoiseForce(0.5, 0)
     force0.setVectorMasks(1, 1, 1)
     force0.setActive(1)
     f0.addForce(force0)
     self.f.addForceGroup(f0)
 def __init__(self):
     PooledEffect.__init__(self)
     EffectController.__init__(self)
     model = loader.loadModel('phase_4/models/props/tt_m_efx_ext_particleCards')
     self.card = model.find('**/tt_t_efx_ext_particleStars')
     self.cardScale = 64.0
     self.effectColor = Vec4(1, 1, 1, 1)
     self.effectScale = 1.0
     self.lifespan = 2.0
     if not SparksTrailLong.particleDummy:
         SparksTrailLong.particleDummy = render.attachNewNode(ModelNode('SparksTrailLongParticleDummy'))
         SparksTrailLong.particleDummy.setDepthWrite(0)
     self.f = ParticleEffect.ParticleEffect('SparksTrailLong')
     self.f.reparentTo(self)
     self.p0 = Particles.Particles('particles-1')
     self.p0.setFactory('ZSpinParticleFactory')
     self.p0.setRenderer('SpriteParticleRenderer')
     self.p0.setEmitter('PointEmitter')
     self.f.addParticles(self.p0)
     f0 = ForceGroup.ForceGroup('Gravity')
     force0 = LinearVectorForce(Vec3(0.0, 0.0, -2.0), 1.0, 0)
     force0.setVectorMasks(1, 1, 1)
     force0.setActive(1)
     f0.addForce(force0)
     self.f.addForceGroup(f0)
     self.p0.setPoolSize(128)
     self.p0.setBirthRate(0.02)
     self.p0.setLitterSize(1)
     self.p0.setLitterSpread(0)
     self.p0.setSystemLifespan(0.0)
     self.p0.setLocalVelocityFlag(0)
     self.p0.setSystemGrowsOlderFlag(0)
     self.p0.factory.setLifespanBase(self.lifespan)
     self.p0.factory.setLifespanSpread(0.1)
     self.p0.factory.setMassBase(1.0)
     self.p0.factory.setMassSpread(0.0)
     self.p0.factory.setTerminalVelocityBase(400.0)
     self.p0.factory.setTerminalVelocitySpread(0.0)
     self.p0.factory.setInitialAngle(0.0)
     self.p0.factory.setInitialAngleSpread(90.0)
     self.p0.factory.enableAngularVelocity(1)
     self.p0.factory.setAngularVelocity(0.0)
     self.p0.factory.setAngularVelocitySpread(25.0)
     self.p0.renderer.setAlphaMode(BaseParticleRenderer.PRALPHAOUT)
     self.p0.renderer.setUserAlpha(1.0)
     self.p0.renderer.setFromNode(self.card)
     self.p0.renderer.setColor(Vec4(1.0, 1.0, 1.0, 1.0))
     self.p0.renderer.setXScaleFlag(1)
     self.p0.renderer.setYScaleFlag(1)
     self.p0.renderer.setAnimAngleFlag(1)
     self.p0.renderer.setNonanimatedTheta(0.0)
     self.p0.renderer.setAlphaBlendMethod(BaseParticleRenderer.PPBLENDLINEAR)
     self.p0.renderer.setAlphaDisable(0)
     self.p0.renderer.setColorBlendMode(ColorBlendAttrib.MAdd, ColorBlendAttrib.OIncomingAlpha, ColorBlendAttrib.OOne)
     self.p0.emitter.setEmissionType(BaseParticleEmitter.ETRADIATE)
     self.p0.emitter.setAmplitudeSpread(0.0)
     self.p0.emitter.setOffsetForce(Vec3(0.0, 0.0, -2.0))
     self.p0.emitter.setExplicitLaunchVector(Vec3(1.0, 0.0, 0.0))
     self.p0.emitter.setRadiateOrigin(Point3(0.0, 0.0, 0.0))
     self.setEffectScale(self.effectScale)
Example #10
0
 def __init__(self):
     PooledEffect.__init__(self)
     EffectController.__init__(self)
     model = loader.loadModel('phase_4/models/props/tt_m_efx_ext_fireworkCards')
     self.card = model.find('**/tt_t_efx_ext_particleStars')
     self.cardScale = 64.0
     self.setDepthWrite(0)
     self.setColorScaleOff()
     self.setLightOff()
     self.effectScale = 1.0
     self.effectColor = Vec4(1, 1, 1, 1)
     self.f = ParticleEffect.ParticleEffect('StarBurst')
     self.f.reparentTo(self)
     self.p0 = Particles.Particles('particles-0')
     self.p0.setFactory('ZSpinParticleFactory')
     self.p0.setRenderer('SpriteParticleRenderer')
     self.p0.setEmitter('SphereSurfaceEmitter')
     self.f.addParticles(self.p0)
     f0 = ForceGroup.ForceGroup('Gravity')
     force0 = LinearVectorForce(Vec3(0.0, 0.0, -25.0), 1.0, 0)
     force0.setVectorMasks(1, 1, 1)
     force0.setActive(1)
     f0.addForce(force0)
     self.f.addForceGroup(f0)
     self.p0.setPoolSize(128)
     self.p0.setBirthRate(0.04)
     self.p0.setLitterSize(64)
     self.p0.setLitterSpread(0)
     self.p0.setSystemLifespan(0.0)
     self.p0.setLocalVelocityFlag(1)
     self.p0.setSystemGrowsOlderFlag(0)
     self.p0.factory.setLifespanBase(1.25)
     self.p0.factory.setLifespanSpread(0.5)
     self.p0.factory.setMassBase(1.0)
     self.p0.factory.setMassSpread(0.0)
     self.p0.factory.setTerminalVelocityBase(400.0)
     self.p0.factory.setTerminalVelocitySpread(0.0)
     self.p0.factory.setInitialAngle(0.0)
     self.p0.factory.setInitialAngleSpread(360.0)
     self.p0.factory.enableAngularVelocity(1)
     self.p0.factory.setAngularVelocity(0.0)
     self.p0.factory.setAngularVelocitySpread(0.0)
     self.p0.renderer.setAlphaMode(BaseParticleRenderer.PRALPHAOUT)
     self.p0.renderer.setUserAlpha(1.0)
     self.p0.renderer.setColorBlendMode(ColorBlendAttrib.MAdd, ColorBlendAttrib.OIncomingAlpha, ColorBlendAttrib.OOne)
     self.p0.renderer.setFromNode(self.card)
     self.p0.renderer.setColor(Vec4(1.0, 1.0, 1.0, 1.0))
     self.p0.renderer.setXScaleFlag(1)
     self.p0.renderer.setYScaleFlag(1)
     self.p0.renderer.setAnimAngleFlag(1)
     self.p0.renderer.setNonanimatedTheta(0.0)
     self.p0.renderer.setAlphaBlendMethod(BaseParticleRenderer.PPBLENDLINEAR)
     self.p0.renderer.setAlphaDisable(0)
     self.p0.renderer.getColorInterpolationManager().addLinear(0.0, 0.1, Vec4(0, 0, 0, 0), self.effectColor, 1)
     self.p0.emitter.setEmissionType(BaseParticleEmitter.ETRADIATE)
     self.p0.emitter.setOffsetForce(Vec3(0.0, 0.0, 0.0))
     self.p0.emitter.setExplicitLaunchVector(Vec3(1.0, 0.0, 0.0))
     self.p0.emitter.setRadiateOrigin(Point3(0.0, 0.0, 0.0))
     self.setEffectScale(self.effectScale)
     self.setEffectColor(self.effectColor)
Example #11
0
 def __init__(self):
     PooledEffect.__init__(self)
     EffectController.__init__(self)
     model = loader.loadModel('models/effects/particleMaps')
     self.card = model.find('**/particleRockShower')
     self.speed = 20.0
     if not ThrowDirt.particleDummy:
         ThrowDirt.particleDummy = render.attachNewNode(ModelNode('ThrowDirtParticleDummy'))
         ThrowDirt.particleDummy.setDepthWrite(0)
         ThrowDirt.particleDummy.setLightOff()
         ThrowDirt.particleDummy.setColorScaleOff()
         ThrowDirt.particleDummy.setFogOff()
     
     self.f = ParticleEffect.ParticleEffect('ThrowDirt')
     self.f.reparentTo(self)
     self.p0 = Particles.Particles('particles-1')
     self.p0.setFactory('PointParticleFactory')
     self.p0.setRenderer('SpriteParticleRenderer')
     self.p0.setEmitter('DiscEmitter')
     self.f.addParticles(self.p0)
     self.f0 = ForceGroup.ForceGroup('Grav')
     force0 = LinearVectorForce(Vec3(0.0, -1.0, -20.0), 1.0, 1)
     force0.setVectorMasks(1, 1, 1)
     force0.setActive(1)
     self.f0.addForce(force0)
     self.f.addForceGroup(self.f0)
     self.p0.setPoolSize(32)
     self.p0.setBirthRate(0.02)
     self.p0.setLitterSize(1)
     self.p0.setLitterSpread(0)
     self.p0.setSystemLifespan(0.0)
     self.p0.setLocalVelocityFlag(1)
     self.p0.setSystemGrowsOlderFlag(0)
     self.p0.factory.setLifespanBase(2.0)
     self.p0.factory.setLifespanSpread(1.0)
     self.p0.factory.setMassBase(0.40000000000000002)
     self.p0.factory.setMassSpread(0.34999999999999998)
     self.p0.factory.setTerminalVelocityBase(400.0)
     self.p0.factory.setTerminalVelocitySpread(0.0)
     self.p0.renderer.setAlphaMode(BaseParticleRenderer.PRALPHAOUT)
     self.p0.renderer.setUserAlpha(1.0)
     self.p0.renderer.setFromNode(self.card)
     self.p0.renderer.setColor(Vec4(0.29999999999999999, 0.20000000000000001, 0, 1))
     self.p0.renderer.setXScaleFlag(1)
     self.p0.renderer.setYScaleFlag(1)
     self.p0.renderer.setAnimAngleFlag(0)
     self.p0.renderer.setInitialXScale(0.0040000000000000001 * self.cardScale)
     self.p0.renderer.setFinalXScale(0.0080000000000000002 * self.cardScale)
     self.p0.renderer.setInitialYScale(0.0040000000000000001 * self.cardScale)
     self.p0.renderer.setFinalYScale(0.0080000000000000002 * self.cardScale)
     self.p0.renderer.setNonanimatedTheta(0.0)
     self.p0.renderer.setAlphaBlendMethod(BaseParticleRenderer.PPBLENDLINEAR)
     self.p0.renderer.setAlphaDisable(0)
     self.p0.emitter.setEmissionType(BaseParticleEmitter.ETRADIATE)
     self.p0.emitter.setAmplitude(1.5)
     self.p0.emitter.setAmplitudeSpread(0.0)
     self.p0.emitter.setOffsetForce(Vec3(0.0, 10.0, 20.0))
     self.p0.emitter.setExplicitLaunchVector(Vec3(0.0, 0.0, 0.0))
     self.p0.emitter.setRadiateOrigin(Point3(0.0, 0.0, 0.0))
     self.p0.emitter.setRadius(1.0)
 def __init__(self):
     PooledEffect.__init__(self)
     EffectController.__init__(self)
     model = loader.loadModel('models/effects/particleMaps')
     self.card = model.find('**/particleSmoke')
     self.speed = 20.0
     self.radius = 7.0
     self.spriteScale = 1.0
     if not SmokePillar.particleDummy:
         SmokePillar.particleDummy = render.attachNewNode(ModelNode('SmokePillarParticleDummy'))
         SmokePillar.particleDummy.setDepthWrite(0)
         SmokePillar.particleDummy.setLightOff()
     
     self.f = ParticleEffect.ParticleEffect('SmokePillar')
     self.f.reparentTo(self)
     self.p0 = Particles.Particles('particles-1')
     self.p0.setFactory('ZSpinParticleFactory')
     self.p0.setRenderer('SpriteParticleRenderer')
     self.p0.setEmitter('SphereVolumeEmitter')
     self.f.addParticles(self.p0)
     f0 = ForceGroup.ForceGroup('gravity')
     force0 = LinearVectorForce(Vec3(0.0, 0.0, -40.0), 1.0, 1)
     force0.setActive(1)
     f0.addForce(force0)
     self.f.addForceGroup(f0)
Example #13
0
 def __init__(self):
     PooledEffect.__init__(self)
     EffectController.__init__(self)
     self.setColorScaleOff()
     self.startCol = Vec4(0.5, 0.5, 0.5, 1)
     model = loader.loadModel('models/effects/particleMaps')
     self.card = model.find('**/particleDot')
     if not PistolFlame.particleDummy:
         PistolFlame.particleDummy = render.attachNewNode(ModelNode('FireParticleDummy'))
         PistolFlame.particleDummy.setDepthWrite(0)
         PistolFlame.particleDummy.node().setAttrib(ColorBlendAttrib.make(ColorBlendAttrib.MAdd, ColorBlendAttrib.OIncomingAlpha, ColorBlendAttrib.OOne))
         PistolFlame.particleDummy.setFogOff()
     
     self.flash = loader.loadModel('models/effects/lanternGlow')
     self.flash.node().setAttrib(ColorBlendAttrib.make(ColorBlendAttrib.MAdd, ColorBlendAttrib.OIncomingAlpha, ColorBlendAttrib.OOne))
     self.flash.setDepthWrite(0)
     self.flash.setFogOff()
     self.flash.setColorScale(self.startCol)
     self.flash.setBillboardPointEye(0.20000000000000001)
     self.flash.setBin('fixed', 120)
     self.flash.setScale(25)
     self.flash.reparentTo(self)
     self.flash.hide()
     self.f = ParticleEffect.ParticleEffect('PistolFlame')
     self.f.reparentTo(self)
     self.p0 = Particles.Particles('particles-1')
     self.p0.setFactory('ZSpinParticleFactory')
     self.p0.setRenderer('SpriteParticleRenderer')
     self.p0.setEmitter('SphereVolumeEmitter')
     self.f.addParticles(self.p0)
     f0 = ForceGroup.ForceGroup('frict')
     force0 = LinearFrictionForce(1.0, 10.0, 1.0)
     force0.setActive(1)
     f0.addForce(force0)
     self.f.addForceGroup(f0)
 def destroy(self):
     if self.fireSfxIval:
         self.fireSfxIval.pause()
         self.fireSfxIval = None
     
     EffectController.destroy(self)
     PooledEffect.destroy(self)
Example #15
0
 def destroy(self):
     if self.disturb:
         self.disturb.pause()
         self.disturb = None
     
     EffectController.destroy(self)
     PooledEffect.destroy(self)
 def __init__(self):
     PooledEffect.__init__(self)
     EffectController.__init__(self)
     if not self.soundFx:
         for audio in self.soundFxNames:
             self.soundFx.append(loadSfx(audio))
         
     
     self.fadeTime = 0.14000000000000001
     self.waitTime = 0.20000000000000001
     self.startScale = 1.0
     self.endScale = 1.01
     self.fadeColor = Vec4(1.0, 1.0, 1.0, 1.0)
     self.flashDummy = self.attachNewNode('FlashDummy')
     self.flashDummy.setBillboardPointEye()
     self.flashDummy.setDepthWrite(0)
     self.flashDummy.setColorScaleOff()
     self.flashDummy.setFogOff()
     self.flashDummy.setLightOff()
     self.flashDummy.reparentTo(self)
     self.flashDummy.setScale(self.startScale)
     self.flashDummy.hide()
     self.flashDummy.node().setAttrib(ColorBlendAttrib.make(ColorBlendAttrib.MAdd, ColorBlendAttrib.OIncomingAlpha, ColorBlendAttrib.OOne))
     self.flasha = loader.loadModel('models/effects/lightning_strike')
     self.flasha.reparentTo(self.flashDummy)
     self.flashb = loader.loadModel('models/effects/lightning_strike')
     self.flashb.reparentTo(self.flasha)
 def __init__(self):
     NodePath.__init__(self, 'Fireflies')
     EffectController.__init__(self)
     model = loader.loadModel('models/effects/particleMaps')
     self.card = model.find('**/particleGlow')
     if not Fireflies.particleDummy:
         Fireflies.particleDummy = render.attachNewNode(ModelNode('FirefliesParticleDummy'))
         Fireflies.particleDummy.setDepthWrite(0)
         Fireflies.particleDummy.setFogOff()
         Fireflies.particleDummy.setColorScale(1.0, 1.0, 1.0, 1)
         Fireflies.particleDummy.setLightOff()
         Fireflies.particleDummy.setBin('fixed', 120)
     
     self.f = ParticleEffect.ParticleEffect('Fireflies')
     self.f.reparentTo(self)
     self.p0 = Particles.Particles('particles-1')
     self.p0.setFactory('PointParticleFactory')
     self.p0.setRenderer('SpriteParticleRenderer')
     self.p0.setEmitter('SphereVolumeEmitter')
     self.f.addParticles(self.p0)
     f0 = ForceGroup.ForceGroup('Noise')
     force0 = LinearNoiseForce(0.10000000000000001, 0)
     force0.setVectorMasks(1, 1, 1)
     force0.setActive(1)
     f0.addForce(force0)
     self.f.addForceGroup(f0)
 def __init__(self):
     PooledEffect.__init__(self)
     EffectController.__init__(self)
     self.effectModel = loader.loadModel('models/effects/soulspiral')
     self.effectModel2 = loader.loadModel('models/effects/soulspiral')
     self.effectModel3 = loader.loadModel('models/effects/soulspiral')
     self.effectModel4 = loader.loadModel('models/effects/soulspiral')
     self.effectModel.setColorScaleOff()
     self.effectModel2.setColorScaleOff()
     self.effectModel.reparentTo(self)
     self.effectModel2.reparentTo(self)
     self.effectModel3.reparentTo(self.effectModel)
     self.effectModel4.reparentTo(self.effectModel2)
     self.effectModel.node().setAttrib(ColorBlendAttrib.make(ColorBlendAttrib.MAdd, ColorBlendAttrib.OIncomingAlpha, ColorBlendAttrib.OOne))
     self.effectModel2.node().setAttrib(ColorBlendAttrib.make(ColorBlendAttrib.MAdd, ColorBlendAttrib.OIncomingAlpha, ColorBlendAttrib.OOne))
     self.effectModel.setScale(0.20000000000000001, 0.20000000000000001, 0.20000000000000001)
     self.effectModel2.setTwoSided(1)
     self.effectModel2.setScale(0.16, 0.16, 0.17999999999999999)
     self.effectModel2.setH(25)
     self.setDepthWrite(0)
     self.setLightOff()
     self.setColorScaleOff()
     self.effectColor = Vec4(1, 1, 1, 1)
     texture = self.effectModel.findAllTextures()[0]
     texture.setBorderColor(VBase4(0.0, 0.0, 0.0, 0.0))
     texture.setWrapU(Texture.WMBorderColor)
     texture.setWrapV(Texture.WMBorderColor)
Example #19
0
 def destroy(self):
     if self.loopEffect:
         self.loopEffect.finish()
         self.loopEffect = None
     
     EffectController.destroy(self)
     PooledEffect.destroy(self)
Example #20
0
 def cleanUpEffect(self):
     if self.loopEffect:
         self.loopEffect.finish()
         self.loopEffect = None
     
     EffectController.cleanUpEffect(self)
     self.checkInEffect(self)
Example #21
0
 def __init__(self):
     PooledEffect.__init__(self)
     EffectController.__init__(self)
     model = loader.loadModel('models/effects/particleMaps')
     self.card = model.find('**/particleSpark')
     if not Sparks.particleDummy:
         Sparks.particleDummy = render.attachNewNode(ModelNode('SparksParticleDummy'))
         Sparks.particleDummy.setDepthWrite(0)
         Sparks.particleDummy.node().setAttrib(ColorBlendAttrib.make(ColorBlendAttrib.MAdd, ColorBlendAttrib.OIncomingAlpha, ColorBlendAttrib.OOne))
         Sparks.particleDummy.setFogOff()
         Sparks.particleDummy.setLightOff()
         Sparks.particleDummy.setBin('fixed', 120)
     
     self.f = ParticleEffect.ParticleEffect('Sparks')
     self.f.reparentTo(self)
     self.p0 = Particles.Particles('particles-1')
     self.p0.setFactory('ZSpinParticleFactory')
     self.p0.setRenderer('SpriteParticleRenderer')
     self.p0.setEmitter('RingEmitter')
     self.f.addParticles(self.p0)
     f0 = ForceGroup.ForceGroup('gravity')
     force0 = LinearVectorForce(Vec3(0.0, 0.0, -6.5), 2.0, 1)
     force0.setActive(1)
     f0.addForce(force0)
     self.f.addForceGroup(f0)
 def __init__(self):
     NodePath.__init__(self, "RayOfLight")
     EffectController.__init__(self)
     self.effectModel = loader.loadModel("models/effects/pir_m_efx_msc_rayOfLight")
     self.effectModel.setColorScale(Vec4(0, 0, 0, 0))
     self.effectModel.reparentTo(self)
     self.mainRay = self.effectModel.find("**/ray_main")
     self.mainRay.setHpr(0, 20, -10)
     self.bottomRay = self.effectModel.find("**/ray_bottom")
     self.bottomRay.stash()
     self.bottomRayEnabled = False
     self.adjustIval = None
     self.mainAnimNode = None
     self.mainAnim = None
     self.bootomAnimNode = None
     self.bottomAnim = None
     self.effectScale = 1.0
     self.av = None
     self.setAttrib(
         ColorBlendAttrib.make(ColorBlendAttrib.MAdd, ColorBlendAttrib.OIncomingAlpha, ColorBlendAttrib.OOne)
     )
     self.setBillboardPointWorld()
     self.setTransparency(1)
     self.setDepthWrite(0)
     self.setLightOff()
     self.setFogOff()
 def __init__(self):
     PooledEffect.__init__(self)
     EffectController.__init__(self)
     model = loader.loadModel('models/effects/particleMaps')
     self.card = model.find('**/particleGreenBlood')
     if not self.splashSfx:
         for audio in self.SfxNames:
             self.splashSfx.append(loadSfx(audio))
         
     
     if not GreenBlood.particleDummy:
         GreenBlood.particleDummy = render.attachNewNode(ModelNode('GreenBloodParticleDummy'))
         GreenBlood.particleDummy.setDepthWrite(0)
     
     self.f = ParticleEffect.ParticleEffect('GreenBlood')
     self.f.reparentTo(self)
     self.p0 = Particles.Particles('particles-1')
     self.p0.setFactory('PointParticleFactory')
     self.p0.setRenderer('SpriteParticleRenderer')
     self.p0.setEmitter('DiscEmitter')
     self.f.addParticles(self.p0)
     f0 = ForceGroup.ForceGroup('gravity')
     force0 = LinearVectorForce(Vec3(0.0, 0.0, -20.0), 1.0, 1)
     force0.setActive(1)
     f0.addForce(force0)
     self.f.addForceGroup(f0)
 def __init__(self, effectParent = None):
     EffectController.__init__(self)
     NodePath.__init__(self, 'SmallFire')
     if effectParent:
         self.reparentTo(effectParent)
     
     model = loader.loadModel('models/effects/particleMaps')
     self.card = model.find('**/particleFire2')
     if not SmallFire.particleDummy:
         SmallFire.particleDummy = base.effectsRoot.attachNewNode(ModelNode('FireParticleDummy'))
         SmallFire.particleDummy.setDepthWrite(0)
         SmallFire.particleDummy.setFogOff()
         SmallFire.particleDummy.setLightOff()
         SmallFire.particleDummy.setColorScaleOff()
         SmallFire.particleDummy.setBin('fixed', 60)
     
     self.duration = 10.0
     self.effectScale = 1.0
     self.f = ParticleEffect.ParticleEffect('Fire')
     self.f.reparentTo(self)
     self.p0 = Particles.Particles('particles-1')
     self.p0.setFactory('ZSpinParticleFactory')
     self.p0.setRenderer('SpriteParticleRenderer')
     self.p0.setEmitter('DiscEmitter')
     self.f.addParticles(self.p0)
     self.p0.setPoolSize(48)
     self.p0.setBirthRate(0.01)
     self.p0.setLitterSize(3)
     self.p0.setLitterSpread(0)
     self.p0.setSystemLifespan(0.0)
     self.p0.setLocalVelocityFlag(1)
     self.p0.setSystemGrowsOlderFlag(0)
     self.p0.factory.setInitialAngle(0.0)
     self.p0.factory.setInitialAngleSpread(360.0)
     self.p0.factory.setLifespanBase(0.59999999999999998)
     self.p0.factory.setLifespanSpread(0.20000000000000001)
     self.p0.factory.setMassBase(1.0)
     self.p0.factory.setMassSpread(0.0)
     self.p0.factory.setTerminalVelocityBase(400.0)
     self.p0.factory.setTerminalVelocitySpread(0.0)
     self.p0.renderer.setAlphaMode(BaseParticleRenderer.PRALPHAINOUT)
     self.p0.renderer.setUserAlpha(1.0)
     self.p0.renderer.setFromNode(self.card)
     self.p0.renderer.setColor(Vec4(1.0, 1.0, 1.0, 1.0))
     self.p0.renderer.setXScaleFlag(1)
     self.p0.renderer.setYScaleFlag(1)
     self.p0.renderer.setAnimAngleFlag(1)
     self.p0.renderer.setNonanimatedTheta(0.0)
     self.p0.renderer.setAlphaBlendMethod(BaseParticleRenderer.PPBLENDLINEAR)
     self.p0.renderer.setColorBlendMode(ColorBlendAttrib.MAdd, ColorBlendAttrib.OIncomingAlpha, ColorBlendAttrib.OOne)
     self.p0.renderer.getColorInterpolationManager().addLinear(0.0, 1.0, Vec4(1.0, 0.59999999999999998, 0.20000000000000001, 1.0), Vec4(0.5, 0.20000000000000001, 0.20000000000000001, 0.5), 1)
     self.p0.renderer.setAlphaDisable(0)
     self.p0.emitter.setEmissionType(BaseParticleEmitter.ETRADIATE)
     self.p0.emitter.setAmplitude(-0.25)
     self.p0.emitter.setAmplitudeSpread(0.10000000000000001)
     self.p0.emitter.setOffsetForce(Vec3(0.0, 0.0, 15.0))
     self.p0.emitter.setExplicitLaunchVector(Vec3(1.0, 0.0, 0.0))
     self.p0.emitter.setRadiateOrigin(Point3(0.0, 0.0, 0.0))
     self.setScale(VBase3(1, 1, 1))
 def __init__(self):
     PooledEffect.__init__(self)
     EffectController.__init__(self)
     model = loader.loadModel('models/effects/particleMaps')
     self.card = model.find('**/pir_t_efx_msc_lavaSplash')
     self.radius = 8.0
     self.effectScale = 1.0
     if not Explosion.particleDummy:
         Explosion.particleDummy = render.attachNewNode(ModelNode('ExplosionParticleDummy'))
         Explosion.particleDummy.setDepthWrite(0)
         Explosion.particleDummy.setLightOff()
         Explosion.particleDummy.setFogOff()
         Explosion.particleDummy.setColorScaleOff()
         Explosion.particleDummy.setBin('fixed', 120)
     
     self.f = ParticleEffect.ParticleEffect('Explosion')
     self.f.reparentTo(self)
     self.p0 = Particles.Particles('particles-1')
     self.p0.setFactory('ZSpinParticleFactory')
     self.p0.setRenderer('SpriteParticleRenderer')
     self.p0.setEmitter('SphereSurfaceEmitter')
     self.f.addParticles(self.p0)
     self.p0.setPoolSize(16)
     self.p0.setBirthRate(0.01)
     self.p0.setLitterSize(2)
     self.p0.setLitterSpread(0)
     self.p0.setSystemLifespan(0.0)
     self.p0.setLocalVelocityFlag(1)
     self.p0.setSystemGrowsOlderFlag(0)
     self.p0.factory.setLifespanBase(1.0)
     self.p0.factory.setLifespanSpread(0.25)
     self.p0.factory.setMassBase(1.0)
     self.p0.factory.setMassSpread(0.0)
     self.p0.factory.setTerminalVelocityBase(400.0)
     self.p0.factory.setTerminalVelocitySpread(0.0)
     self.p0.factory.setInitialAngle(0.0)
     self.p0.factory.setInitialAngleSpread(180.0)
     self.p0.factory.enableAngularVelocity(1)
     self.p0.factory.setAngularVelocity(20.0)
     self.p0.factory.setAngularVelocitySpread(5.0)
     self.p0.renderer.setAlphaMode(BaseParticleRenderer.PRALPHAINOUT)
     self.p0.renderer.setUserAlpha(1.0)
     self.p0.renderer.setFromNode(self.card)
     self.p0.renderer.setColor(Vec4(1.0, 1.0, 1.0, 1.0))
     self.p0.renderer.setXScaleFlag(1)
     self.p0.renderer.setYScaleFlag(1)
     self.p0.renderer.setAnimAngleFlag(1)
     self.p0.renderer.setNonanimatedTheta(0.0)
     self.p0.renderer.setAlphaBlendMethod(BaseParticleRenderer.PPBLENDLINEAR)
     self.p0.renderer.setAlphaDisable(0)
     self.p0.renderer.setColorBlendMode(ColorBlendAttrib.MAdd, ColorBlendAttrib.OOneMinusFbufferAlpha, ColorBlendAttrib.OOneMinusIncomingAlpha)
     self.p0.emitter.setEmissionType(BaseParticleEmitter.ETRADIATE)
     self.p0.emitter.setAmplitude(2.0)
     self.p0.emitter.setAmplitudeSpread(0.0)
     self.p0.emitter.setOffsetForce(Vec3(0.0, 0.0, 5.0))
     self.p0.emitter.setExplicitLaunchVector(Vec3(1.0, 0.0, 0.0))
     self.p0.emitter.setRadiateOrigin(Point3(0.0, 0.0, 0.0))
     self.setEffectScale(self.effectScale)
     self.setEffectRadius(self.radius)
 def __init__(self, newParent = None):
     NodePath.__init__(self, 'TorchFire')
     EffectController.__init__(self)
     if newParent:
         self.reparentTo(newParent)
     
     model = loader.loadModel('models/effects/particleMaps')
     self.card = model.find('**/particleFlame')
     if not TorchFire.particleDummy:
         TorchFire.particleDummy = base.effectsRoot.attachNewNode(ModelNode('TorchFireParticleDummy'))
         TorchFire.particleDummy.setDepthWrite(0)
         TorchFire.particleDummy.setFogOff()
         TorchFire.particleDummy.setLightOff()
         TorchFire.particleDummy.setColorScaleOff()
         TorchFire.particleDummy.setBin('fixed', 60)
         TorchFire.particleDummy.setAttrib(ColorBlendAttrib.make(ColorBlendAttrib.MAdd, ColorBlendAttrib.OIncomingAlpha, ColorBlendAttrib.OOne))
     
     self.f = ParticleEffect.ParticleEffect('TorchFire')
     self.f.reparentTo(self)
     self.f.setPos(0, 0, 0.75)
     self.p0 = Particles.Particles('particles-1')
     self.p0.setFactory('PointParticleFactory')
     self.p0.setRenderer('SpriteParticleRenderer')
     self.p0.setEmitter('DiscEmitter')
     self.f.addParticles(self.p0)
     self.p0.setPoolSize(8)
     self.p0.setBirthRate(0.10000000000000001)
     self.p0.setLitterSize(1)
     self.p0.setLitterSpread(0)
     self.p0.setSystemLifespan(0.0)
     self.p0.setLocalVelocityFlag(1)
     self.p0.setSystemGrowsOlderFlag(0)
     self.p0.factory.setLifespanBase(0.5)
     self.p0.factory.setLifespanSpread(0.050000000000000003)
     self.p0.factory.setMassBase(1.0)
     self.p0.factory.setMassSpread(0.5)
     self.p0.factory.setTerminalVelocityBase(400.0)
     self.p0.factory.setTerminalVelocitySpread(0.0)
     self.p0.renderer.setAlphaMode(BaseParticleRenderer.PRALPHAOUT)
     self.p0.renderer.setUserAlpha(1.0)
     self.p0.renderer.setFromNode(self.card)
     self.p0.renderer.setColor(Vec4(1.0, 1.0, 1.0, 1.0))
     self.p0.renderer.setXScaleFlag(1)
     self.p0.renderer.setYScaleFlag(1)
     self.p0.renderer.setAnimAngleFlag(0)
     self.p0.renderer.setInitialXScale(0.014 * self.cardScale)
     self.p0.renderer.setFinalXScale(0.002 * self.cardScale)
     self.p0.renderer.setInitialYScale(0.024 * self.cardScale)
     self.p0.renderer.setFinalYScale(0.002 * self.cardScale)
     self.p0.renderer.setNonanimatedTheta(0.0)
     self.p0.renderer.setAlphaBlendMethod(BaseParticleRenderer.PPNOBLEND)
     self.p0.renderer.setAlphaDisable(0)
     self.p0.emitter.setEmissionType(BaseParticleEmitter.ETRADIATE)
     self.p0.emitter.setAmplitude(0.14999999999999999)
     self.p0.emitter.setAmplitudeSpread(0.29999999999999999)
     self.p0.emitter.setOffsetForce(Vec3(0.0, 0.0, 3.0))
     self.p0.emitter.setExplicitLaunchVector(Vec3(1.0, 0.0, 0.0))
     self.p0.emitter.setRadiateOrigin(Point3(0.0, 0.0, 0.0))
     self.p0.emitter.setRadius(0.20000000000000001)
 def __init__(self):
     PooledEffect.__init__(self)
     EffectController.__init__(self)
     model = loader.loadModel("models/effects/particleMaps")
     self.card = model.find("**/particleDarkSmoke")
     self.setDepthWrite(0)
     self.setLightOff()
     self.effectColor = Vec4(1, 1, 1, 1)
     self.f = ParticleEffect.ParticleEffect("VoodooGlow")
     self.f.reparentTo(self)
     self.p0 = Particles.Particles("particles-1")
     self.p0.setFactory("ZSpinParticleFactory")
     self.p0.setRenderer("SpriteParticleRenderer")
     self.p0.setEmitter("PointEmitter")
     self.f.addParticles(self.p0)
     self.p0.setPoolSize(32)
     self.p0.setBirthRate(0.01)
     self.p0.setLitterSize(2)
     self.p0.setLitterSpread(0)
     self.p0.setSystemLifespan(0.0)
     self.p0.setLocalVelocityFlag(1)
     self.p0.setSystemGrowsOlderFlag(0)
     self.p0.factory.setLifespanBase(0.20000000000000001)
     self.p0.factory.setLifespanSpread(0.10000000000000001)
     self.p0.factory.setMassBase(1.0)
     self.p0.factory.setMassSpread(0.0)
     self.p0.factory.setTerminalVelocityBase(400.0)
     self.p0.factory.setTerminalVelocitySpread(0.0)
     self.p0.factory.setInitialAngle(0.0)
     self.p0.factory.setInitialAngleSpread(360.0)
     self.p0.factory.enableAngularVelocity(1)
     self.p0.factory.setAngularVelocity(0.0)
     self.p0.factory.setAngularVelocitySpread(0.0)
     self.p0.renderer.setAlphaMode(BaseParticleRenderer.PRALPHAINOUT)
     self.p0.renderer.setUserAlpha(1.0)
     self.p0.renderer.setColorBlendMode(
         ColorBlendAttrib.MAdd, ColorBlendAttrib.OIncomingAlpha, ColorBlendAttrib.OOne
     )
     self.p0.renderer.getColorInterpolationManager().addLinear(
         0.0, 1.0, Vec4(1.0, 1.0, 1.0, 1.0), Vec4(0.5, 0.20000000000000001, 1.0, 0.40000000000000002), 1
     )
     self.p0.renderer.setFromNode(self.card)
     self.p0.renderer.setColor(Vec4(1.0, 1.0, 1.0, 1.0))
     self.p0.renderer.setXScaleFlag(1)
     self.p0.renderer.setYScaleFlag(1)
     self.p0.renderer.setAnimAngleFlag(1)
     self.p0.renderer.setInitialXScale(0.002 * self.cardScale)
     self.p0.renderer.setFinalXScale(0.02 * self.cardScale)
     self.p0.renderer.setInitialYScale(0.002 * self.cardScale)
     self.p0.renderer.setFinalYScale(0.029999999999999999 * self.cardScale)
     self.p0.renderer.setNonanimatedTheta(0.0)
     self.p0.renderer.setAlphaBlendMethod(BaseParticleRenderer.PPBLENDLINEAR)
     self.p0.renderer.setAlphaDisable(0)
     self.p0.emitter.setEmissionType(BaseParticleEmitter.ETRADIATE)
     self.p0.emitter.setAmplitude(0.0)
     self.p0.emitter.setAmplitudeSpread(0.0)
     self.p0.emitter.setOffsetForce(Vec3(0.0, 0.0, 0.0))
     self.p0.emitter.setExplicitLaunchVector(Vec3(1.0, 0.0, 0.0))
     self.p0.emitter.setRadiateOrigin(Point3(0.0, 0.0, 0.0))
Example #28
0
 def destroy(self):
     self.stop()
     if self.track:
         self.track = None
     
     self.removeNode()
     EffectController.destroy(self)
     PooledEffect.destroy(self)
Example #29
0
 def cleanUpEffect(self):
     if self.wantTrail:
         self.motion_trail.endTrail()
         self.motion_trail2.endTrail()
     
     taskMgr.remove(PythonUtil.uniqueName('homingMissileTask'))
     EffectController.cleanUpEffect(self)
     self.checkInEffect(self)
 def __init__(self):
     PooledEffect.__init__(self)
     EffectController.__init__(self)
     model = loader.loadModel('models/effects/particleMaps')
     self.card = model.find('**/particleEvilSmoke')
     self.effectScale = 1.0
     if not self.particleDummy:
         self.particleDummy = render.attachNewNode(ModelNode('selfParticleDummy'))
         self.particleDummy.setDepthWrite(0)
         self.particleDummy.setColorScaleOff()
         self.particleDummy.setLightOff()
         self.particleDummy.setFogOff()
         self.particleDummy.hide(OTPRender.ShadowCameraBitmask)
     
     self.f = ParticleEffect.ParticleEffect('VoodooPestilence')
     self.f.reparentTo(self)
     self.p0 = Particles.Particles('particles-1')
     self.p0.setFactory('ZSpinParticleFactory')
     self.p0.setRenderer('SpriteParticleRenderer')
     self.p0.setEmitter('SphereVolumeEmitter')
     self.f.addParticles(self.p0)
     self.f.setP(90.0)
     self.p0.setPoolSize(256)
     self.p0.setBirthRate(0.01)
     self.p0.setLitterSize(3)
     self.p0.setLitterSpread(0)
     self.p0.setSystemLifespan(0.0)
     self.p0.setLocalVelocityFlag(0)
     self.p0.setSystemGrowsOlderFlag(0)
     self.p0.factory.setLifespanBase(1.2)
     self.p0.factory.setLifespanSpread(0.20000000000000001)
     self.p0.factory.setMassBase(1.0)
     self.p0.factory.setMassSpread(0.0)
     self.p0.factory.setTerminalVelocityBase(400.0)
     self.p0.factory.setTerminalVelocitySpread(0.0)
     self.p0.factory.setInitialAngle(0.0)
     self.p0.factory.setInitialAngleSpread(360.0)
     self.p0.factory.enableAngularVelocity(1)
     self.p0.factory.setAngularVelocity(300.0)
     self.p0.factory.setAngularVelocitySpread(25.0)
     self.p0.renderer.setAlphaMode(BaseParticleRenderer.PRALPHAINOUT)
     self.p0.renderer.setUserAlpha(1.0)
     self.p0.renderer.setFromNode(self.card)
     self.p0.renderer.setXScaleFlag(1)
     self.p0.renderer.setYScaleFlag(1)
     self.p0.renderer.setAnimAngleFlag(1)
     self.p0.renderer.setNonanimatedTheta(0.0)
     self.p0.renderer.setAlphaBlendMethod(BaseParticleRenderer.PPBLENDLINEAR)
     self.p0.renderer.setAlphaDisable(0)
     self.p0.renderer.setColorBlendMode(ColorBlendAttrib.MAdd, ColorBlendAttrib.OOneMinusFbufferAlpha, ColorBlendAttrib.OOneMinusIncomingAlpha)
     self.p0.renderer.getColorInterpolationManager().addLinear(0.0, 1.0, Vec4(1.0, 1.0, 1.0, 1.0), Vec4(0.10000000000000001, 0.20000000000000001, 0.10000000000000001, 0.5), 1)
     self.p0.emitter.setEmissionType(BaseParticleEmitter.ETRADIATE)
     self.p0.emitter.setAmplitude(0.29999999999999999)
     self.p0.emitter.setAmplitudeSpread(0.0)
     self.p0.emitter.setOffsetForce(Vec3(0.0, 0.0, -0.45000000000000001))
     self.p0.emitter.setExplicitLaunchVector(Vec3(1.0, 0.0, 0.0))
     self.p0.emitter.setRadiateOrigin(Point3(0.0, 0.0, 0.0))
     self.p0.emitter.setRadius(0.01)
Example #31
0
    def __init__(self):
        PooledEffect.__init__(self)
        EffectController.__init__(self)
        model = loader.loadModel('models/effects/particleCards')
        self.card = model.find('**/particleStars')
        self.cardScale = 64.0
        self.effectColor = Vec4(1, 1, 1, 1)
        self.effectScale = 1.0
        self.lifespan = 1.0
        if not SparksTrail.particleDummy:
            SparksTrail.particleDummy = render.attachNewNode(
                ModelNode('SparksTrailParticleDummy'))
            SparksTrail.particleDummy.setDepthWrite(0)
            SparksTrail.particleDummy.setLightOff()
            SparksTrail.particleDummy.setFogOff()

        self.f = ParticleEffect.ParticleEffect('SparksTrail')
        self.f.reparentTo(self)
        self.p0 = Particles.Particles('particles-1')
        self.p0.setFactory('ZSpinParticleFactory')
        self.p0.setRenderer('SpriteParticleRenderer')
        self.p0.setEmitter('PointEmitter')
        self.f.addParticles(self.p0)
        self.p0.setPoolSize(64)
        self.p0.setBirthRate(0.02)
        self.p0.setLitterSize(1)
        self.p0.setLitterSpread(0)
        self.p0.setSystemLifespan(0.0)
        self.p0.setLocalVelocityFlag(0)
        self.p0.setSystemGrowsOlderFlag(0)
        self.p0.factory.setLifespanBase(0.5)
        self.p0.factory.setLifespanSpread(0.10000000000000001)
        self.p0.factory.setMassBase(1.0)
        self.p0.factory.setMassSpread(0.0)
        self.p0.factory.setTerminalVelocityBase(400.0)
        self.p0.factory.setTerminalVelocitySpread(0.0)
        self.p0.factory.setInitialAngle(0.0)
        self.p0.factory.setInitialAngleSpread(90.0)
        self.p0.factory.enableAngularVelocity(1)
        self.p0.factory.setAngularVelocity(0.0)
        self.p0.factory.setAngularVelocitySpread(25.0)
        self.p0.renderer.setAlphaMode(BaseParticleRenderer.PRALPHAOUT)
        self.p0.renderer.setUserAlpha(1.0)
        self.p0.renderer.setFromNode(self.card)
        self.p0.renderer.setColor(Vec4(1.0, 1.0, 1.0, 1.0))
        self.p0.renderer.setXScaleFlag(1)
        self.p0.renderer.setYScaleFlag(1)
        self.p0.renderer.setAnimAngleFlag(1)
        self.p0.renderer.setNonanimatedTheta(0.0)
        self.p0.renderer.setAlphaBlendMethod(
            BaseParticleRenderer.PPBLENDLINEAR)
        self.p0.renderer.setAlphaDisable(0)
        self.p0.renderer.setColorBlendMode(ColorBlendAttrib.MAdd,
                                           ColorBlendAttrib.OIncomingAlpha,
                                           ColorBlendAttrib.OOne)
        self.p0.emitter.setEmissionType(BaseParticleEmitter.ETRADIATE)
        self.p0.emitter.setAmplitudeSpread(0.0)
        self.p0.emitter.setOffsetForce(Vec3(0.0, 0.0, -2.0))
        self.p0.emitter.setExplicitLaunchVector(Vec3(1.0, 0.0, 0.0))
        self.p0.emitter.setRadiateOrigin(Point3(0.0, 0.0, 0.0))
        self.setEffectScale(self.effectScale)
Example #32
0
 def reallyCleanUpEffect(self):
     self.stopAdjustTask()
     EffectController.reallyCleanUpEffect(self)
Example #33
0
 def enableEffect(self):
     EffectController.enableEffect(self)
     EffectController.startLoop(self)
Example #34
0
 def destroy(self):
     EffectController.destroy(self)
Example #35
0
    def __init__(self):
        PooledEffect.__init__(self)
        EffectController.__init__(self)
        model = loader.loadModel('models/effects/sigils')
        self.card = model.find('**/effectSkull')
        if not SoulHarvest.particleDummy:
            SoulHarvest.particleDummy = render.attachNewNode(
                ModelNode('SoulHarvestParticleDummy'))
            SoulHarvest.particleDummy.setDepthWrite(0)
            SoulHarvest.particleDummy.setLightOff()

        self.radius = 8.0
        self.effectColor = Vec4(1, 1, 1, 1)
        self.f = ParticleEffect.ParticleEffect('SoulHarvest')
        self.f.reparentTo(self)
        self.p0 = Particles.Particles('particles-1')
        self.p0.setFactory('PointParticleFactory')
        self.p0.setRenderer('SpriteParticleRenderer')
        self.p0.setEmitter('SphereVolumeEmitter')
        self.f.addParticles(self.p0)
        self.p0.setPoolSize(256)
        self.p0.setBirthRate(0.02)
        self.p0.setLitterSize(5)
        self.p0.setLitterSpread(0)
        self.p0.setSystemLifespan(0.0)
        self.p0.setLocalVelocityFlag(1)
        self.p0.setSystemGrowsOlderFlag(0)
        self.p0.factory.setLifespanBase(1.0)
        self.p0.factory.setLifespanSpread(0.5)
        self.p0.factory.setMassBase(1.0)
        self.p0.factory.setMassSpread(0.0)
        self.p0.factory.setTerminalVelocityBase(400.0)
        self.p0.factory.setTerminalVelocitySpread(0.0)
        self.p0.renderer.setAlphaMode(BaseParticleRenderer.PRALPHAINOUT)
        self.p0.renderer.setUserAlpha(0.5)
        self.p0.renderer.setFromNode(self.card)
        self.p0.renderer.setColor(Vec4(1.0, 1.0, 1.0, 1.0))
        self.p0.renderer.setXScaleFlag(1)
        self.p0.renderer.setYScaleFlag(1)
        self.p0.renderer.setAnimAngleFlag(0)
        self.p0.renderer.setInitialXScale(0.01 * self.cardScale)
        self.p0.renderer.setFinalXScale(0.012 * self.cardScale)
        self.p0.renderer.setInitialYScale(0.0001 * self.cardScale)
        self.p0.renderer.setFinalYScale(0.14999999999999999 * self.cardScale)
        self.p0.renderer.setNonanimatedTheta(0.0)
        self.p0.renderer.setAlphaBlendMethod(
            BaseParticleRenderer.PPBLENDLINEAR)
        self.p0.renderer.setAlphaDisable(0)
        self.p0.renderer.setColorBlendMode(
            ColorBlendAttrib.MAdd, ColorBlendAttrib.OOneMinusFbufferAlpha,
            ColorBlendAttrib.OOneMinusIncomingAlpha)
        self.p0.renderer.getColorInterpolationManager().addLinear(
            0.0, 1.0, Vec4(1.0, 1.0, 1.0, 1.0),
            Vec4(0.58999999999999997, 0.78000000000000003, 0.69999999999999996,
                 0.40000000000000002), 1)
        self.p0.emitter.setEmissionType(BaseParticleEmitter.ETRADIATE)
        self.p0.emitter.setAmplitude(1.0)
        self.p0.emitter.setAmplitudeSpread(0.0)
        self.p0.emitter.setOffsetForce(Vec3(0.0, 0.0, 3.0))
        self.p0.emitter.setExplicitLaunchVector(Vec3(1.0, 0.0, 0.0))
        self.p0.emitter.setRadiateOrigin(Point3(0.0, 0.0, 0.0))
Example #36
0
    def __init__(self, parent=None):
        PooledEffect.__init__(self)
        EffectController.__init__(self)
        if parent is not None:
            self.reparentTo(parent)

        self.loopEffect = None
        self.effectScale = 1.0
        model = loader.loadModel('models/effects/particleMaps')
        self.card = model.find('**/pir_t_efx_msc_lavaSplash')
        if not LavaBurst.particleDummy:
            LavaBurst.particleDummy = base.effectsRoot.attachNewNode(
                ModelNode('LavaBurstParticleDummy'))
            LavaBurst.particleDummy.setDepthWrite(0)
            LavaBurst.particleDummy.setColorScaleOff()
            LavaBurst.particleDummy.setLightOff()
            LavaBurst.particleDummy.setBin('fixed', 50)

        self.f = ParticleEffect.ParticleEffect('LavaEruption')
        self.p0 = Particles.Particles('particles-1')
        self.p0.setFactory('ZSpinParticleFactory')
        self.p0.setRenderer('SpriteParticleRenderer')
        self.p0.setEmitter('SphereVolumeEmitter')
        self.f0 = ForceGroup.ForceGroup('gravity')
        self.force0 = LinearVectorForce(Vec3(0.0, 0.0, -8.0), 1.0, 0)
        self.force0.setVectorMasks(0, 0, 1)
        self.force0.setActive(1)
        self.f0.addForce(self.force0)
        self.f.addForceGroup(self.f0)
        self.p0.setPoolSize(12)
        self.p0.setBirthRate(100)
        self.p0.setLitterSize(4)
        self.p0.setLitterSpread(0)
        self.p0.setSystemLifespan(0.0)
        self.p0.setLocalVelocityFlag(1)
        self.p0.setSystemGrowsOlderFlag(0)
        self.p0.factory.setLifespanBase(2.0)
        self.p0.factory.setLifespanSpread(0.0)
        self.p0.factory.setMassBase(1.0)
        self.p0.factory.setMassSpread(0.0)
        self.p0.factory.setTerminalVelocityBase(400.0)
        self.p0.factory.setTerminalVelocitySpread(0.0)
        self.p0.factory.setInitialAngle(0.0)
        self.p0.factory.setInitialAngleSpread(15.0)
        self.p0.factory.enableAngularVelocity(1)
        self.p0.factory.setAngularVelocity(0.0)
        self.p0.factory.setAngularVelocitySpread(30.0)
        self.p0.renderer.setAlphaMode(BaseParticleRenderer.PRALPHAOUT)
        self.p0.renderer.setUserAlpha(1.0)
        self.p0.renderer.setFromNode(self.card)
        self.p0.renderer.setColor(
            Vec4(1.0, 0.80000000000000004, 0.80000000000000004, 1.0))
        self.p0.renderer.setXScaleFlag(1)
        self.p0.renderer.setYScaleFlag(1)
        self.p0.renderer.setAnimAngleFlag(1)
        self.p0.renderer.setNonanimatedTheta(0.0)
        self.p0.renderer.setAlphaBlendMethod(
            BaseParticleRenderer.PPBLENDLINEAR)
        self.p0.renderer.setAlphaDisable(0)
        self.p0.renderer.setColorBlendMode(ColorBlendAttrib.MAdd,
                                           ColorBlendAttrib.OIncomingAlpha,
                                           ColorBlendAttrib.OOne)
        self.p0.emitter.setEmissionType(BaseParticleEmitter.ETRADIATE)
        self.p0.emitter.setAmplitude(1.0)
        self.p0.emitter.setAmplitudeSpread(0.0)
        self.p0.emitter.setOffsetForce(Vec3(0.0, 0.0, 20.0))
        self.p0.emitter.setExplicitLaunchVector(Vec3(1.0, 0.0, 0.0))
        self.p0.emitter.setRadiateOrigin(Point3(0.0, 0.0, 0.0))
        self.p0.emitter.setRadius(0.5)
        self.f.addParticles(self.p0)
    def __init__(self):
        PooledEffect.__init__(self)
        EffectController.__init__(self)
        model = loader.loadModel('models/effects/particleMaps')
        self.card = model.find('**/particleWhiteSmoke')
        self.speed = 20.0
        if not VoodooSmokeAura.particleDummy:
            VoodooSmokeAura.particleDummy = render.attachNewNode(
                ModelNode('VoodooSmokeAuraParticleDummy'))
            VoodooSmokeAura.particleDummy.setDepthWrite(0)
            VoodooSmokeAura.particleDummy.setLightOff()

        self.f = ParticleEffect.ParticleEffect('VoodooSmokeAura')
        self.f.reparentTo(self)
        self.p0 = Particles.Particles('particles-1')
        self.p0.setFactory('PointParticleFactory')
        self.p0.setRenderer('SpriteParticleRenderer')
        self.p0.setEmitter('DiscEmitter')
        self.f.addParticles(self.p0)
        self.p0.setPoolSize(64)
        self.p0.setBirthRate(0.029999999999999999)
        self.p0.setLitterSize(1)
        self.p0.setLitterSpread(0)
        self.p0.setSystemLifespan(0.0)
        self.p0.setLocalVelocityFlag(1)
        self.p0.setSystemGrowsOlderFlag(0)
        self.p0.factory.setLifespanBase(1.5)
        self.p0.factory.setLifespanSpread(1.0)
        self.p0.factory.setMassBase(1.0)
        self.p0.factory.setMassSpread(0.0)
        self.p0.factory.setTerminalVelocityBase(400.0)
        self.p0.factory.setTerminalVelocitySpread(0.0)
        self.p0.renderer.setAlphaMode(BaseParticleRenderer.PRALPHAINOUT)
        self.p0.renderer.setUserAlpha(1.0)
        self.p0.renderer.setFromNode(self.card)
        self.p0.renderer.setColor(
            Vec4(0.80000000000000004, 0.80000000000000004, 0.80000000000000004,
                 0.59999999999999998))
        self.p0.renderer.setXScaleFlag(1)
        self.p0.renderer.setYScaleFlag(1)
        self.p0.renderer.setAnimAngleFlag(0)
        self.p0.renderer.setInitialXScale(0.025000000000000001 *
                                          self.cardScale)
        self.p0.renderer.setFinalXScale(0.01 * self.cardScale)
        self.p0.renderer.setInitialYScale(0.01 * self.cardScale)
        self.p0.renderer.setFinalYScale(0.01 * self.cardScale)
        self.p0.renderer.setNonanimatedTheta(0.0)
        self.p0.renderer.setAlphaBlendMethod(
            BaseParticleRenderer.PPBLENDLINEAR)
        self.p0.renderer.setAlphaDisable(0)
        self.p0.renderer.setColorBlendMode(
            ColorBlendAttrib.MAdd, ColorBlendAttrib.OIncomingColor,
            ColorBlendAttrib.OOneMinusIncomingAlpha)
        self.p0.renderer.getColorInterpolationManager().addLinear(
            0.0, 0.20000000000000001, Vec4(0, 0, 0, 0),
            Vec4(1.0, 0.40000000000000002, 0.40000000000000002, 1), 1)
        self.p0.renderer.getColorInterpolationManager().addLinear(
            0.20000000000000001, 1.0,
            Vec4(1.0, 0.40000000000000002, 0.40000000000000002, 1.0),
            Vec4(0, 0, 0, 1), 1)
        self.p0.emitter.setEmissionType(BaseParticleEmitter.ETRADIATE)
        self.p0.emitter.setAmplitude(0.0)
        self.p0.emitter.setAmplitudeSpread(0.10000000000000001)
        self.p0.emitter.setOffsetForce(Vec3(0.0, 0.0, 1.0))
        self.p0.emitter.setExplicitLaunchVector(Vec3(1.0, 0.0, 2.0))
        self.p0.emitter.setRadiateOrigin(Point3(0.0, 0.0, 0.0))
        self.p0.emitter.setRadius(10.0)
Example #38
0
 def __init__(self):
     PooledEffect.__init__(self)
     EffectController.__init__(self)
     model = loader.loadModel(
         'phase_4/models/props/tt_m_efx_ext_fireworkCards')
     self.card = model.find('**/tt_t_efx_ext_particleStars')
     self.cardScale = 64.0
     self.setDepthWrite(0)
     self.setColorScaleOff()
     self.setLightOff()
     self.effectScale = 1.0
     self.effectColor = Vec4(1, 1, 1, 1)
     self.f = ParticleEffect.ParticleEffect('StarBurst')
     self.f.reparentTo(self)
     self.p0 = Particles.Particles('particles-0')
     self.p0.setFactory('ZSpinParticleFactory')
     self.p0.setRenderer('SpriteParticleRenderer')
     self.p0.setEmitter('SphereSurfaceEmitter')
     self.f.addParticles(self.p0)
     f0 = ForceGroup.ForceGroup('Gravity')
     force0 = LinearVectorForce(Vec3(0.0, 0.0, -25.0), 1.0, 0)
     force0.setVectorMasks(1, 1, 1)
     force0.setActive(1)
     f0.addForce(force0)
     self.f.addForceGroup(f0)
     self.p0.setPoolSize(128)
     self.p0.setBirthRate(0.04)
     self.p0.setLitterSize(64)
     self.p0.setLitterSpread(0)
     self.p0.setSystemLifespan(0.0)
     self.p0.setLocalVelocityFlag(1)
     self.p0.setSystemGrowsOlderFlag(0)
     self.p0.factory.setLifespanBase(1.25)
     self.p0.factory.setLifespanSpread(0.5)
     self.p0.factory.setMassBase(1.0)
     self.p0.factory.setMassSpread(0.0)
     self.p0.factory.setTerminalVelocityBase(400.0)
     self.p0.factory.setTerminalVelocitySpread(0.0)
     self.p0.factory.setInitialAngle(0.0)
     self.p0.factory.setInitialAngleSpread(360.0)
     self.p0.factory.enableAngularVelocity(1)
     self.p0.factory.setAngularVelocity(0.0)
     self.p0.factory.setAngularVelocitySpread(0.0)
     self.p0.renderer.setAlphaMode(BaseParticleRenderer.PRALPHAOUT)
     self.p0.renderer.setUserAlpha(1.0)
     self.p0.renderer.setColorBlendMode(ColorBlendAttrib.MAdd,
                                        ColorBlendAttrib.OIncomingAlpha,
                                        ColorBlendAttrib.OOne)
     self.p0.renderer.setFromNode(self.card)
     self.p0.renderer.setColor(Vec4(1.0, 1.0, 1.0, 1.0))
     self.p0.renderer.setXScaleFlag(1)
     self.p0.renderer.setYScaleFlag(1)
     self.p0.renderer.setAnimAngleFlag(1)
     self.p0.renderer.setNonanimatedTheta(0.0)
     self.p0.renderer.setAlphaBlendMethod(
         BaseParticleRenderer.PPBLENDLINEAR)
     self.p0.renderer.setAlphaDisable(0)
     self.p0.renderer.getColorInterpolationManager().addLinear(
         0.0, 0.1, Vec4(0, 0, 0, 0), self.effectColor, 1)
     self.p0.emitter.setEmissionType(BaseParticleEmitter.ETRADIATE)
     self.p0.emitter.setOffsetForce(Vec3(0.0, 0.0, 0.0))
     self.p0.emitter.setExplicitLaunchVector(Vec3(1.0, 0.0, 0.0))
     self.p0.emitter.setRadiateOrigin(Point3(0.0, 0.0, 0.0))
     self.setEffectScale(self.effectScale)
     self.setEffectColor(self.effectColor)
 def cleanUpEffect(self):
     self.effectModel.hide()
     EffectController.cleanUpEffect(self)
     if self.pool and self.pool.isUsed(self):
         self.pool.checkin(self)
Example #40
0
    def __init__(self):
        PooledEffect.__init__(self)
        EffectController.__init__(self)
        
        model = loader.loadModel("phase_4/models/props/tt_m_efx_ext_fireworkCards")
        self.card = model.find("**/tt_t_efx_ext_particleSpark_sharp")
        self.cardScale = 16.0

        self.setDepthWrite(0)
        self.setColorScaleOff()
        self.setLightOff()

        self.startDelay = 0.0
        self.effectScale = 1.0
        self.effectColor = Vec4(1,1,1,1)
        
        # Load Particle Effects
        self.f = ParticleEffect.ParticleEffect("Sparkles")
        self.f.reparentTo(self)
        
        self.p0 = Particles.Particles('particles-2')
        self.p0.setFactory("PointParticleFactory")
        self.p0.setRenderer("SpriteParticleRenderer")
        self.p0.setEmitter("SphereVolumeEmitter")

        self.f.addParticles(self.p0)

        # Setup forces
        f0 = ForceGroup.ForceGroup('Gravity')
        force0 = LinearVectorForce(Vec3(0.0, 0.0, -15.0), 1.0, 0)
        force0.setVectorMasks(1, 1, 1)
        force0.setActive(1)
        f0.addForce(force0)
        self.f.addForceGroup(f0)

        self.p0.setPoolSize(64)
        self.p0.setBirthRate(0.02)
        self.p0.setLitterSize(10)
        self.p0.setLitterSpread(0)
        self.p0.setSystemLifespan(0.0)
        self.p0.setLocalVelocityFlag(1)
        self.p0.setSystemGrowsOlderFlag(0)
        # Factory parameters
        self.p0.factory.setLifespanBase(1.5)
        self.p0.factory.setLifespanSpread(1.0)
        self.p0.factory.setMassBase(1.0000)
        self.p0.factory.setMassSpread(0.0000)
        self.p0.factory.setTerminalVelocityBase(400.0)
        self.p0.factory.setTerminalVelocitySpread(0.0)
        # Renderer parameters
        self.p0.renderer.setAlphaMode(BaseParticleRenderer.PRALPHAOUT)
        self.p0.renderer.setUserAlpha(1.0)
        self.p0.renderer.setColorBlendMode(ColorBlendAttrib.MAdd,ColorBlendAttrib.OIncomingAlpha,ColorBlendAttrib.OOne)
        # Sprite parameters
        self.p0.renderer.setFromNode(self.card)
        self.p0.renderer.setColor(Vec4(1.0, 1.0, 1.0, 1.0))
        self.p0.renderer.setXScaleFlag(1)
        self.p0.renderer.setYScaleFlag(1)
        self.p0.renderer.setAnimAngleFlag(1)
        self.p0.renderer.setNonanimatedTheta(0.0000)
        self.p0.renderer.setAlphaBlendMethod(BaseParticleRenderer.PPBLENDLINEAR)
        self.p0.renderer.setAlphaDisable(0)
        self.p0.renderer.getColorInterpolationManager().addLinear(0.0,.1,Vec4(0,0,0,0),self.effectColor,1)
        # Emitter parameters
        self.p0.emitter.setEmissionType(BaseParticleEmitter.ETRADIATE)
        self.p0.emitter.setAmplitudeSpread(0.0000)
        self.p0.emitter.setOffsetForce(Vec3(0.0, 0.0, 0.0))
        self.p0.emitter.setExplicitLaunchVector(Vec3(1.0, 0.0, 0.0))
        self.p0.emitter.setRadiateOrigin(Point3(0.0, 0.0, 0.0))
        self.setEffectScale(self.effectScale)
        self.setEffectColor(self.effectColor)
 def __init__(self):
     PooledEffect.__init__(self)
     EffectController.__init__(self)
Example #42
0
 def __init__(self):
     PooledEffect.__init__(self)
     EffectController.__init__(self)
     self.modelParent = self.attachNewNode('ModelParent')
     model = loader.loadModel('models/effects/particleCards')
     self.effectModel = model.find('**/particleWhiteGlow')
     self.effectModel.reparentTo(self.modelParent)
     model = loader.loadModel('models/effects/particleCards')
     self.effectModel2 = model.find('**/particleWhiteGlow')
     self.effectModel2.reparentTo(self.modelParent)
     self.modelParent.setBillboardAxis(0)
     self.modelParent.setBillboardPointWorld()
     self.modelParent.setBin
     self.modelParent.setScale(1.4)
     self.modelParent.setColorScale(0, 0, 0, 1.0)
     self.modelParent.setBin('fixed', 0)
     self.effectActor = Actor.Actor(
         'models/effects/mopath_none',
         {'spin': 'models/effects/mopath_spiral'})
     self.effectActor.setPlayRate(-1.6, 'spin')
     self.effectActor.reparentTo(self)
     self.effectActor.setH(-90)
     self.effectActor.setPos(-0.6, -0.2, 0)
     self.effectActor.setScale(1, 1.2, 1)
     self.effectActor.setBin('fixed', 2)
     self.joint = self.effectActor.find('**/joint1')
     model = loader.loadModel('models/effects/particleMaps')
     self.card = model.find('**/particleEvilSmoke')
     if not self.particleDummy:
         self.particleDummy = render.attachNewNode(
             ModelNode('FlamingSkullParticleDummy'))
         self.particleDummy.setBin('fixed', 1)
     self.setDepthWrite(0)
     self.setFogOff()
     self.setLightOff()
     self.setColorScaleOff()
     self.hide(OTPRender.ShadowCameraBitmask)
     self.f = ParticleEffect.ParticleEffect('BlackspotCurseSword')
     self.f.reparentTo(self)
     self.p0 = Particles.Particles('particles-1')
     self.p0.setFactory('ZSpinParticleFactory')
     self.p0.setRenderer('SpriteParticleRenderer')
     self.p0.setEmitter('SphereVolumeEmitter')
     self.f.addParticles(self.p0)
     self.p0.setPoolSize(64)
     self.p0.setBirthRate(0.2)
     self.p0.setLitterSize(1)
     self.p0.setLitterSpread(0)
     self.p0.setSystemLifespan(0.0)
     self.p0.setLocalVelocityFlag(1)
     self.p0.setSystemGrowsOlderFlag(0)
     self.p0.factory.setLifespanBase(1.2)
     self.p0.factory.setLifespanSpread(0.5)
     self.p0.factory.setMassBase(1.0)
     self.p0.factory.setMassSpread(0.2)
     self.p0.factory.setTerminalVelocityBase(400.0)
     self.p0.factory.setTerminalVelocitySpread(0.0)
     self.p0.factory.setInitialAngle(0.0)
     self.p0.factory.setInitialAngleSpread(90.0)
     self.p0.factory.enableAngularVelocity(1)
     self.p0.factory.setAngularVelocity(0.0)
     self.p0.factory.setAngularVelocitySpread(20.0)
     self.p0.renderer.setAlphaMode(BaseParticleRenderer.PRALPHAOUT)
     self.p0.renderer.setUserAlpha(1.0)
     self.p0.renderer.setFromNode(self.card)
     self.p0.renderer.setColor(Vec4(1.0, 1.0, 1.0, 1.0))
     self.p0.renderer.setXScaleFlag(1)
     self.p0.renderer.setYScaleFlag(1)
     self.p0.renderer.setAnimAngleFlag(1)
     self.p0.renderer.setInitialXScale(0.001 * self.cardScale)
     self.p0.renderer.setInitialYScale(0.0012 * self.cardScale)
     self.p0.renderer.setFinalXScale(0.0003 * self.cardScale)
     self.p0.renderer.setFinalYScale(0.0003 * self.cardScale)
     self.p0.renderer.setNonanimatedTheta(0.0)
     self.p0.renderer.setAlphaBlendMethod(
         BaseParticleRenderer.PPBLENDLINEAR)
     self.p0.renderer.setAlphaDisable(0)
     self.p0.renderer.getColorInterpolationManager().addLinear(
         0.0, 1.0, Vec4(0.5, 0.5, 0.5, 1.0), Vec4(0, 0, 0, 1.0), 1)
     self.p0.emitter.setEmissionType(BaseParticleEmitter.ETRADIATE)
     self.p0.emitter.setAmplitude(-0.25)
     self.p0.emitter.setAmplitudeSpread(0.5)
     self.p0.emitter.setOffsetForce(Vec3(0.0, 0.0, 0.5))
     self.p0.emitter.setExplicitLaunchVector(Vec3(1.0, 0.0, 0.0))
     self.p0.emitter.setRadiateOrigin(Point3(0.0, 0.0, 0.0))
     self.p0.emitter.setRadius(0.4)
     self.f2 = ParticleEffect.ParticleEffect('BlackspotPestilence')
     self.f2.reparentTo(self)
     self.p1 = Particles.Particles('particles-1')
     self.p1.setFactory('ZSpinParticleFactory')
     self.p1.setRenderer('SpriteParticleRenderer')
     self.p1.setEmitter('SphereVolumeEmitter')
     self.f2.addParticles(self.p1)
     self.p1.setPoolSize(128)
     self.p1.setBirthRate(0.01)
     self.p1.setLitterSize(2)
     self.p1.setLitterSpread(0)
     self.p1.setSystemLifespan(0.0)
     self.p1.setLocalVelocityFlag(0)
     self.p1.setSystemGrowsOlderFlag(0)
     self.p1.factory.setLifespanBase(1.0)
     self.p1.factory.setLifespanSpread(0.2)
     self.p1.factory.setMassBase(1.0)
     self.p1.factory.setMassSpread(0.0)
     self.p1.factory.setTerminalVelocityBase(400.0)
     self.p1.factory.setTerminalVelocitySpread(0.0)
     self.p1.factory.setInitialAngle(0.0)
     self.p1.factory.setInitialAngleSpread(360.0)
     self.p1.factory.enableAngularVelocity(1)
     self.p1.factory.setAngularVelocity(300.0)
     self.p1.factory.setAngularVelocitySpread(25.0)
     self.p1.renderer.setAlphaMode(BaseParticleRenderer.PRALPHAOUT)
     self.p1.renderer.setUserAlpha(1.0)
     self.p1.renderer.setFromNode(self.card)
     self.p1.renderer.setXScaleFlag(1)
     self.p1.renderer.setYScaleFlag(1)
     self.p1.renderer.setAnimAngleFlag(1)
     self.p1.renderer.setNonanimatedTheta(0.0)
     self.p1.renderer.setAlphaBlendMethod(
         BaseParticleRenderer.PPBLENDLINEAR)
     self.p1.renderer.setAlphaDisable(0)
     self.p1.renderer.getColorInterpolationManager().addLinear(
         0.0, 1.0, Vec4(0.5, 0.5, 0.5, 1.0), Vec4(0, 0, 0, 1.0), 1)
     self.p1.renderer.setInitialXScale(0.001 * self.cardScale2)
     self.p1.renderer.setFinalXScale(0.0001 * self.cardScale2)
     self.p1.renderer.setInitialYScale(0.001 * self.cardScale2)
     self.p1.renderer.setFinalYScale(0.0001 * self.cardScale2)
     self.p1.emitter.setEmissionType(BaseParticleEmitter.ETRADIATE)
     self.p1.emitter.setAmplitude(0.2)
     self.p1.emitter.setAmplitudeSpread(0.5)
     self.p1.emitter.setOffsetForce(Vec3(0.0, 0.0, -0.45))
     self.p1.emitter.setExplicitLaunchVector(Vec3(1.0, 0.0, 0.0))
     self.p1.emitter.setRadiateOrigin(Point3(0.0, 0.0, 0.0))
     self.p1.emitter.setRadius(0.01)
Example #43
0
 def cleanUpEffect(self):
     EffectController.cleanUpEffect(self)
     if self.pool and self.pool.isUsed(self):
         self.pool.checkin(self)
Example #44
0
 def __init__(self, effectParent=None):
     PooledEffect.__init__(self)
     EffectController.__init__(self)
     if effectParent:
         self.reparentTo(effectParent)
     model = loader.loadModel('models/effects/particleMaps')
     self.card = model.find('**/particleFire2')
     self.effectScale = 1.0
     if not TentacleFire.particleDummy:
         TentacleFire.particleDummy = base.effectsRoot.attachNewNode(ModelNode('FireParticleDummy'))
         TentacleFire.particleDummy.setDepthWrite(0)
         TentacleFire.particleDummy.setFogOff()
         TentacleFire.particleDummy.setLightOff()
         TentacleFire.particleDummy.setColorScaleOff()
         TentacleFire.particleDummy.setBin('fixed', 120)
         TentacleFire.particleDummy.setTwoSided(1)
         TentacleFire.particleDummy.setAttrib(ColorWriteAttrib.make(ColorWriteAttrib.CRed | ColorWriteAttrib.CGreen | ColorWriteAttrib.CBlue))
     self.f = ParticleEffect.ParticleEffect('TentacleFire')
     self.f.reparentTo(self)
     self.p0 = Particles.Particles('particles-1')
     self.p0.setFactory('ZSpinParticleFactory')
     self.p0.setRenderer('SpriteParticleRenderer')
     self.p0.setEmitter('RectangleEmitter')
     self.f.addParticles(self.p0)
     self.p0.setPoolSize(64)
     self.p0.setBirthRate(0.01)
     self.p0.setLitterSize(3)
     self.p0.setLitterSpread(0)
     self.p0.setSystemLifespan(0.0)
     self.p0.setLocalVelocityFlag(1)
     self.p0.setSystemGrowsOlderFlag(0)
     self.p0.setFloorZ(-1.0)
     self.p0.factory.setLifespanBase(0.6)
     self.p0.factory.setLifespanSpread(0.2)
     self.p0.factory.setMassBase(1.0)
     self.p0.factory.setMassSpread(0.0)
     self.p0.factory.setTerminalVelocityBase(400.0)
     self.p0.factory.setTerminalVelocitySpread(0.0)
     self.p0.factory.setInitialAngle(0.0)
     self.p0.factory.setInitialAngleSpread(360.0)
     self.p0.factory.enableAngularVelocity(1)
     self.p0.factory.setAngularVelocity(0.0)
     self.p0.factory.setAngularVelocitySpread(350.0)
     self.p0.renderer.setAlphaMode(BaseParticleRenderer.PRALPHAOUT)
     self.p0.renderer.setUserAlpha(1.0)
     self.p0.renderer.setFromNode(self.card)
     self.p0.renderer.setColor(Vec4(1.0, 1.0, 1.0, 1.0))
     self.p0.renderer.setXScaleFlag(1)
     self.p0.renderer.setYScaleFlag(1)
     self.p0.renderer.setAnimAngleFlag(1)
     self.p0.renderer.setNonanimatedTheta(0.0)
     self.p0.renderer.setAlphaBlendMethod(BaseParticleRenderer.PPNOBLEND)
     self.p0.renderer.setColorBlendMode(ColorBlendAttrib.MAdd, ColorBlendAttrib.OIncomingAlpha, ColorBlendAttrib.OOne)
     self.p0.renderer.getColorInterpolationManager().addLinear(0.0, 1.0, Vec4(1.0, 0.6, 0.2, 1.0), Vec4(0.5, 0.2, 0.2, 0.5), 1)
     self.p0.renderer.setAlphaDisable(0)
     self.p0.emitter.setEmissionType(BaseParticleEmitter.ETRADIATE)
     self.p0.emitter.setAmplitude(-1.0)
     self.p0.emitter.setAmplitudeSpread(0.25)
     self.p0.emitter.setExplicitLaunchVector(Vec3(1.0, 0.0, 0.0))
     self.p0.emitter.setOffsetForce(Vec3(0.0, 1.0, 15.0))
     self.p0.emitter.setRadiateOrigin(Point3(0.0, 0.0, 0.0))
     self.setEffectScale(self.effectScale)
Example #45
0
    def __init__(self, effectParent=None):
        PooledEffect.__init__(self)
        EffectController.__init__(self)
        self.effectScale = 1.0
        model = loader.loadModel('models/effects/particleCards')
        self.card = model.find('**/particleSparkle')
        if not FireSparks.particleDummy:
            FireSparks.particleDummy = base.effectsRoot.attachNewNode(
                ModelNode('FireSparksParticleDummy'))
            FireSparks.particleDummy.setColorScaleOff()
            FireSparks.particleDummy.setDepthWrite(0)
            FireSparks.particleDummy.setLightOff()
            FireSparks.particleDummy.setBin('fixed', 70)

        self.f = ParticleEffect.ParticleEffect('FireSparks')
        self.f.reparentTo(self)
        self.p0 = Particles.Particles('particles-sparks')
        self.p0.setFactory('PointParticleFactory')
        self.p0.setRenderer('SpriteParticleRenderer')
        self.p0.setEmitter('DiscEmitter')
        self.f.addParticles(self.p0)
        f0 = ForceGroup.ForceGroup('Noise')
        self.noiseForce = LinearNoiseForce(10.0, 10.0)
        self.noiseForce.setVectorMasks(1, 1, 1)
        self.noiseForce.setActive(0)
        f0.addForce(self.noiseForce)
        self.f.addForceGroup(f0)
        self.p0.setPoolSize(64)
        self.p0.setBirthRate(0.20000000000000001)
        self.p0.setLitterSize(12)
        self.p0.setLitterSpread(0)
        self.p0.setSystemLifespan(0.0)
        self.p0.setLocalVelocityFlag(1)
        self.p0.setSystemGrowsOlderFlag(0)
        self.p0.factory.setLifespanBase(1.0)
        self.p0.factory.setLifespanSpread(0.5)
        self.p0.factory.setMassBase(1.0)
        self.p0.factory.setMassSpread(0.20000000000000001)
        self.p0.factory.setTerminalVelocityBase(400.0)
        self.p0.factory.setTerminalVelocitySpread(0.0)
        self.p0.renderer.setAlphaMode(BaseParticleRenderer.PRALPHAOUT)
        self.p0.renderer.setUserAlpha(1.0)
        self.p0.renderer.setFromNode(self.card)
        self.p0.renderer.setColor(
            Vec4(1.0, 0.59999999999999998, 0.20000000000000001, 1.0))
        self.p0.renderer.setXScaleFlag(1)
        self.p0.renderer.setYScaleFlag(1)
        self.p0.renderer.setAnimAngleFlag(1)
        self.p0.renderer.setInitialXScale(0.0080000000000000002 *
                                          self.cardScale)
        self.p0.renderer.setInitialYScale(0.0080000000000000002 *
                                          self.cardScale)
        self.p0.renderer.setFinalXScale(0.016 * self.cardScale)
        self.p0.renderer.setFinalYScale(0.016 * self.cardScale)
        self.p0.renderer.setNonanimatedTheta(0.0)
        self.p0.renderer.setAlphaBlendMethod(BaseParticleRenderer.PPNOBLEND)
        self.p0.renderer.setColorBlendMode(ColorBlendAttrib.MAdd,
                                           ColorBlendAttrib.OIncomingAlpha,
                                           ColorBlendAttrib.OOne)
        self.p0.renderer.setAlphaDisable(0)
        self.p0.emitter.setEmissionType(BaseParticleEmitter.ETCUSTOM)
        self.p0.emitter.setAmplitude(3.0)
        self.p0.emitter.setAmplitudeSpread(3.0)
        self.p0.emitter.setOffsetForce(Vec3(2.0, 2.0, 20.0))
        self.p0.emitter.setExplicitLaunchVector(Vec3(1.0, 0.0, 0.0))
        self.p0.emitter.setRadiateOrigin(Point3(0.0, 0.0, 1.0))
        self.p0.emitter.setRadius(5.0)
Example #46
0
 def __init__(self, parent=None):
     PooledEffect.__init__(self)
     EffectController.__init__(self)
     if parent is not None:
         self.reparentTo(parent)
     if not EvilRingEffect.particleDummy:
         EvilRingEffect.particleDummy = render.attachNewNode(
             ModelNode('EvilRingEffectParticleDummy'))
         EvilRingEffect.particleDummy.setColorScaleOff()
         EvilRingEffect.particleDummy.setLightOff()
         EvilRingEffect.particleDummy.setFogOff()
         EvilRingEffect.particleDummy.setDepthWrite(0)
         EvilRingEffect.particleDummy.setDepthTest(0)
         EvilRingEffect.particleDummy.setBin('shadow', 0)
         EvilRingEffect.particleDummy.setTransparency(
             TransparencyAttrib.MAlpha)
     self.effectScale = 1.0
     self.effectColor = Vec4(1, 1, 1, 1)
     self.duration = 4.0
     model = loader.loadModel('models/effects/particleMaps')
     self.card = model.find('**/particleDarkSmoke')
     self.f = ParticleEffect.ParticleEffect('EvilRingEffect')
     self.f.reparentTo(self)
     self.p0 = Particles.Particles('particles-1')
     self.p0.setFactory('ZSpinParticleFactory')
     self.p0.setRenderer('SpriteParticleRenderer')
     self.p0.setEmitter('RingEmitter')
     self.f.addParticles(self.p0)
     self.p0.setPoolSize(256)
     self.p0.setBirthRate(0.0)
     self.p0.setLitterSize(8)
     self.p0.setLitterSpread(0)
     self.p0.setSystemLifespan(0.0)
     self.p0.setLocalVelocityFlag(1)
     self.p0.setSystemGrowsOlderFlag(0)
     self.p0.factory.setLifespanBase(0.35)
     self.p0.factory.setLifespanSpread(0.0)
     self.p0.factory.setMassBase(1.0)
     self.p0.factory.setMassSpread(0.0)
     self.p0.factory.setTerminalVelocityBase(400.0)
     self.p0.factory.setTerminalVelocitySpread(0.0)
     self.p0.factory.setInitialAngle(0.0)
     self.p0.factory.setInitialAngleSpread(10.0)
     self.p0.factory.enableAngularVelocity(0)
     self.p0.factory.setFinalAngle(90.0)
     self.p0.factory.setFinalAngleSpread(0.0)
     self.p0.renderer.setAlphaMode(BaseParticleRenderer.PRALPHAOUT)
     self.p0.renderer.setUserAlpha(1.0)
     self.p0.renderer.setFromNode(self.card)
     self.p0.renderer.setColor(Vec4(1.0, 1.0, 1.0, 1.0))
     self.p0.renderer.setXScaleFlag(1)
     self.p0.renderer.setYScaleFlag(1)
     self.p0.renderer.setAnimAngleFlag(1)
     self.p0.renderer.setInitialXScale(0.005 * self.cardScale)
     self.p0.renderer.setFinalXScale(0.03 * self.cardScale)
     self.p0.renderer.setInitialYScale(0.005 * self.cardScale)
     self.p0.renderer.setFinalYScale(0.025 * self.cardScale)
     self.p0.renderer.setNonanimatedTheta(0.0)
     self.p0.renderer.setAlphaBlendMethod(
         BaseParticleRenderer.PPBLENDLINEAR)
     self.p0.renderer.setAlphaDisable(0)
     self.p0.renderer.setColorBlendMode(
         ColorBlendAttrib.MAdd, ColorBlendAttrib.OOneMinusFbufferAlpha,
         ColorBlendAttrib.OOneMinusIncomingAlpha)
     self.p0.renderer.getColorInterpolationManager().addLinear(
         0.0, 1.0, Vec4(1.0, 1.0, 1.0, 1.0), Vec4(0.6, 0.8, 0.7, 0.4), 1)
     self.p0.emitter.setEmissionType(BaseParticleEmitter.ETRADIATE)
     self.p0.emitter.setAmplitude(1.0)
     self.p0.emitter.setAmplitudeSpread(0.0)
     self.p0.emitter.setOffsetForce(Vec3(0.0, 0.0, 0.0))
     self.p0.emitter.setExplicitLaunchVector(Vec3(1.0, 0.0, 0.0))
     self.p0.emitter.setRadiateOrigin(Point3(0.0, 0.0, 0.0))
     self.p0.emitter.setRadius(0.0)
     self.p0.emitter.setRadiusSpread(0.0)
     return
Example #47
0
 def __init__(self):
     PooledEffect.__init__(self)
     EffectController.__init__(self)
     model = loader.loadModel(
         'phase_4/models/props/tt_m_efx_ext_fireworkCards')
     self.card = model.find('**/tt_t_efx_ext_particleSpark_soft')
     self.cardScale = 16.0
     self.setDepthWrite(0)
     self.setColorScaleOff()
     self.setLightOff()
     self.effectScale = 1.0
     self.effectColor = Vec4(1, 1, 1, 1)
     self.f = ParticleEffect.ParticleEffect('NoiseSparkles')
     self.f.reparentTo(self)
     self.p0 = Particles.Particles('particles-2')
     self.p0.setFactory('PointParticleFactory')
     self.p0.setRenderer('SpriteParticleRenderer')
     self.p0.setEmitter('SphereSurfaceEmitter')
     self.f.addParticles(self.p0)
     f0 = ForceGroup.ForceGroup('Gravity')
     force0 = LinearVectorForce(Vec3(0.0, 0.0, 10.0), 1.0, 0)
     force0.setVectorMasks(1, 1, 1)
     force0.setActive(1)
     f0.addForce(force0)
     self.f.addForceGroup(f0)
     f1 = ForceGroup.ForceGroup('Noise')
     self.noiseForce = LinearNoiseForce(10.0, 0.0)
     self.noiseForce.setVectorMasks(1, 1, 1)
     self.noiseForce.setActive(0)
     f1.addForce(self.noiseForce)
     self.f.addForceGroup(f1)
     self.p0.setPoolSize(150)
     self.p0.setBirthRate(0.02)
     self.p0.setLitterSize(50)
     self.p0.setLitterSpread(0)
     self.p0.setSystemLifespan(0.0)
     self.p0.setLocalVelocityFlag(1)
     self.p0.setSystemGrowsOlderFlag(0)
     self.p0.factory.setLifespanBase(2.0)
     self.p0.factory.setLifespanSpread(0.5)
     self.p0.factory.setMassBase(1.0)
     self.p0.factory.setMassSpread(0.0)
     self.p0.factory.setTerminalVelocityBase(400.0)
     self.p0.factory.setTerminalVelocitySpread(0.0)
     self.p0.renderer.setAlphaMode(BaseParticleRenderer.PRALPHAUSER)
     self.p0.renderer.setUserAlpha(1.0)
     self.p0.renderer.setColorBlendMode(ColorBlendAttrib.MAdd,
                                        ColorBlendAttrib.OIncomingAlpha,
                                        ColorBlendAttrib.OOne)
     self.p0.renderer.setFromNode(self.card)
     self.p0.renderer.setColor(Vec4(1.0, 1.0, 1.0, 1.0))
     self.p0.renderer.setXScaleFlag(1)
     self.p0.renderer.setYScaleFlag(1)
     self.p0.renderer.setAnimAngleFlag(1)
     self.p0.renderer.setNonanimatedTheta(0.0)
     self.p0.renderer.setAlphaBlendMethod(
         BaseParticleRenderer.PPBLENDLINEAR)
     self.p0.renderer.setAlphaDisable(0)
     self.p0.emitter.setEmissionType(BaseParticleEmitter.ETRADIATE)
     self.p0.emitter.setAmplitudeSpread(0.0)
     self.p0.emitter.setOffsetForce(Vec3(0.0, 0.0, 0.0))
     self.p0.emitter.setExplicitLaunchVector(Vec3(1.0, 0.0, 0.0))
     self.p0.emitter.setRadiateOrigin(Point3(0.0, 0.0, 0.0))
     self.setEffectScale(self.effectScale)
     self.setEffectColor(self.effectColor)
    def __init__(self):
        PooledEffect.__init__(self)
        EffectController.__init__(self)
        model = loader.loadModel('models/effects/battleEffects')
        self.card = model.find('**/effectVoodooShockwave')
        if not self.particleDummy:
            self.particleDummy = self.attachNewNode(
                ModelNode('VoodooAura2ParticleDummy'))
            self.particleDummy.setDepthWrite(0)
            self.particleDummy.setLightOff()
            self.particleDummy.hide(OTPRender.ShadowCameraBitmask)

        self.effectColor = Vec4(1, 1, 1, 1)
        self.f = ParticleEffect.ParticleEffect('VoodooAura2')
        self.f.reparentTo(self)
        self.p0 = Particles.Particles('particles-1')
        self.p0.setFactory('PointParticleFactory')
        self.p0.setRenderer('SpriteParticleRenderer')
        self.p0.setEmitter('PointEmitter')
        self.f.addParticles(self.p0)
        self.p0.setPoolSize(64)
        self.p0.setBirthRate(0.02)
        self.p0.setLitterSize(1)
        self.p0.setLitterSpread(0)
        self.p0.setSystemLifespan(0.0)
        self.p0.setLocalVelocityFlag(0)
        self.p0.setSystemGrowsOlderFlag(0)
        self.p0.factory.setLifespanBase(1.0)
        self.p0.factory.setLifespanSpread(0.0)
        self.p0.factory.setMassBase(1.0)
        self.p0.factory.setMassSpread(0.0)
        self.p0.factory.setTerminalVelocityBase(400.0)
        self.p0.factory.setTerminalVelocitySpread(0.0)
        self.p0.renderer.setAlphaMode(BaseParticleRenderer.PRALPHAOUT)
        self.p0.renderer.setUserAlpha(0.5)
        self.p0.renderer.setFromNode(self.card)
        self.p0.renderer.setColor(Vec4(1.0, 1.0, 1.0, 1.0))
        self.p0.renderer.setXScaleFlag(1)
        self.p0.renderer.setYScaleFlag(1)
        self.p0.renderer.setAnimAngleFlag(0)
        self.p0.renderer.setInitialXScale(0.0050000000000000001 *
                                          self.cardScale)
        self.p0.renderer.setFinalXScale(0.012 * self.cardScale)
        self.p0.renderer.setInitialYScale(0.0050000000000000001 *
                                          self.cardScale)
        self.p0.renderer.setFinalYScale(0.012 * self.cardScale)
        self.p0.renderer.setNonanimatedTheta(0.0)
        self.p0.renderer.setAlphaBlendMethod(
            BaseParticleRenderer.PPBLENDLINEAR)
        self.p0.renderer.setAlphaDisable(0)
        self.p0.renderer.getColorInterpolationManager().addLinear(
            0.0, 1.0,
            Vec4(0.80000000000000004, 0.80000000000000004, 0.80000000000000004,
                 1), self.effectColor, 1)
        self.p0.renderer.setColorBlendMode(ColorBlendAttrib.MAdd,
                                           ColorBlendAttrib.OIncomingAlpha,
                                           ColorBlendAttrib.OOne)
        self.p0.emitter.setEmissionType(BaseParticleEmitter.ETRADIATE)
        self.p0.emitter.setAmplitude(0.20000000000000001)
        self.p0.emitter.setAmplitudeSpread(0.0)
        self.p0.emitter.setOffsetForce(Vec3(0.0, 0.0, 0.0))
        self.p0.emitter.setExplicitLaunchVector(Vec3(1.0, 0.0, 0.0))
        self.p0.emitter.setRadiateOrigin(Point3(0.0, 0.0, 0.0))
 def __init__(self):
     PooledEffect.__init__(self)
     EffectController.__init__(self)
     model = loader.loadModel('models/effects/particleMaps')
     self.card = model.find('**/particleDust')
     if not DustCloud.particleDummy:
         DustCloud.particleDummy = render.attachNewNode(
             ModelNode('DustCloudParticleDummy'))
         DustCloud.particleDummy.setDepthWrite(0)
         DustCloud.particleDummy.setLightOff()
     self.f = ParticleEffect.ParticleEffect('DustCloud')
     self.f.reparentTo(self)
     self.p0 = Particles.Particles('particles-1')
     self.p0.setFactory('PointParticleFactory')
     self.p0.setRenderer('SpriteParticleRenderer')
     self.p0.setEmitter('DiscEmitter')
     self.f.addParticles(self.p0)
     f0 = ForceGroup.ForceGroup('gravity')
     force0 = LinearVectorForce(Vec3(0.0, 0.0, -10.0), 1.0, 1)
     force0.setActive(1)
     f0.addForce(force0)
     self.f.addForceGroup(f0)
     self.p0.setPoolSize(64)
     self.p0.setBirthRate(0.3)
     self.p0.setLitterSize(8)
     self.p0.setLitterSpread(2)
     self.p0.setSystemLifespan(0.0)
     self.p0.setLocalVelocityFlag(1)
     self.p0.setSystemGrowsOlderFlag(0)
     self.p0.setFloorZ(-5.0)
     self.p0.factory.setLifespanBase(6.0)
     self.p0.factory.setLifespanSpread(2.0)
     self.p0.factory.setMassBase(0.3)
     self.p0.factory.setMassSpread(0.2)
     self.p0.factory.setTerminalVelocityBase(400.0)
     self.p0.factory.setTerminalVelocitySpread(0.0)
     self.p0.renderer.setAlphaMode(BaseParticleRenderer.PRALPHAOUT)
     self.p0.renderer.setUserAlpha(1.0)
     self.p0.renderer.setFromNode(self.card)
     self.p0.renderer.setColor(Vec4(1.0, 1.0, 1.0, 1.0))
     self.p0.renderer.setXScaleFlag(1)
     self.p0.renderer.setYScaleFlag(1)
     self.p0.renderer.setAnimAngleFlag(1)
     self.p0.renderer.setInitialXScale(0.02 * self.cardScale)
     self.p0.renderer.setFinalXScale(0.7 * self.cardScale)
     self.p0.renderer.setInitialYScale(0.02 * self.cardScale)
     self.p0.renderer.setFinalYScale(0.7 * self.cardScale)
     self.p0.renderer.setNonanimatedTheta(0.0)
     self.p0.renderer.setAlphaBlendMethod(BaseParticleRenderer.PPNOBLEND)
     self.p0.renderer.setAlphaDisable(0)
     self.p0.emitter.setEmissionType(BaseParticleEmitter.ETCUSTOM)
     self.p0.emitter.setAmplitude(1.0)
     self.p0.emitter.setAmplitudeSpread(0.0)
     self.p0.emitter.setOffsetForce(Vec3(0.0, 0.0, 30.0))
     self.p0.emitter.setExplicitLaunchVector(Vec3(1.0, 0.0, 0.0))
     self.p0.emitter.setRadiateOrigin(Point3(0.0, 0.0, 1.0))
     self.p0.emitter.setRadius(1.0)
     self.p0.emitter.setOuterAngle(90.0)
     self.p0.emitter.setInnerAngle(0.0)
     self.p0.emitter.setOuterMagnitude(8.0)
     self.p0.emitter.setInnerMagnitude(0.0)
     self.p0.emitter.setCubicLerping(0)
Example #50
0
    def __init__(self):
        PooledEffect.__init__(self)
        EffectController.__init__(self)
        model = loader.loadModel('models/effects/particleMaps')
        self.card = model.find('**/particleGlowBlue')
        self.faceCard = model.find('**/effectFury')
        self.faceCard.reparentTo(self)
        self.faceCard.setDepthWrite(0)
        self.faceCard.setLightOff()
        self.faceCard.setColorScale(0.0, 0.0, 0.0, 1.0)
        self.faceCard.setBillboardPointEye(3.0)
        self.faceCard.setScale(5.0)
        self.faceCard.setBin('fixed', 10)
        if not FuryTrail.particleDummy:
            FuryTrail.particleDummy = render.attachNewNode(
                ModelNode('FuryTrailParticleDummy'))
            FuryTrail.particleDummy.setDepthWrite(0)
            FuryTrail.particleDummy.setLightOff()
            FuryTrail.particleDummy.setBin('fixed', 0)

        self.f = ParticleEffect.ParticleEffect('FuryTrail')
        self.f.reparentTo(self)
        self.p0 = Particles.Particles('particles-1')
        self.p0.setFactory('PointParticleFactory')
        self.p0.setRenderer('SpriteParticleRenderer')
        self.p0.setEmitter('DiscEmitter')
        self.f.addParticles(self.p0)
        f0 = ForceGroup.ForceGroup('noise')
        force0 = LinearNoiseForce(1.5, 1)
        force0.setActive(1)
        f0.addForce(force0)
        self.f.addForceGroup(f0)
        self.p0.setPoolSize(32)
        self.p0.setBirthRate(0.01)
        self.p0.setLitterSize(1)
        self.p0.setLitterSpread(0)
        self.p0.setSystemLifespan(0.0)
        self.p0.setLocalVelocityFlag(1)
        self.p0.setSystemGrowsOlderFlag(0)
        self.p0.factory.setLifespanBase(0.29999999999999999)
        self.p0.factory.setLifespanSpread(0.0)
        self.p0.factory.setMassBase(1.0)
        self.p0.factory.setMassSpread(0.20000000000000001)
        self.p0.factory.setTerminalVelocityBase(400.0)
        self.p0.factory.setTerminalVelocitySpread(0.0)
        self.p0.renderer.setAlphaMode(BaseParticleRenderer.PRALPHAOUT)
        self.p0.renderer.setUserAlpha(1.0)
        self.p0.renderer.setFromNode(self.card)
        self.p0.renderer.setColor(Vec4(1.0, 1.0, 1.0, 1.0))
        self.p0.renderer.setXScaleFlag(1)
        self.p0.renderer.setYScaleFlag(1)
        self.p0.renderer.setAnimAngleFlag(0)
        self.p0.renderer.setInitialXScale(0.13 * self.cardScale)
        self.p0.renderer.setInitialYScale(0.13 * self.cardScale)
        self.p0.renderer.setFinalXScale(0.050000000000000003 * self.cardScale)
        self.p0.renderer.setFinalYScale(0.050000000000000003 * self.cardScale)
        self.p0.renderer.setNonanimatedTheta(0.0)
        self.p0.renderer.setAlphaBlendMethod(BaseParticleRenderer.PPNOBLEND)
        self.p0.renderer.setAlphaDisable(0)
        self.p0.emitter.setEmissionType(BaseParticleEmitter.ETRADIATE)
        self.p0.emitter.setAmplitude(-2.0)
        self.p0.emitter.setAmplitudeSpread(0.5)
        self.p0.emitter.setOffsetForce(Vec3(0.0, 0.0, 10.0))
        self.p0.renderer.setColorBlendMode(ColorBlendAttrib.MAdd,
                                           ColorBlendAttrib.OIncomingAlpha,
                                           ColorBlendAttrib.OOne)
        self.p0.emitter.setExplicitLaunchVector(Vec3(1.0, 0.0, 0.0))
        self.p0.emitter.setRadiateOrigin(Point3(0.0, 0.0, 0.0))
        self.p0.emitter.setRadius(1.0)
Example #51
0
 def destroy(self):
     EffectController.destroy(self)
     PooledEffect.destroy(self)
     self.adjustIval = None
     return
Example #52
0
 def disableEffect(self):
     EffectController.disableEffect(self)
     EffectController.stopLoop(self)
Example #53
0
 def startLoop(self, lod=None, accelerateTime=0):
     self._accelerateTime = accelerateTime
     EffectController.startLoop(self, lod)
class RemoteSL:
    """ Automap script for the Novation Remote SL.
    TODO: Add some general comments about the mappings, FX, MX left/right side...
    """

    def __init__(self, c_instance):
        self.__c_instance = c_instance
        self.__automap_has_control = False
        self.__display_controller = DisplayController(self)
        self.__effect_controller = EffectController(self, self.__display_controller)
        self.__mixer_controller = MixerController(self, self.__display_controller)
        self.__components = [self.__effect_controller, self.__mixer_controller, self.__display_controller]
        self.__update_hardware_delay = -1

    def disconnect(self):
        """Called right before we get disconnected from Live
        """
        for c in self.__components:
            c.disconnect()

        self.send_midi(ALL_LEDS_OFF_MESSAGE)
        self.send_midi(GOOD_BYE_SYSEX_MESSAGE)

    def application(self):
        """returns a reference to the application that we are running in
        """
        return Live.Application.get_application()

    def song(self):
        """returns a reference to the Live song instance that we do control
        """
        return self.__c_instance.song()

    def suggest_input_port(self):
        """Live -> Script
        Live can ask the script for an input port name to find a suitable one.
        """
        return 'RemoteSL'

    def suggest_output_port(self):
        """Live -> Script
        Live can ask the script for an output port name to find a suitable one.
        """
        return 'RemoteSL'

    def can_lock_to_devices(self):
        """Live -> Script
        Live can ask the script whether it can be locked to devices
        """
        return True

    def lock_to_device(self, device):
        """Live -> Script
        Live can tell the script to lock to a given device
        """
        self.__effect_controller.lock_to_device(device)

    def unlock_from_device(self, device):
        """Live -> Script
        Live can tell the script to unlock from a given device
        """
        self.__effect_controller.unlock_from_device(device)

    def set_appointed_device(self, device):
        """Live -> Script
        Live can tell the script which device to use if it is not locked
        This is a substitute mechanism for the listeners used by older scripts
        """
        self.__effect_controller.set_appointed_device(device)

    def toggle_lock(self):
        """Script -> Live
        Use this function to toggle the script's lock on devices
        """
        self.__c_instance.toggle_lock()

    def suggest_map_mode(self, cc_no, channel):
        """Live -> Script
        Live can ask the script to suggest a map mode for the given CC
        """
        result = Live.MidiMap.MapMode.absolute
        if cc_no in fx_encoder_row_ccs:
            result = Live.MidiMap.MapMode.relative_smooth_signed_bit
        return result

    def restore_bank(self, bank):
        self.__effect_controller.restore_bank(bank)

    def supports_pad_translation(self):
        return True

    def show_message(self, message):
        self.__c_instance.show_message(message)

    def instance_identifier(self):
        return self.__c_instance.instance_identifier()

    def connect_script_instances(self, instanciated_scripts):
        """
        Called by the Application as soon as all scripts are initialized.
        You can connect yourself to other running scripts here, as we do it
        connect the extension modules (MackieControlXTs).
        """
        pass

    def request_rebuild_midi_map(self):
        """When the internal MIDI controller has changed in a way that you need to rebuild
        the MIDI mappings, request a rebuild by calling this function
        This is processed as a request, to be sure that its not too often called, because
        its time-critical.
        """
        self.__c_instance.request_rebuild_midi_map()

    def send_midi(self, midi_event_bytes):
        """Use this function to send MIDI events through Live to the _real_ MIDI devices
        that this script is assigned to.
        """
        if not self.__automap_has_control:
            self.__c_instance.send_midi(midi_event_bytes)

    def refresh_state(self):
        """Send out MIDI to completely update the attached MIDI controller.
        Will be called when requested by the user, after for example having reconnected
        the MIDI cables...
        """
        self.__update_hardware_delay = 5

    def __update_hardware(self):
        self.__automap_has_control = False
        self.send_midi(WELCOME_SYSEX_MESSAGE)
        for c in self.__components:
            c.refresh_state()

    def build_midi_map(self, midi_map_handle):
        """Build DeviceParameter Mappings, that are processed in Audio time, or
        forward MIDI messages explicitly to our receive_midi_functions.
        Which means that when you are not forwarding MIDI, nor mapping parameters, you will
        never get any MIDI messages at all.
        """
        if not self.__automap_has_control:
            for c in self.__components:
                c.build_midi_map(self.__c_instance.handle(), midi_map_handle)

        self.__c_instance.set_pad_translation(PAD_TRANSLATION)

    def update_display(self):
        """Aka on_timer. Called every 100 ms and should be used to update display relevant
        parts of the controller only...
        """
        if self.__update_hardware_delay > 0:
            self.__update_hardware_delay -= 1
            if self.__update_hardware_delay == 0:
                self.__update_hardware()
                self.__update_hardware_delay = -1
        for c in self.__components:
            c.update_display()

    def receive_midi(self, midi_bytes):
        """MIDI messages are only received through this function, when explicitly
        forwarded in 'build_midi_map'.
        """
        if midi_bytes[0] & 240 in (NOTE_ON_STATUS, NOTE_OFF_STATUS):
            channel = midi_bytes[0] & 15
            note = midi_bytes[1]
            velocity = midi_bytes[2]
            if note in fx_notes:
                self.__effect_controller.receive_midi_note(note, velocity)
            elif note in mx_notes:
                self.__mixer_controller.receive_midi_note(note, velocity)
            else:
                print 'unknown MIDI message %s' % str(midi_bytes)
        elif midi_bytes[0] & 240 == CC_STATUS:
            channel = midi_bytes[0] & 15
            cc_no = midi_bytes[1]
            cc_value = midi_bytes[2]
            if cc_no in fx_ccs:
                self.__effect_controller.receive_midi_cc(cc_no, cc_value)
            elif cc_no in mx_ccs:
                self.__mixer_controller.receive_midi_cc(cc_no, cc_value)
            else:
                print 'unknown MIDI message %s' % str(midi_bytes)
        elif midi_bytes[0] == 240:
            if len(midi_bytes) == 13 and midi_bytes[1:4] == (0, 32, 41):
                if midi_bytes[8] == ABLETON_PID and midi_bytes[10] == 1:
                    self.__automap_has_control = midi_bytes[11] == 0
                    support_mkII = midi_bytes[6] * 100 + midi_bytes[7] >= 1800
                    if not self.__automap_has_control:
                        self.send_midi(ALL_LEDS_OFF_MESSAGE)
                    for c in self.__components:
                        c.set_support_mkII(support_mkII)
                        if not self.__automap_has_control:
                            c.refresh_state()

                    self.request_rebuild_midi_map()
        else:
            print 'unknown MIDI message %s' % str(midi_bytes)
Example #55
0
 def __init__(self, parent=None):
     PooledEffect.__init__(self)
     EffectController.__init__(self)
     if parent is not None:
         self.reparentTo(parent)
     self._accelerateTime = 0
     model = loader.loadModel('models/effects/particleMaps')
     self.card = model.find('**/particleBlackSmoke')
     if not BlackSmoke.particleDummy:
         BlackSmoke.particleDummy = base.effectsRoot.attachNewNode(
             ModelNode('BlackSmokeParticleDummy'))
         BlackSmoke.particleDummy.setDepthWrite(0)
         BlackSmoke.particleDummy.setColorScaleOff()
         BlackSmoke.particleDummy.setLightOff()
     self.duration = 10.0
     self.f = ParticleEffect.ParticleEffect('BlackSmoke')
     self.f.reparentTo(self)
     self.p0 = Particles.Particles('particles-1')
     self.p0.setFactory('ZSpinParticleFactory')
     self.p0.setRenderer('SpriteParticleRenderer')
     self.p0.setEmitter('DiscEmitter')
     self.f.addParticles(self.p0)
     self.p0.setPoolSize(32)
     self.p0.setBirthRate(0.25)
     self.p0.setLitterSize(2)
     self.p0.setLitterSpread(0)
     self.p0.setSystemLifespan(0.0)
     self.p0.setLocalVelocityFlag(1)
     self.p0.setSystemGrowsOlderFlag(0)
     self.p0.setFloorZ(-5.0)
     self.p0.factory.setLifespanBase(2.5)
     self.p0.factory.setLifespanSpread(1.5)
     self.p0.factory.setMassBase(1.0)
     self.p0.factory.setMassSpread(0.2)
     self.p0.factory.setTerminalVelocityBase(400.0)
     self.p0.factory.setTerminalVelocitySpread(0.0)
     self.p0.factory.setInitialAngle(0.0)
     self.p0.factory.setInitialAngleSpread(30.0)
     self.p0.factory.enableAngularVelocity(0)
     self.p0.factory.setAngularVelocity(0.0)
     self.p0.factory.setAngularVelocitySpread(0.0)
     self.p0.renderer.setAlphaMode(BaseParticleRenderer.PRALPHAOUT)
     self.p0.renderer.setUserAlpha(0.8)
     self.p0.renderer.setFromNode(self.card)
     self.p0.renderer.setColor(Vec4(1.0, 1.0, 1.0, 1.0))
     self.p0.renderer.setXScaleFlag(1)
     self.p0.renderer.setYScaleFlag(1)
     self.p0.renderer.setAnimAngleFlag(1)
     self.p0.renderer.setInitialXScale(0.13 * self.cardScale)
     self.p0.renderer.setInitialYScale(0.13 * self.cardScale)
     self.p0.renderer.setFinalXScale(0.4 * self.cardScale)
     self.p0.renderer.setFinalYScale(0.4 * self.cardScale)
     self.p0.renderer.setNonanimatedTheta(0.0)
     self.p0.renderer.setAlphaBlendMethod(BaseParticleRenderer.PPNOBLEND)
     self.p0.renderer.setAlphaDisable(0)
     self.p0.emitter.setEmissionType(BaseParticleEmitter.ETCUSTOM)
     self.p0.emitter.setAmplitude(3.0)
     self.p0.emitter.setAmplitudeSpread(1.5)
     self.p0.emitter.setOffsetForce(Vec3(2.0, 2.0, 25.0))
     self.p0.emitter.setExplicitLaunchVector(Vec3(1.0, 0.0, 0.0))
     self.p0.emitter.setRadiateOrigin(Point3(0.0, 0.0, 1.0))
     self.p0.emitter.setRadius(4.0)
     return
 def destroy(self):
     EffectController.destroy(self)
     PooledEffect.destroy(self)
Example #57
0
 def cleanUpEffect(self):
     EffectController.cleanUpEffect(self)
Example #58
0
 def cleanUpEffect(self):
     EffectController.cleanUpEffect(self)
     self.checkInEffect(self)
    def __init__(self, newParent=None):
        NodePath.__init__(self, 'TorchFire')
        EffectController.__init__(self)
        if newParent:
            self.reparentTo(newParent)

        model = loader.loadModel('models/effects/particleMaps')
        self.card = model.find('**/particleFlame')
        if not TorchFire.particleDummy:
            TorchFire.particleDummy = base.effectsRoot.attachNewNode(
                ModelNode('TorchFireParticleDummy'))
            TorchFire.particleDummy.setDepthWrite(0)
            TorchFire.particleDummy.setFogOff()
            TorchFire.particleDummy.setLightOff()
            TorchFire.particleDummy.setColorScaleOff()
            TorchFire.particleDummy.setBin('fixed', 60)
            TorchFire.particleDummy.setAttrib(
                ColorBlendAttrib.make(ColorBlendAttrib.MAdd,
                                      ColorBlendAttrib.OIncomingAlpha,
                                      ColorBlendAttrib.OOne))

        self.f = ParticleEffect.ParticleEffect('TorchFire')
        self.f.reparentTo(self)
        self.f.setPos(0, 0, 0.75)
        self.p0 = Particles.Particles('particles-1')
        self.p0.setFactory('PointParticleFactory')
        self.p0.setRenderer('SpriteParticleRenderer')
        self.p0.setEmitter('DiscEmitter')
        self.f.addParticles(self.p0)
        self.p0.setPoolSize(8)
        self.p0.setBirthRate(0.10000000000000001)
        self.p0.setLitterSize(1)
        self.p0.setLitterSpread(0)
        self.p0.setSystemLifespan(0.0)
        self.p0.setLocalVelocityFlag(1)
        self.p0.setSystemGrowsOlderFlag(0)
        self.p0.factory.setLifespanBase(0.5)
        self.p0.factory.setLifespanSpread(0.050000000000000003)
        self.p0.factory.setMassBase(1.0)
        self.p0.factory.setMassSpread(0.5)
        self.p0.factory.setTerminalVelocityBase(400.0)
        self.p0.factory.setTerminalVelocitySpread(0.0)
        self.p0.renderer.setAlphaMode(BaseParticleRenderer.PRALPHAOUT)
        self.p0.renderer.setUserAlpha(1.0)
        self.p0.renderer.setFromNode(self.card)
        self.p0.renderer.setColor(Vec4(1.0, 1.0, 1.0, 1.0))
        self.p0.renderer.setXScaleFlag(1)
        self.p0.renderer.setYScaleFlag(1)
        self.p0.renderer.setAnimAngleFlag(0)
        self.p0.renderer.setInitialXScale(0.014 * self.cardScale)
        self.p0.renderer.setFinalXScale(0.002 * self.cardScale)
        self.p0.renderer.setInitialYScale(0.024 * self.cardScale)
        self.p0.renderer.setFinalYScale(0.002 * self.cardScale)
        self.p0.renderer.setNonanimatedTheta(0.0)
        self.p0.renderer.setAlphaBlendMethod(BaseParticleRenderer.PPNOBLEND)
        self.p0.renderer.setAlphaDisable(0)
        self.p0.emitter.setEmissionType(BaseParticleEmitter.ETRADIATE)
        self.p0.emitter.setAmplitude(0.14999999999999999)
        self.p0.emitter.setAmplitudeSpread(0.29999999999999999)
        self.p0.emitter.setOffsetForce(Vec3(0.0, 0.0, 3.0))
        self.p0.emitter.setExplicitLaunchVector(Vec3(1.0, 0.0, 0.0))
        self.p0.emitter.setRadiateOrigin(Point3(0.0, 0.0, 0.0))
        self.p0.emitter.setRadius(0.20000000000000001)