コード例 #1
0
ファイル: CCParticle.cs プロジェクト: chengcong/cocos2d-xna
 public void copy(CCParticle particleCopied)
 {
     this.pos.x                  = particleCopied.pos.x;
     this.pos.y                  = particleCopied.pos.y;
     this.startPos.x             = particleCopied.startPos.x;
     this.startPos.y             = particleCopied.startPos.y;
     this.color.r                = particleCopied.color.r;
     this.color.g                = particleCopied.color.g;
     this.color.b                = particleCopied.color.b;
     this.color.a                = particleCopied.color.a;
     this.deltaColor.r           = particleCopied.deltaColor.r;
     this.deltaColor.g           = particleCopied.deltaColor.g;
     this.deltaColor.b           = particleCopied.deltaColor.b;
     this.deltaColor.a           = particleCopied.deltaColor.a;
     this.size                   = particleCopied.size;
     this.deltaSize              = particleCopied.deltaSize;
     this.rotation               = particleCopied.rotation;
     this.deltaRotation          = particleCopied.deltaRotation;
     this.timeToLive             = particleCopied.timeToLive;
     this.modeA.dir.x            = particleCopied.modeA.dir.x;
     this.modeA.dir.y            = particleCopied.modeA.dir.y;
     this.modeA.radialAccel      = particleCopied.modeA.radialAccel;
     this.modeA.tangentialAccel  = particleCopied.modeA.tangentialAccel;
     this.modeB.angle            = particleCopied.modeB.angle;
     this.modeB.degreesPerSecond = particleCopied.modeB.degreesPerSecond;
     this.modeB.radius           = particleCopied.modeB.radius;
     this.modeB.deltaRadius      = particleCopied.modeB.deltaRadius;
 }
コード例 #2
0
        public override void draw()
        {
            base.draw();
            BlendState blendState = CCApplication.sharedApplication().GraphicsDevice.BlendState;
            BlendState alphaBlend = BlendState.AlphaBlend;

            if (base.IsBlendAdditive)
            {
                alphaBlend = BlendState.Additive;
            }
            CCApplication.sharedApplication().spriteBatch.Begin(SpriteSortMode.Deferred, alphaBlend);
            for (int i = 0; i < base.ParticleCount; i++)
            {
                CCParticle particle = base.m_pParticles[i];
                CCPoint    obPoint  = CCPointExtension.ccpAdd(CCAffineTransform.CCPointApplyAffineTransform(new CCPoint(), base.nodeToWorldTransform()), new CCPoint(this.m_pQuads[i].bl.vertices.x, this.m_pQuads[i].bl.vertices.y));
                obPoint = CCDirector.sharedDirector().convertToUI(obPoint);
                Vector2 position = new Vector2(obPoint.x, obPoint.y);
                Color   color    = new Color(particle.color.r, particle.color.g, particle.color.b, particle.color.a);
                float   scale    = 1f;
                if (this.Texture.getTexture2D().Width > this.Texture.getTexture2D().Height)
                {
                    scale = particle.size / ((float)this.Texture.getTexture2D().Height);
                }
                else
                {
                    scale = particle.size / ((float)this.Texture.getTexture2D().Width);
                }
                float     rotation        = particle.rotation;
                Vector2   origin          = new Vector2((float)(this.Texture.getTexture2D().Width / 2), (float)(this.Texture.getTexture2D().Height / 2));
                Rectangle?sourceRectangle = null;
                CCApplication.sharedApplication().spriteBatch.Draw(this.Texture.getTexture2D(), position, sourceRectangle, color, rotation, origin, scale, SpriteEffects.None, 0f);
            }
            CCApplication.sharedApplication().spriteBatch.End();
            CCApplication.sharedApplication().GraphicsDevice.BlendState = blendState;
        }
コード例 #3
0
        public override void updateQuadWithParticle(CCParticle particle, CCPoint newPosition)
        {
            this.m_pVertices[base.m_uParticleIdx].pos  = ccTypes.vertex2(newPosition.x, newPosition.y);
            this.m_pVertices[base.m_uParticleIdx].size = particle.size;
            ccColor4B colorb = new ccColor4B((byte)(particle.color.r * 255f), (byte)(particle.color.g * 255f), (byte)(particle.color.b * 255f), (byte)(particle.color.a * 255f));

            this.m_pVertices[base.m_uParticleIdx].color = colorb;
        }
コード例 #4
0
        public override void updateQuadWithParticle(CCParticle particle, CCPoint newPosition)
        {
            // place vertices and colos in array
            m_pVertices[m_uParticleIdx].pos  = ccTypes.vertex2(newPosition.x, newPosition.y);
            m_pVertices[m_uParticleIdx].size = particle.size;
            ccColor4B color = new ccColor4B((Byte)(particle.color.r * 255), (Byte)(particle.color.g * 255), (Byte)(particle.color.b * 255),
                                            (Byte)(particle.color.a * 255));

            m_pVertices[m_uParticleIdx].color = color;
        }
コード例 #5
0
        public bool addParticle()
        {
            if (this.isFull())
            {
                return(false);
            }
            CCParticle particle = this.m_pParticles[this.m_uParticleCount];

            this.initParticle(particle);
            this.m_uParticleCount++;
            return(true);
        }
コード例 #6
0
 public void resetSystem()
 {
     this.m_bIsActive    = true;
     this.m_fElapsed     = 0f;
     this.m_uParticleIdx = 0;
     while (this.m_uParticleIdx < this.m_uParticleCount)
     {
         CCParticle particle = this.m_pParticles[this.m_uParticleIdx];
         particle.timeToLive = 0f;
         this.m_uParticleIdx++;
     }
 }
コード例 #7
0
        public override void updateQuadWithParticle(CCParticle particle, CCPoint newPosition)
        {
            ccV2F_C4B_T2F_Quad quad   = this.m_pQuads[base.m_uParticleIdx];
            ccColor4B          colorb = new ccColor4B((byte)(particle.color.r * 255f), (byte)(particle.color.g * 255f), (byte)(particle.color.b * 255f), (byte)(particle.color.a * 255f));

            quad.bl.colors = colorb;
            quad.br.colors = colorb;
            quad.tl.colors = colorb;
            quad.tr.colors = colorb;
            float num = particle.size / 2f;

            if (particle.rotation != 0f)
            {
                float num2  = -num;
                float num3  = -num;
                float num4  = num;
                float num5  = num;
                float x     = newPosition.x;
                float y     = newPosition.y;
                float num8  = -ccMacros.CC_DEGREES_TO_RADIANS(particle.rotation);
                float num9  = (float)Math.Cos((double)num8);
                float num10 = (float)Math.Sin((double)num8);
                float num11 = ((num2 * num9) - (num3 * num10)) + x;
                float num12 = ((num2 * num10) + (num3 * num9)) + y;
                float num13 = ((num4 * num9) - (num3 * num10)) + x;
                float num14 = ((num4 * num10) + (num3 * num9)) + y;
                float num15 = ((num4 * num9) - (num5 * num10)) + x;
                float num16 = ((num4 * num10) + (num5 * num9)) + y;
                float num17 = ((num2 * num9) - (num5 * num10)) + x;
                float num18 = ((num2 * num10) + (num5 * num9)) + y;
                quad.bl.vertices.x = num11;
                quad.bl.vertices.y = num12;
                quad.br.vertices.x = num13;
                quad.br.vertices.y = num14;
                quad.tl.vertices.x = num17;
                quad.tl.vertices.y = num18;
                quad.tr.vertices.x = num15;
                quad.tr.vertices.y = num16;
            }
            else
            {
                quad.bl.vertices.x = newPosition.x - num;
                quad.bl.vertices.y = newPosition.y - num;
                quad.br.vertices.x = newPosition.x + num;
                quad.br.vertices.y = newPosition.y - num;
                quad.tl.vertices.x = newPosition.x - num;
                quad.tl.vertices.y = newPosition.y + num;
                quad.tr.vertices.x = newPosition.x + num;
                quad.tr.vertices.y = newPosition.y + num;
            }
        }
コード例 #8
0
 //! should be overriden by subclasses
 public virtual void updateQuadWithParticle(CCParticle particle, CCPoint newPosition)
 {
     // should be overriden
 }
コード例 #9
0
        public void copy(CCParticle particleCopied)
        {
            pos.x = particleCopied.pos.x;
            pos.y = particleCopied.pos.y;

            startPos.x = particleCopied.startPos.x;
            startPos.y = particleCopied.startPos.y;

            color.r = particleCopied.color.r;
            color.g = particleCopied.color.g;
            color.b = particleCopied.color.b;
            color.a = particleCopied.color.a;

            deltaColor.r = particleCopied.deltaColor.r;
            deltaColor.g = particleCopied.deltaColor.g;
            deltaColor.b = particleCopied.deltaColor.b;
            deltaColor.a = particleCopied.deltaColor.a;

            size = particleCopied.size;
            deltaSize = particleCopied.deltaSize;

            rotation = particleCopied.rotation;
            deltaRotation = particleCopied.deltaRotation;

            timeToLive = particleCopied.timeToLive;

            // modeA
            modeA.dir.x = particleCopied.modeA.dir.x;
            modeA.dir.y = particleCopied.modeA.dir.y;
            modeA.radialAccel = particleCopied.modeA.radialAccel;
            modeA.tangentialAccel = particleCopied.modeA.tangentialAccel;

            // mocdB
            modeB.angle = particleCopied.modeB.angle;
            modeB.degreesPerSecond = particleCopied.modeB.degreesPerSecond;
            modeB.radius = particleCopied.modeB.radius;
            modeB.deltaRadius = particleCopied.modeB.deltaRadius;
        }
コード例 #10
0
        //! Initializes a system with a fixed number of particles
        public virtual bool initWithTotalParticles(uint numberOfParticles)
        {
            m_uTotalParticles = numberOfParticles;

            m_pParticles = new CCParticle[m_uTotalParticles];

            if (null == m_pParticles)
            {
                Debug.WriteLine("Particle system: not enough memory");
                return false;
            }

            for (int i = 0; i < m_uTotalParticles; i++)
            {
                m_pParticles[i] = new CCParticle();
            }

            // default, active
            m_bIsActive = true;

            // default blend function
            m_tBlendFunc.src = 1;// CC_BLEND_SRC;
            m_tBlendFunc.dst = 0x0303;// CC_BLEND_DST;

            // default movement type;
            m_ePositionType = eParticlePositionType.kCCPositionTypeFree;

            // by default be in mode A:
            m_nEmitterMode = (int)eParticleMode.kCCParticleModeGravity;

            // default: modulate
            // XXX: not used
            //	colorModulate = YES;

            m_bIsAutoRemoveOnFinish = false;

            // profiling
            #if CC_ENABLE_PROFILERS
            /// @todo _profilingTimer = [[CCProfiler timerWithName:@"particle system" andInstance:self] retain];
            #endif

            // Optimization: compile udpateParticle method
            //updateParticleSel = @selector(updateQuadWithParticle:newPosition:);
            //updateParticleImp = (CC_UPDATE_PARTICLE_IMP) [self methodForSelector:updateParticleSel];

            // udpate after action in run!
            this.scheduleUpdateWithPriority(1);

            return true;
        }
コード例 #11
0
 public override void updateQuadWithParticle(CCParticle particle, CCPoint newPosition)
 {
     // place vertices and colos in array
     m_pVertices[m_uParticleIdx].pos = ccTypes.vertex2(newPosition.x, newPosition.y);
     m_pVertices[m_uParticleIdx].size = particle.size;
     ccColor4B color = new ccColor4B((Byte)(particle.color.r * 255), (Byte)(particle.color.g * 255), (Byte)(particle.color.b * 255),
     (Byte)(particle.color.a * 255));
     m_pVertices[m_uParticleIdx].color = color;
 }
コード例 #12
0
        public override void draw()
        {
            base.draw();

            BlendState oldBlendState = Application.SharedApplication.GraphicsDevice.BlendState;

            BlendState eBlendState = BlendState.AlphaBlend;

            if (this.IsBlendAdditive)
            {
                eBlendState = BlendState.Additive;
            }

            Application.SharedApplication.SpriteBatch.Begin(SpriteSortMode.Deferred, eBlendState);
            for (int i = 0; i < this.ParticleCount; i++)
            {
                CCParticle particle = m_pParticles[i];

                CCPoint uiPoint = CCAffineTransform.CCPointApplyAffineTransform(new CCPoint(), this.nodeToWorldTransform());
                uiPoint = CCPointExtension.ccpAdd(uiPoint, new CCPoint(m_pQuads[i].bl.vertices.x, m_pQuads[i].bl.vertices.y));
                uiPoint = Director.SharedDirector.ConvertToUI(uiPoint);

                Vector2 vecPosition = new Vector2(uiPoint.X, uiPoint.Y);

                Color color = new Color(particle.color.r,
                                        particle.color.g,
                                        particle.color.b,
                                        particle.color.a);

                float scale = 1.0f;
                if (Texture.Texture2D.Width > Texture.Texture2D.Height)
                {
                    scale = particle.size / Texture.Texture2D.Height;
                }
                else
                {
                    scale = particle.size / Texture.Texture2D.Width;
                }

                float rotation = particle.rotation;

                Vector2 origin = new Vector2(Texture.Texture2D.Width / 2, Texture.Texture2D.Height / 2);
                Application.SharedApplication.SpriteBatch.Draw(this.Texture.Texture2D, vecPosition, null, color, rotation, origin, scale, SpriteEffects.None, 0);


                //CCPoint uiPoint = CCAffineTransform.CCPointApplyAffineTransform(new CCPoint(), this.nodeToWorldTransform());
                //uiPoint.x += m_pQuads[i].bl.vertices.x;
                //uiPoint.y += m_pQuads[i].bl.vertices.y;
                //uiPoint = CCDirector.sharedDirector().convertToUI(uiPoint);
                //Vector2 vecPosition = new Vector2(uiPoint.x, uiPoint.y);

                //Color color = new Color(m_pQuads[i].bl.colors.r,
                //                        m_pQuads[i].bl.colors.g,
                //                        m_pQuads[i].bl.colors.b,
                //                        m_pQuads[i].bl.colors.a);

                //Vector2 origin = new Vector2(Texture.Texture2D.Width/2, Texture.Texture2D.Height/2);
                //Application.SharedApplication.SpriteBatch.Draw(this.Texture.Texture2D, vecPosition, null, color, 0, origin, 1.0f, SpriteEffects.None, 0);
            }
            Application.SharedApplication.SpriteBatch.End();

            Application.SharedApplication.GraphicsDevice.BlendState = oldBlendState;

            //    // Default GL states: GL_TEXTURE_2D, GL_VERTEX_ARRAY, GL_COLOR_ARRAY, GL_TEXTURE_COORD_ARRAY
            //    // Needed states: GL_TEXTURE_2D, GL_VERTEX_ARRAY, GL_COLOR_ARRAY, GL_TEXTURE_COORD_ARRAY
            //    // Unneeded states: -
            //    glBindTexture(GL_TEXTURE_2D, m_pTexture->getName());

            //    #define kQuadSize sizeof(m_pQuads[0].bl)


            //    int offset = (int) m_pQuads;

            //    // vertex
            //    int diff = offsetof( ccV2F_C4B_T2F, vertices);
            //    glVertexPointer(2,GL_FLOAT, kQuadSize, (GLvoid*) (offset+diff) );

            //    // color
            //    diff = offsetof( ccV2F_C4B_T2F, colors);
            //    glColorPointer(4, GL_UNSIGNED_BYTE, kQuadSize, (GLvoid*)(offset + diff));

            //    // tex coords
            //    diff = offsetof( ccV2F_C4B_T2F, texCoords);
            //    glTexCoordPointer(2, GL_FLOAT, kQuadSize, (GLvoid*)(offset + diff));


            //    bool newBlend = (m_tBlendFunc.src != CC_BLEND_SRC || m_tBlendFunc.dst != CC_BLEND_DST) ? true : false;
            //    if( newBlend )
            //    {
            //        glBlendFunc( m_tBlendFunc.src, m_tBlendFunc.dst );
            //    }

            //    CCAssert( m_uParticleIdx == m_uParticleCount, "Abnormal error in particle quad");

            //    glDrawElements(GL_TRIANGLES, (GLsizei)(m_uParticleIdx*6), GL_UNSIGNED_SHORT, m_pIndices);

            //    // restore blend state
            //    if( newBlend )
            //        glBlendFunc( CC_BLEND_SRC, CC_BLEND_DST );

            //#if CC_USES_VBO
            //    glBindBuffer(GL_ARRAY_BUFFER, 0);
            //#endif
        }
コード例 #13
0
        public override void updateQuadWithParticle(CCParticle particle, CCPoint newPosition)
        {
            // colors
            ccV2F_C4B_T2F_Quad quad = m_pQuads[m_uParticleIdx];

            ccColor4B color = new ccColor4B((Byte)(particle.color.r * 255), (Byte)(particle.color.g * 255), (Byte)(particle.color.b * 255),
                                            (Byte)(particle.color.a * 255));

            quad.bl.colors = color;
            quad.br.colors = color;
            quad.tl.colors = color;
            quad.tr.colors = color;

            // vertices
            float size_2 = particle.size / 2;

            if (particle.rotation != 0)
            {
                float x1 = -size_2;
                float y1 = -size_2;

                float x2 = size_2;
                float y2 = size_2;
                float x  = newPosition.X;
                float y  = newPosition.Y;

                float r  = -CCUtils.CC_DEGREES_TO_RADIANS(particle.rotation);
                float cr = (float)System.Math.Cos(r);
                float sr = (float)System.Math.Sin(r);
                float ax = x1 * cr - y1 * sr + x;
                float ay = x1 * sr + y1 * cr + y;
                float bx = x2 * cr - y1 * sr + x;
                float by = x2 * sr + y1 * cr + y;
                float cx = x2 * cr - y2 * sr + x;
                float cy = x2 * sr + y2 * cr + y;
                float dx = x1 * cr - y2 * sr + x;
                float dy = x1 * sr + y2 * cr + y;

                // bottom-left
                quad.bl.vertices.x = ax;
                quad.bl.vertices.y = ay;

                // bottom-right vertex:
                quad.br.vertices.x = bx;
                quad.br.vertices.y = by;

                // top-left vertex:
                quad.tl.vertices.x = dx;
                quad.tl.vertices.y = dy;

                // top-right vertex:
                quad.tr.vertices.x = cx;
                quad.tr.vertices.y = cy;
            }
            else
            {
                // bottom-left vertex:
                quad.bl.vertices.x = newPosition.X - size_2;
                quad.bl.vertices.y = newPosition.Y - size_2;

                // bottom-right vertex:
                quad.br.vertices.x = newPosition.X + size_2;
                quad.br.vertices.y = newPosition.Y - size_2;

                // top-left vertex:
                quad.tl.vertices.x = newPosition.X - size_2;
                quad.tl.vertices.y = newPosition.Y + size_2;

                // top-right vertex:
                quad.tr.vertices.x = newPosition.X + size_2;
                quad.tr.vertices.y = newPosition.Y + size_2;
            }
        }
コード例 #14
0
        private void UpdateQuad(ref CCV3F_C4B_T2F_Quad quad, ref CCParticle particle)
        {
            CCPoint newPosition;

            if (m_ePositionType == CCPositionType.kCCPositionTypeFree || m_ePositionType == CCPositionType.kCCPositionTypeRelative)
            {
                newPosition.X = particle.pos.X - (s_currentPosition.X - particle.startPos.X);
                newPosition.Y = particle.pos.Y - (s_currentPosition.Y - particle.startPos.Y);
            }
            else
            {
                newPosition = particle.pos;
            }

            // translate newPos to correct position, since matrix transform isn't performed in batchnode
            // don't update the particle with the new position information, it will interfere with the radius and tangential calculations
            if (m_pBatchNode != null)
            {
                newPosition.X += m_tPosition.X;
                newPosition.Y += m_tPosition.Y;
            }

            CCColor4B color;

            if  (m_bOpacityModifyRGB)
            {
                color.R = (byte) (particle.color.R * particle.color.A * 255);
                color.G = (byte) (particle.color.G * particle.color.A * 255);
                color.B = (byte) (particle.color.B * particle.color.A * 255);
                color.A = (byte)(particle.color.A * 255);
            }
            else
            {
                color.R = (byte)(particle.color.R * 255);
                color.G = (byte)(particle.color.G * 255);
                color.B = (byte)(particle.color.B * 255);
                color.A = (byte)(particle.color.A * 255);
            }

            quad.BottomLeft.Colors = color;
            quad.BottomRight.Colors = color;
            quad.TopLeft.Colors = color;
            quad.TopRight.Colors = color;

            // vertices
            float size_2 = particle.size / 2;
            if (particle.rotation != 0.0)
            {
                float x1 = -size_2;
                float y1 = -size_2;

                float x2 = size_2;
                float y2 = size_2;
                float x = newPosition.X;
                float y = newPosition.Y;

                float r = -MathHelper.ToRadians(particle.rotation);
                float cr = MHelper.Cos(r);
                float sr = MHelper.Sin(r);
                float ax = x1 * cr - y1 * sr + x;
                float ay = x1 * sr + y1 * cr + y;
                float bx = x2 * cr - y1 * sr + x;
                float by = x2 * sr + y1 * cr + y;
                float cx = x2 * cr - y2 * sr + x;
                float cy = x2 * sr + y2 * cr + y;
                float dx = x1 * cr - y2 * sr + x;
                float dy = x1 * sr + y2 * cr + y;

                // bottom-left
                quad.BottomLeft.Vertices.X = ax;
                quad.BottomLeft.Vertices.Y = ay;

                // bottom-right vertex:
                quad.BottomRight.Vertices.X = bx;
                quad.BottomRight.Vertices.Y = by;

                // top-left vertex:
                quad.TopLeft.Vertices.X = dx;
                quad.TopLeft.Vertices.Y = dy;

                // top-right vertex:
                quad.TopRight.Vertices.X = cx;
                quad.TopRight.Vertices.Y = cy;
            }
            else
            {
                // bottom-left vertex:
                quad.BottomLeft.Vertices.X = newPosition.X - size_2;
                quad.BottomLeft.Vertices.Y = newPosition.Y - size_2;

                // bottom-right vertex:
                quad.BottomRight.Vertices.X = newPosition.X + size_2;
                quad.BottomRight.Vertices.Y = newPosition.Y - size_2;

                // top-left vertex:
                quad.TopLeft.Vertices.X = newPosition.X - size_2;
                quad.TopLeft.Vertices.Y = newPosition.Y + size_2;

                // top-right vertex:
                quad.TopRight.Vertices.X = newPosition.X + size_2;
                quad.TopRight.Vertices.Y = newPosition.Y + size_2;
            }
        }
コード例 #15
0
        private bool UpdateParticle(ref CCParticle p, float dt)
        {
            // life
            p.timeToLive -= dt;

            if (p.timeToLive > 0)
            {
                // Mode A: gravity, direction, tangential accel & radial accel
                if (m_nEmitterMode == CCEmitterMode.kCCParticleModeGravity)
                {
                    float radial_x = 0;
                    float radial_y = 0;

                    float tmp_x, tmp_y;
                    float tangential_x, tangential_y;

                    float x = p.pos.X;
                    float y = p.pos.Y;

                    if (x != 0 || y != 0)
                    {
                        float l = 1.0f / (float) Math.Sqrt(x * x + y * y);

                        radial_x = x * l;
                        radial_y = y * l;
                    }
                    tangential_x = radial_x;
                    tangential_y = radial_y;

                    //radial = CCPointExtension.ccpMult(radial, p.modeA.radialAccel);
                    radial_x *= p.modeA.radialAccel;
                    radial_y *= p.modeA.radialAccel;

                    // tangential acceleration
                    float newy = tangential_x;
                    tangential_x = -tangential_y;
                    tangential_y = newy;
                    //tangential = CCPointExtension.ccpMult(tangential, p.modeA.tangentialAccel);
                    tangential_x *= p.modeA.tangentialAccel;
                    tangential_y *= p.modeA.tangentialAccel;

                    // (gravity + radial + tangential) * dt
                    //tmp = CCPointExtension.ccpAdd(CCPointExtension.ccpAdd(radial, tangential), modeA.gravity);
                    //tmp = CCPointExtension.ccpMult(tmp, dt);
                    //p.modeA.dir = CCPointExtension.ccpAdd(p.modeA.dir, tmp);
                    //tmp = CCPointExtension.ccpMult(p.modeA.dir, dt);
                    //p.pos = CCPointExtension.ccpAdd(p.pos, tmp);

                    tmp_x = (radial_x + tangential_x + modeA.gravity.X) * dt;
                    tmp_y = (radial_y + tangential_y + modeA.gravity.Y) * dt;

                    p.modeA.dir.X += tmp_x;
                    p.modeA.dir.Y += tmp_y;

                    p.pos.X += p.modeA.dir.X * dt;
                    p.pos.Y += p.modeA.dir.Y * dt;
                }

                    // Mode B: radius movement
                else
                {
                    // Update the angle and radius of the particle.
                    p.modeB.angle += p.modeB.degreesPerSecond * dt;
                    p.modeB.radius += p.modeB.deltaRadius * dt;

                    p.pos.X = -MHelper.Cos(p.modeB.angle) * p.modeB.radius;
                    p.pos.Y = -MHelper.Sin(p.modeB.angle) * p.modeB.radius;
                }

                // color
                p.color.R += (p.deltaColor.R * dt);
                p.color.G += (p.deltaColor.G * dt);
                p.color.B += (p.deltaColor.B * dt);
                p.color.A += (p.deltaColor.A * dt);

                // size
                p.size += (p.deltaSize * dt);
                if (p.size < 0)
                {
                    p.size = 0;
                }

                // angle
                p.rotation += (p.deltaRotation * dt);

                return true;
            }
            return false;
        }
コード例 #16
0
        //! Initializes a particle
        public void initParticle(CCParticle particle)
        {
            Debug.Assert(null != particle, "particle shouldn't be null.");

            // timeToLive
            // no negative life. prevent division by 0
            particle.timeToLive = m_fLife + m_fLifeVar * ccMacros.CCRANDOM_MINUS1_1();
            particle.timeToLive = (((0) > (particle.timeToLive)) ? (0) : (particle.timeToLive));

            // position
            particle.pos.x = m_tSourcePosition.x + m_tPosVar.x * ccMacros.CCRANDOM_MINUS1_1();
            particle.pos.x *= CCDirector.sharedDirector().ContentScaleFactor;
            particle.pos.y = m_tSourcePosition.y + m_tPosVar.y * ccMacros.CCRANDOM_MINUS1_1();
            particle.pos.y *= CCDirector.sharedDirector().ContentScaleFactor;

            // Color
            ccColor4F start = new ccColor4F();
            start.r = CCPointExtension.clampf(m_tStartColor.r + m_tStartColorVar.r * ccMacros.CCRANDOM_MINUS1_1(), 0, 1);
            start.g = CCPointExtension.clampf(m_tStartColor.g + m_tStartColorVar.g * ccMacros.CCRANDOM_MINUS1_1(), 0, 1);
            start.b = CCPointExtension.clampf(m_tStartColor.b + m_tStartColorVar.b * ccMacros.CCRANDOM_MINUS1_1(), 0, 1);
            start.a = CCPointExtension.clampf(m_tStartColor.a + m_tStartColorVar.a * ccMacros.CCRANDOM_MINUS1_1(), 0, 1);

            ccColor4F end = new ccColor4F();
            end.r = CCPointExtension.clampf(m_tEndColor.r + m_tEndColorVar.r * ccMacros.CCRANDOM_MINUS1_1(), 0, 1);
            end.g = CCPointExtension.clampf(m_tEndColor.g + m_tEndColorVar.g * ccMacros.CCRANDOM_MINUS1_1(), 0, 1);
            end.b = CCPointExtension.clampf(m_tEndColor.b + m_tEndColorVar.b * ccMacros.CCRANDOM_MINUS1_1(), 0, 1);
            end.a = CCPointExtension.clampf(m_tEndColor.a + m_tEndColorVar.a * ccMacros.CCRANDOM_MINUS1_1(), 0, 1);

            particle.color = start;
            particle.deltaColor.r = (end.r - start.r) / particle.timeToLive;
            particle.deltaColor.g = (end.g - start.g) / particle.timeToLive;
            particle.deltaColor.b = (end.b - start.b) / particle.timeToLive;
            particle.deltaColor.a = (end.a - start.a) / particle.timeToLive;

            // size
            float startS = m_fStartSize + m_fStartSizeVar * ccMacros.CCRANDOM_MINUS1_1();
            startS = (((0) > (startS)) ? (0) : (startS)); // No negative value
            startS *= CCDirector.sharedDirector().ContentScaleFactor;

            particle.size = startS;

            if( m_fEndSize == (float)eParticleShowingProperty.kCCParticleStartSizeEqualToEndSize )
            {
                particle.deltaSize = 0;
            }
            else
            {
                float endS = m_fEndSize + m_fEndSizeVar * ccMacros.CCRANDOM_MINUS1_1();
                endS = (((0) > (endS)) ? (0) : (endS)); // No negative values
                endS *= CCDirector.sharedDirector().ContentScaleFactor;
                particle.deltaSize = (endS - startS) / particle.timeToLive;
            }

            // rotation
            float startA = m_fStartSpin + m_fStartSpinVar * ccMacros.CCRANDOM_MINUS1_1();
            float endA = m_fEndSpin + m_fEndSpinVar * ccMacros.CCRANDOM_MINUS1_1();
            particle.rotation = startA;
            particle.deltaRotation = (endA - startA) / particle.timeToLive;

            // position
            if( m_ePositionType == eParticlePositionType.kCCPositionTypeFree )
            {
                CCPoint p = this.convertToWorldSpace(new CCPoint(0,0));
                particle.startPos = CCPointExtension.ccpMult( p, CCDirector.sharedDirector().ContentScaleFactor );
            }
            else if ( m_ePositionType == eParticlePositionType.kCCPositionTypeRelative )
            {
                particle.startPos = CCPointExtension.ccpMult( m_tPosition, CCDirector.sharedDirector().ContentScaleFactor );
            }

            // direction
            float a = ccMacros.CC_DEGREES_TO_RADIANS(m_fAngle + m_fAngleVar * ccMacros.CCRANDOM_MINUS1_1());

            // Mode Gravity: A
            if( m_nEmitterMode == (int)eParticleMode.kCCParticleModeGravity )
            {
                CCPoint v = new CCPoint( (float)System.Math.Cos( a ), (float)System.Math.Sin( a ));
                float s = modeA.speed + modeA.speedVar * ccMacros.CCRANDOM_MINUS1_1();
                s *= CCDirector.sharedDirector().ContentScaleFactor;

                // direction
                particle.modeA.dir = CCPointExtension.ccpMult( v, s );

                // radial accel
                particle.modeA.radialAccel = modeA.radialAccel + modeA.radialAccelVar * ccMacros.CCRANDOM_MINUS1_1();
                particle.modeA.radialAccel *= CCDirector.sharedDirector().ContentScaleFactor;

                // tangential accel
                particle.modeA.tangentialAccel = modeA.tangentialAccel + modeA.tangentialAccelVar * ccMacros.CCRANDOM_MINUS1_1();
                particle.modeA.tangentialAccel *= CCDirector.sharedDirector().ContentScaleFactor;
            }

            // Mode Radius: B
            else {
                // Set the default diameter of the particle from the source position
                float startRadius = modeB.startRadius + modeB.startRadiusVar * ccMacros.CCRANDOM_MINUS1_1();
                float endRadius = modeB.endRadius + modeB.endRadiusVar * ccMacros.CCRANDOM_MINUS1_1();
                startRadius *= CCDirector.sharedDirector().ContentScaleFactor;
                endRadius *= CCDirector.sharedDirector().ContentScaleFactor;

                particle.modeB.radius = startRadius;

                if( modeB.endRadius == (float)eParticleShowingProperty.kCCParticleStartRadiusEqualToEndRadius )
                    particle.modeB.deltaRadius = 0;
                else
                    particle.modeB.deltaRadius = (endRadius - startRadius) / particle.timeToLive;

                particle.modeB.angle = a;
                particle.modeB.degreesPerSecond = ccMacros.CC_DEGREES_TO_RADIANS(modeB.rotatePerSecond + modeB.rotatePerSecondVar * ccMacros.CCRANDOM_MINUS1_1());
            }
        }
コード例 #17
0
 public virtual void updateQuadWithParticle(CCParticle particle, CCPoint newPosition)
 {
 }
コード例 #18
0
        public override void update(float dt)
        {
            if (this.m_bIsActive && (this.m_fEmissionRate != 0f))
            {
                float num = 1f / this.m_fEmissionRate;
                this.m_fEmitCounter += dt;
                while ((this.m_uParticleCount < this.m_uTotalParticles) && (this.m_fEmitCounter > num))
                {
                    this.addParticle();
                    this.m_fEmitCounter -= num;
                }
                this.m_fElapsed += dt;
                if ((this.m_fDuration != -1f) && (this.m_fDuration < this.m_fElapsed))
                {
                    this.stopSystem();
                }
            }
            this.m_uParticleIdx = 0;
            CCPoint tPosition = new CCPoint(0f, 0f);

            if (this.m_ePositionType == eParticlePositionType.kCCPositionTypeFree)
            {
                tPosition    = base.convertToWorldSpace(new CCPoint(0f, 0f));
                tPosition.x *= CCDirector.sharedDirector().ContentScaleFactor;
                tPosition.y *= CCDirector.sharedDirector().ContentScaleFactor;
            }
            else if (this.m_ePositionType == eParticlePositionType.kCCPositionTypeRelative)
            {
                tPosition    = base.m_tPosition;
                tPosition.x *= CCDirector.sharedDirector().ContentScaleFactor;
                tPosition.y *= CCDirector.sharedDirector().ContentScaleFactor;
            }
            while (this.m_uParticleIdx < this.m_uParticleCount)
            {
                CCParticle particle = this.m_pParticles[this.m_uParticleIdx];
                particle.timeToLive -= dt;
                if (particle.timeToLive > 0f)
                {
                    CCPoint pos;
                    if (this.m_nEmitterMode == 0)
                    {
                        CCPoint v = new CCPoint(0f, 0f);
                        if ((particle.pos.x != 0f) || (particle.pos.y != 0f))
                        {
                            v = CCPointExtension.ccpNormalize(particle.pos);
                        }
                        CCPoint point4 = v;
                        v = CCPointExtension.ccpMult(v, particle.modeA.radialAccel);
                        float x = point4.x;
                        point4.x = -point4.y;
                        point4.y = x;
                        point4   = CCPointExtension.ccpMult(point4, particle.modeA.tangentialAccel);
                        CCPoint point2 = CCPointExtension.ccpMult(CCPointExtension.ccpAdd(CCPointExtension.ccpAdd(v, point4), this.modeA.gravity), dt);
                        particle.modeA.dir = CCPointExtension.ccpAdd(particle.modeA.dir, point2);
                        point2             = CCPointExtension.ccpMult(particle.modeA.dir, dt);
                        particle.pos       = CCPointExtension.ccpAdd(particle.pos, point2);
                    }
                    else
                    {
                        particle.modeB.angle  += particle.modeB.degreesPerSecond * dt;
                        particle.modeB.radius += particle.modeB.deltaRadius * dt;
                        particle.pos.x         = -((float)Math.Cos((double)particle.modeB.angle)) * particle.modeB.radius;
                        particle.pos.y         = -((float)Math.Sin((double)particle.modeB.angle)) * particle.modeB.radius;
                    }
                    particle.color.r  += particle.deltaColor.r * dt;
                    particle.color.g  += particle.deltaColor.g * dt;
                    particle.color.b  += particle.deltaColor.b * dt;
                    particle.color.a  += particle.deltaColor.a * dt;
                    particle.size     += particle.deltaSize * dt;
                    particle.size      = (0f > particle.size) ? 0f : particle.size;
                    particle.rotation += particle.deltaRotation * dt;
                    if ((this.m_ePositionType == eParticlePositionType.kCCPositionTypeFree) || (this.m_ePositionType == eParticlePositionType.kCCPositionTypeRelative))
                    {
                        CCPoint point6 = CCPointExtension.ccpSub(tPosition, particle.startPos);
                        pos = CCPointExtension.ccpSub(particle.pos, point6);
                    }
                    else
                    {
                        pos = particle.pos;
                    }
                    this.updateQuadWithParticle(particle, pos);
                    this.m_uParticleIdx++;
                }
                else
                {
                    if (this.m_uParticleIdx != (this.m_uParticleCount - 1))
                    {
                        this.m_pParticles[this.m_uParticleIdx].copy(this.m_pParticles[(int)((IntPtr)(this.m_uParticleCount - 1))]);
                    }
                    this.m_uParticleCount--;
                    if ((this.m_uParticleCount == 0) && this.m_bIsAutoRemoveOnFinish)
                    {
                        base.unscheduleUpdate();
                        base.m_pParent.removeChild(this, true);
                        return;
                    }
                }
            }
            this.postStep();
        }
コード例 #19
0
        public void initParticle(CCParticle particle)
        {
            particle.timeToLive = this.m_fLife + (this.m_fLifeVar * ccMacros.CCRANDOM_MINUS1_1());
            particle.timeToLive = (0f > particle.timeToLive) ? 0f : particle.timeToLive;
            particle.pos.x      = this.m_tSourcePosition.x + (this.m_tPosVar.x * ccMacros.CCRANDOM_MINUS1_1());
            particle.pos.x     *= CCDirector.sharedDirector().ContentScaleFactor;
            particle.pos.y      = this.m_tSourcePosition.y + (this.m_tPosVar.y * ccMacros.CCRANDOM_MINUS1_1());
            particle.pos.y     *= CCDirector.sharedDirector().ContentScaleFactor;
            ccColor4F colorf = new ccColor4F
            {
                r = CCPointExtension.clampf(this.m_tStartColor.r + (this.m_tStartColorVar.r * ccMacros.CCRANDOM_MINUS1_1()), 0f, 1f),
                g = CCPointExtension.clampf(this.m_tStartColor.g + (this.m_tStartColorVar.g * ccMacros.CCRANDOM_MINUS1_1()), 0f, 1f),
                b = CCPointExtension.clampf(this.m_tStartColor.b + (this.m_tStartColorVar.b * ccMacros.CCRANDOM_MINUS1_1()), 0f, 1f),
                a = CCPointExtension.clampf(this.m_tStartColor.a + (this.m_tStartColorVar.a * ccMacros.CCRANDOM_MINUS1_1()), 0f, 1f)
            };
            ccColor4F colorf2 = new ccColor4F
            {
                r = CCPointExtension.clampf(this.m_tEndColor.r + (this.m_tEndColorVar.r * ccMacros.CCRANDOM_MINUS1_1()), 0f, 1f),
                g = CCPointExtension.clampf(this.m_tEndColor.g + (this.m_tEndColorVar.g * ccMacros.CCRANDOM_MINUS1_1()), 0f, 1f),
                b = CCPointExtension.clampf(this.m_tEndColor.b + (this.m_tEndColorVar.b * ccMacros.CCRANDOM_MINUS1_1()), 0f, 1f),
                a = CCPointExtension.clampf(this.m_tEndColor.a + (this.m_tEndColorVar.a * ccMacros.CCRANDOM_MINUS1_1()), 0f, 1f)
            };

            particle.color        = colorf;
            particle.deltaColor.r = (colorf2.r - colorf.r) / particle.timeToLive;
            particle.deltaColor.g = (colorf2.g - colorf.g) / particle.timeToLive;
            particle.deltaColor.b = (colorf2.b - colorf.b) / particle.timeToLive;
            particle.deltaColor.a = (colorf2.a - colorf.a) / particle.timeToLive;
            float num = this.m_fStartSize + (this.m_fStartSizeVar * ccMacros.CCRANDOM_MINUS1_1());

            num           = (0f > num) ? 0f : num;
            num          *= CCDirector.sharedDirector().ContentScaleFactor;
            particle.size = num;
            if (this.m_fEndSize == -1f)
            {
                particle.deltaSize = 0f;
            }
            else
            {
                float num2 = this.m_fEndSize + (this.m_fEndSizeVar * ccMacros.CCRANDOM_MINUS1_1());
                num2  = (0f > num2) ? 0f : num2;
                num2 *= CCDirector.sharedDirector().ContentScaleFactor;
                particle.deltaSize = (num2 - num) / particle.timeToLive;
            }
            float num3 = this.m_fStartSpin + (this.m_fStartSpinVar * ccMacros.CCRANDOM_MINUS1_1());
            float num4 = this.m_fEndSpin + (this.m_fEndSpinVar * ccMacros.CCRANDOM_MINUS1_1());

            particle.rotation      = num3;
            particle.deltaRotation = (num4 - num3) / particle.timeToLive;
            if (this.m_ePositionType == eParticlePositionType.kCCPositionTypeFree)
            {
                CCPoint v = base.convertToWorldSpace(new CCPoint(0f, 0f));
                particle.startPos = CCPointExtension.ccpMult(v, CCDirector.sharedDirector().ContentScaleFactor);
            }
            else if (this.m_ePositionType == eParticlePositionType.kCCPositionTypeRelative)
            {
                particle.startPos = CCPointExtension.ccpMult(base.m_tPosition, CCDirector.sharedDirector().ContentScaleFactor);
            }
            float num5 = ccMacros.CC_DEGREES_TO_RADIANS(this.m_fAngle + (this.m_fAngleVar * ccMacros.CCRANDOM_MINUS1_1()));

            if (this.m_nEmitterMode == 0)
            {
                CCPoint point2 = new CCPoint((float)Math.Cos((double)num5), (float)Math.Sin((double)num5));
                float   s      = this.modeA.speed + (this.modeA.speedVar * ccMacros.CCRANDOM_MINUS1_1());
                s *= CCDirector.sharedDirector().ContentScaleFactor;
                particle.modeA.dir              = CCPointExtension.ccpMult(point2, s);
                particle.modeA.radialAccel      = this.modeA.radialAccel + (this.modeA.radialAccelVar * ccMacros.CCRANDOM_MINUS1_1());
                particle.modeA.radialAccel     *= CCDirector.sharedDirector().ContentScaleFactor;
                particle.modeA.tangentialAccel  = this.modeA.tangentialAccel + (this.modeA.tangentialAccelVar * ccMacros.CCRANDOM_MINUS1_1());
                particle.modeA.tangentialAccel *= CCDirector.sharedDirector().ContentScaleFactor;
            }
            else
            {
                float num7 = this.modeB.startRadius + (this.modeB.startRadiusVar * ccMacros.CCRANDOM_MINUS1_1());
                float num8 = this.modeB.endRadius + (this.modeB.endRadiusVar * ccMacros.CCRANDOM_MINUS1_1());
                num7 *= CCDirector.sharedDirector().ContentScaleFactor;
                num8 *= CCDirector.sharedDirector().ContentScaleFactor;
                particle.modeB.radius = num7;
                if (this.modeB.endRadius == -1f)
                {
                    particle.modeB.deltaRadius = 0f;
                }
                else
                {
                    particle.modeB.deltaRadius = (num8 - num7) / particle.timeToLive;
                }
                particle.modeB.angle            = num5;
                particle.modeB.degreesPerSecond = ccMacros.CC_DEGREES_TO_RADIANS(this.modeB.rotatePerSecond + (this.modeB.rotatePerSecondVar * ccMacros.CCRANDOM_MINUS1_1()));
            }
        }
コード例 #20
0
        public override void updateQuadWithParticle(CCParticle particle, CCPoint newPosition)
        {
            // colors
            ccV2F_C4B_T2F_Quad quad = m_pQuads[m_uParticleIdx];

            ccColor4B color = new ccColor4B( (Byte)(particle.color.r * 255), (Byte)(particle.color.g * 255), (Byte)(particle.color.b * 255), 
		(Byte)(particle.color.a * 255));
            quad.bl.colors = color;
            quad.br.colors = color;
            quad.tl.colors = color;
            quad.tr.colors = color;

            // vertices
            float size_2 = particle.size / 2;
            if (particle.rotation != 0)
            {
                float x1 = -size_2;
                float y1 = -size_2;

                float x2 = size_2;
                float y2 = size_2;
                float x = newPosition.x;
                float y = newPosition.y;

                float r = - ccMacros.CC_DEGREES_TO_RADIANS(particle.rotation); 
                float cr = (float)System.Math.Cos(r);
                float sr = (float)System.Math.Sin(r);
                float ax = x1 * cr - y1 * sr + x;
                float ay = x1 * sr + y1 * cr + y;
                float bx = x2 * cr - y1 * sr + x;
                float by = x2 * sr + y1 * cr + y;
                float cx = x2 * cr - y2 * sr + x;
                float cy = x2 * sr + y2 * cr + y;
                float dx = x1 * cr - y2 * sr + x;
                float dy = x1 * sr + y2 * cr + y;

                // bottom-left
                quad.bl.vertices.x = ax;
                quad.bl.vertices.y = ay;

                // bottom-right vertex:
                quad.br.vertices.x = bx;
                quad.br.vertices.y = by;

                // top-left vertex:
                quad.tl.vertices.x = dx;
                quad.tl.vertices.y = dy;

                // top-right vertex:
                quad.tr.vertices.x = cx;
                quad.tr.vertices.y = cy;
            }
            else
            {
                // bottom-left vertex:
                quad.bl.vertices.x = newPosition.x - size_2;
                quad.bl.vertices.y = newPosition.y - size_2;

                // bottom-right vertex:
                quad.br.vertices.x = newPosition.x + size_2;
                quad.br.vertices.y = newPosition.y - size_2;

                // top-left vertex:
                quad.tl.vertices.x = newPosition.x - size_2;
                quad.tl.vertices.y = newPosition.y + size_2;

                // top-right vertex:
                quad.tr.vertices.x = newPosition.x + size_2;
                quad.tr.vertices.y = newPosition.y + size_2;
            }
        }
コード例 #21
0
        private void InitParticle(ref CCParticle particle)
        {
            // timeToLive
            // no negative life. prevent division by 0
            particle.timeToLive = Math.Max(0, m_fLife + m_fLifeVar * Random.Float_Minus1_1());

            // position
            particle.pos.X = m_tSourcePosition.X + m_tPosVar.X * Random.Float_Minus1_1();
            particle.pos.Y = m_tSourcePosition.Y + m_tPosVar.Y * Random.Float_Minus1_1();

            // Color
            CCColor4F start;
            start.R = MathHelper.Clamp(m_tStartColor.R + m_tStartColorVar.R * Random.Float_Minus1_1(), 0, 1);
            start.G = MathHelper.Clamp(m_tStartColor.G + m_tStartColorVar.G * Random.Float_Minus1_1(), 0, 1);
            start.B = MathHelper.Clamp(m_tStartColor.B + m_tStartColorVar.B * Random.Float_Minus1_1(), 0, 1);
            start.A = MathHelper.Clamp(m_tStartColor.A + m_tStartColorVar.A * Random.Float_Minus1_1(), 0, 1);

            CCColor4F end;
            end.R = MathHelper.Clamp(m_tEndColor.R + m_tEndColorVar.R * Random.Float_Minus1_1(), 0, 1);
            end.G = MathHelper.Clamp(m_tEndColor.G + m_tEndColorVar.G * Random.Float_Minus1_1(), 0, 1);
            end.B = MathHelper.Clamp(m_tEndColor.B + m_tEndColorVar.B * Random.Float_Minus1_1(), 0, 1);
            end.A = MathHelper.Clamp(m_tEndColor.A + m_tEndColorVar.A * Random.Float_Minus1_1(), 0, 1);

            particle.color = start;
            particle.deltaColor.R = (end.R - start.R) / particle.timeToLive;
            particle.deltaColor.G = (end.G - start.G) / particle.timeToLive;
            particle.deltaColor.B = (end.B - start.B) / particle.timeToLive;
            particle.deltaColor.A = (end.A - start.A) / particle.timeToLive;

            // size
            float startS = m_fStartSize + m_fStartSizeVar * Random.Float_Minus1_1();
            startS = Math.Max(0, startS); // No negative value

            particle.size = startS;

            if (m_fEndSize == kCCParticleStartSizeEqualToEndSize)
            {
                particle.deltaSize = 0;
            }
            else
            {
                float endS = m_fEndSize + m_fEndSizeVar * Random.Float_Minus1_1();
                endS = Math.Max(0, endS); // No negative values
                particle.deltaSize = (endS - startS) / particle.timeToLive;
            }

            // rotation
            float startA = m_fStartSpin + m_fStartSpinVar * Random.Float_Minus1_1();
            float endA = m_fEndSpin + m_fEndSpinVar * Random.Float_Minus1_1();
            particle.rotation = startA;
            particle.deltaRotation = (endA - startA) / particle.timeToLive;

            // position
            if (m_ePositionType == CCPositionType.kCCPositionTypeFree)
            {
                particle.startPos = ConvertToWorldSpace(CCPoint.Zero);
            }
            else if (m_ePositionType == CCPositionType.kCCPositionTypeRelative)
            {
                particle.startPos = m_tPosition;
            }

            // direction
            float a = MathHelper.ToRadians(m_fAngle + m_fAngleVar * Random.Float_Minus1_1());

            // Mode Gravity: A
            if (m_nEmitterMode == CCEmitterMode.kCCParticleModeGravity)
            {
                var v = new CCPoint(MHelper.Cos(a), MHelper.Sin(a));

                float s = modeA.speed + modeA.speedVar * Random.Float_Minus1_1();

                // direction
                particle.modeA.dir = CCPointExtension.Multiply(v, s);

                // radial accel
                particle.modeA.radialAccel = modeA.radialAccel + modeA.radialAccelVar * Random.Float_Minus1_1();

                // tangential accel
                particle.modeA.tangentialAccel = modeA.tangentialAccel + modeA.tangentialAccelVar * Random.Float_Minus1_1();
            }

                // Mode Radius: B
            else
            {
                // Set the default diameter of the particle from the source position
                float startRadius = modeB.startRadius + modeB.startRadiusVar * Random.Float_Minus1_1();
                float endRadius = modeB.endRadius + modeB.endRadiusVar * Random.Float_Minus1_1();

                particle.modeB.radius = startRadius;

                if (modeB.endRadius == kCCParticleStartRadiusEqualToEndRadius)
                {
                    particle.modeB.deltaRadius = 0;
                }
                else
                {
                    particle.modeB.deltaRadius = (endRadius - startRadius) / particle.timeToLive;
                }

                particle.modeB.angle = a;
                particle.modeB.degreesPerSecond =
                    MathHelper.ToRadians(modeB.rotatePerSecond + modeB.rotatePerSecondVar * Random.Float_Minus1_1());
            }
        }