Exemplo n.º 1
0
        public override void OnEnter()
        {
            base.OnEnter();

            CCActionInterval effect = (CCSequence.FromActions(new CCDelayTime (2.0f), new CCShaky3D(16, false, new CCGridSize(5, 5), 5.0f)));

            // cleanup
            CCNode bg = GetChildByTag(EffectAdvanceScene.kTagBackground);
            RemoveChild(bg, true);

            // background
            CCLayerColor layer = new CCLayerColor(new CCColor4B(255, 0, 0, 255));
            AddChild(layer, -10);
            CCSprite sprite = new CCSprite("Images/grossini");
            sprite.Position = new CCPoint(50, 80);
            layer.AddChild(sprite, 10);

            // foreground
            CCLayerColor layer2 = new CCLayerColor(new CCColor4B(0, 255, 0, 255));
            CCSprite fog = new CCSprite("Images/Fog");

            var bf = new CCBlendFunc {Source = CCOGLES.GL_SRC_ALPHA, Destination = CCOGLES.GL_ONE_MINUS_SRC_ALPHA};
            fog.BlendFunc = bf;
            layer2.AddChild(fog, 1);
            AddChild(layer2, 1);

            layer2.RunAction(new CCRepeatForever (effect));
        }
Exemplo n.º 2
0
        protected virtual bool InitWithFade(float fade, float minSeg, float stroke, CCColor3B color, CCTexture2D texture)
        {
            Position    = CCPoint.Zero;
            AnchorPoint = CCPoint.Zero;
            IgnoreAnchorPointForPosition   = true;
            m_bStartingPositionInitialized = false;

            m_tPositionR = CCPoint.Zero;
            m_bFastMode  = true;
            m_fMinSeg    = (minSeg == -1.0f) ? stroke / 5.0f : minSeg;
            m_fMinSeg   *= m_fMinSeg;

            m_fStroke    = stroke;
            m_fFadeDelta = 1.0f / fade;

            m_uMaxPoints     = (int)(fade * 60.0f) + 2;
            m_uNuPoints      = 0;
            m_pPointState    = new float[m_uMaxPoints];
            m_pPointVertexes = new CCPoint[m_uMaxPoints];

            m_pVertices = new CCV3F_C4B_T2F[(m_uMaxPoints + 1) * 2];

            // Set blend mode
            m_tBlendFunc = CCBlendFunc.NonPremultiplied;

            Texture = texture;
            Color   = color;
            ScheduleUpdate();

            return(true);
        }
Exemplo n.º 3
0
 private void UpdateBlendFunc()
 {
     if (!m_pobTextureAtlas.Texture.HasPremultipliedAlpha)
     {
         m_blendFunc = CCBlendFunc.NonPremultiplied;
     }
 }
Exemplo n.º 4
0
        public override bool Init()
        {
            base.Init();

            m_sBlendFunc = CCBlendFunc.AlphaBlend;
            m_pVertices  = new CCRawList <VertexPositionColor>(512);

            return(true);
        }
Exemplo n.º 5
0
        //protected bool m_opacityChanged;

        public CCLayerColor()
        {
            m_cOpacity = 0;
            m_tColor   = new CCColor3B(0, 0, 0);

            // default blend function
            m_tBlendFunc = new CCBlendFunc(CCMacros.CCDefaultSourceBlending, CCMacros.CCDefaultDestinationBlending);
            Init();
        }
Exemplo n.º 6
0
        public override bool Init()
        {
            base.Init();

            m_sBlendFunc = CCBlendFunc.AlphaBlend;
            m_pVertices = new CCRawList<VertexPositionColor>(512);

            return true;
        }
Exemplo n.º 7
0
        //protected bool m_opacityChanged;

        public CCLayerColor()
        {
            m_cOpacity = 0;
            m_tColor = new CCColor3B(0, 0, 0);

            // default blend function
            m_tBlendFunc = new CCBlendFunc(CCMacros.CCDefaultSourceBlending, CCMacros.CCDefaultDestinationBlending);
            Init ();

        }
Exemplo n.º 8
0
        /*
         * init with CCTexture2D
         */

        public bool InitWithTexture(CCTexture2D tex, int capacity)
        {
            TextureAtlas.InitWithTexture(tex, capacity);

            // no lazy alloc in this node
            m_pChildren = new CCRawList <CCNode>(capacity);

            m_tBlendFunc = CCBlendFunc.AlphaBlend;

            return(true);
        }
Exemplo n.º 9
0
        /*
         * init with CCTexture2D
         */

        public bool InitWithTexture(CCTexture2D tex, int capacity)
        {
            TextureAtlas.InitWithTexture(tex, capacity);

            // no lazy alloc in this node
            m_pChildren = new CCRawList<CCNode>(capacity);

            m_tBlendFunc = CCBlendFunc.AlphaBlend;

            return true;
        }
Exemplo n.º 10
0
        public static void BlendFunc(CCBlendFunc blendFunc)
        {
            // It looks like the blend state is being reset somewhere so this check of not setting
            // the blend states is causing multiple problems.  Took this check out and setting the
            // blend state seems the correct modification for now.
            //if (m_currBlend.Destination != blendFunc.Destination || m_currBlend.Source != blendFunc.Source)
            //{
            BlendState bs = null;

            if (blendFunc.Source == OGLES.GL_ONE && blendFunc.Destination == OGLES.GL_ONE_MINUS_SRC_ALPHA)
            {
                bs = BlendState.AlphaBlend;
            }
            else if (blendFunc.Source == OGLES.GL_SRC_ALPHA && blendFunc.Destination == OGLES.GL_ONE)
            {
                bs = BlendState.Additive;
            }
            else if (blendFunc.Source == OGLES.GL_SRC_ALPHA && blendFunc.Destination == OGLES.GL_ONE_MINUS_SRC_ALPHA)
            {
                bs = BlendState.NonPremultiplied;
            }
            else if (blendFunc.Source == OGLES.GL_ONE && blendFunc.Destination == OGLES.GL_ZERO)
            {
                bs = BlendState.Opaque;
            }
            else
            {
                if (!m_blendStates.TryGetValue(blendFunc, out bs))
                {
                    bs = new BlendState();

                    bs.ColorSourceBlend      = OGLES.GetXNABlend(blendFunc.Source);
                    bs.AlphaSourceBlend      = OGLES.GetXNABlend(blendFunc.Source);
                    bs.ColorDestinationBlend = OGLES.GetXNABlend(blendFunc.Destination);
                    bs.AlphaDestinationBlend = OGLES.GetXNABlend(blendFunc.Destination);

                    m_blendStates.Add(blendFunc, bs);
                }
            }

            graphicsDevice.BlendState = bs;

            m_currBlend.Source      = blendFunc.Source;
            m_currBlend.Destination = blendFunc.Destination;

            //}
        }
Exemplo n.º 11
0
        public bool InitWithTexture(CCTexture2D pTexture, CCRect rect, bool rotated)
        {
            base.Init();

            m_pobBatchNode = null;

            // shader program
            //setShaderProgram(CCShaderCache::sharedShaderCache()->programForKey(kCCShader_PositionTextureColor));

            m_bRecursiveDirty = false;
            Dirty             = false;

            m_bOpacityModifyRGB = true;
            m_sBlendFunc        = CCBlendFunc.AlphaBlend;

            m_bFlipX = m_bFlipY = false;

            // default transform anchor: center
            AnchorPoint = new CCPoint(0.5f, 0.5f);

            // zwoptex default values
            m_obOffsetPosition = CCPoint.Zero;

            m_bHasChildren = false;

            // clean the Quad
            m_sQuad = new CCV3F_C4B_T2F_Quad();

            // Atlas: Color
            var tmpColor = new CCColor4B(255, 255, 255, 255);

            m_sQuad.BottomLeft.Colors  = tmpColor;
            m_sQuad.BottomRight.Colors = tmpColor;
            m_sQuad.TopLeft.Colors     = tmpColor;
            m_sQuad.TopRight.Colors    = tmpColor;

            // update texture (calls updateBlendFunc)
            Texture = pTexture;
            SetTextureRect(rect, rotated, rect.Size);

            // by default use "Self Render".
            // if the sprite is added to a batchnode, then it will automatically switch to "batchnode Render"
            BatchNode = null;

            return(true);
        }
Exemplo n.º 12
0
        protected void UpdateBlendFunc()
        {
            Debug.Assert(m_pobBatchNode == null,
                         "CCSprite: updateBlendFunc doesn't work when the sprite is rendered using a CCSpriteSheet");

            // it's possible to have an untextured sprite
            if (m_pobTexture == null || !m_pobTexture.HasPremultipliedAlpha)
            {
                m_sBlendFunc       = CCBlendFunc.NonPremultiplied;
                IsOpacityModifyRGB = false;
            }
            else
            {
                m_sBlendFunc       = CCBlendFunc.AlphaBlend;
                IsOpacityModifyRGB = true;
            }
        }
Exemplo n.º 13
0
        public RenderTextureSave()
        {
            CCSize s = CCDirector.SharedDirector.WinSize;

            // create a render texture, this is what we are going to draw into
            m_pTarget = new CCRenderTexture((int) s.Width, (int) s.Height, SurfaceFormat.Color, DepthFormat.None, RenderTargetUsage.PreserveContents);

			// Let's clear the rendertarget here so that we start off fresh.
			// Some platforms do not seem to be initializing the rendertarget color so this will make sure the background shows up colored instead of 
			// what looks like non initialized.  Mostly MacOSX for now.
			m_pTarget.Clear(0,0,0,255);

            m_pTarget.Position = new CCPoint(s.Width / 2, s.Height / 2);

            // It's possible to modify the RenderTexture blending function by
            //CCBlendFunc tbf = new CCBlendFunc (OGLES.GL_ONE, OGLES.GL_ONE_MINUS_SRC_ALPHA);
            //m_pTarget.Sprite.BlendFunc = tbf;

            // note that the render texture is a CCNode, and contains a sprite of its texture for convience,
            // so we can just parent it to the scene like any other CCNode
            AddChild(m_pTarget, -1);

            // create a brush image to draw into the texture with
            m_pBrush = new CCSprite("Images/fire");
            // It's possible to modify the Brushes blending function by
            CCBlendFunc bbf = new CCBlendFunc (CCOGLES.GL_ONE, CCOGLES.GL_ONE_MINUS_SRC_ALPHA);
            m_pBrush.BlendFunc = bbf;

            m_pBrush.Color = new CCColor3B (Color.Red);
            m_pBrush.Opacity = 20;
            TouchEnabled = true;

            // Save Image menu
            CCMenuItemFont.FontSize = 16;
            CCMenuItem item1 = new CCMenuItemFont("Save Image", saveImage);
            CCMenuItem item2 = new CCMenuItemFont("Clear", clearImage);
            var menu = new CCMenu(item1, item2);
            AddChild(menu);
            menu.AlignItemsVertically();
            menu.Position = new CCPoint(s.Width - 80, s.Height - 30);
        }
        public virtual bool InitWithTotalParticles(int numberOfParticles)
        {
            m_uTotalParticles = numberOfParticles;

            m_pParticles = new CCParticle[m_uTotalParticles];

            m_uAllocatedParticles = numberOfParticles;

            if (m_pBatchNode != null)
            {
                for (int i = 0; i < m_uTotalParticles; i++)
                {
                    m_pParticles[i].atlasIndex = i;
                }
            }
            // default, active
            m_bIsActive = true;

            // default blend function
            m_tBlendFunc = CCBlendFunc.AlphaBlend;

            // default movement type;
            m_ePositionType = CCPositionType.Free;

            // by default be in mode A:
            m_nEmitterMode = CCEmitterMode.Gravity;

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

            m_bIsAutoRemoveOnFinish = false;

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

            return(true);
        }
Exemplo n.º 15
0
        protected virtual bool InitWithTexture(CCTexture2D tex, int capacity)
        {
            m_blendFunc = CCBlendFunc.AlphaBlend;

            m_pobTextureAtlas = new CCTextureAtlas();

            if (capacity == 0)
            {
                capacity = kDefaultSpriteBatchCapacity;
            }

            ContentSize = tex.ContentSize; // @@ TotallyEvil - contentSize should return the size of the sprite sheet
            m_pobTextureAtlas.InitWithTexture(tex, capacity);

            UpdateBlendFunc();

            // no lazy alloc in this node
            m_pChildren      = new CCRawList <CCNode>(capacity);
            m_pobDescendants = new CCRawList <CCSprite>(capacity);

            return(true);
        }
Exemplo n.º 16
0
        public bool InitWithTexture(CCTexture2D texture, int tileWidth, int tileHeight, int itemsToRender)
        {
            m_uItemWidth  = tileWidth;
            m_uItemHeight = tileHeight;

            m_tColorUnmodified    = CCTypes.CCWhite;
            m_bIsOpacityModifyRGB = true;

            m_tBlendFunc = CCBlendFunc.AlphaBlend;

            m_pTextureAtlas = new CCTextureAtlas();
            m_pTextureAtlas.InitWithTexture(texture, itemsToRender);

            UpdateBlendFunc();
            UpdateOpacityModifyRgb();

            CalculateMaxItems();

            m_uQuadsToDraw = itemsToRender;

            return(true);
        }
Exemplo n.º 17
0
        // override addChild:
        public override void AddChild(CCNode child, int zOrder, int tag)
        {
            Debug.Assert(child != null, "Argument must be non-null");
            Debug.Assert(child is CCParticleSystem, "CCParticleBatchNode only supports CCQuadParticleSystems as children");
            var pChild = (CCParticleSystem)child;

            Debug.Assert(pChild.Texture.Name == TextureAtlas.Texture.Name, "CCParticleSystem is not using the same texture id");

            // If this is the 1st children, then copy blending function
            if (m_pChildren.Count == 0)
            {
                BlendFunc = pChild.BlendFunc;
            }

            Debug.Assert(m_tBlendFunc.Source == pChild.BlendFunc.Source && m_tBlendFunc.Destination == pChild.BlendFunc.Destination,
                         "Can't add a PaticleSystem that uses a differnt blending function");

            //no lazy sorting, so don't call super addChild, call helper instead
            int pos = AddChildHelper(pChild, zOrder, tag);

            //get new atlasIndex
            int atlasIndex;

            if (pos != 0)
            {
                var p = (CCParticleSystem)m_pChildren[pos - 1];
                atlasIndex = p.AtlasIndex + p.TotalParticles;
            }
            else
            {
                atlasIndex = 0;
            }

            InsertChild(pChild, atlasIndex);

            // update quad info
            pChild.BatchNode = this;
        }
        private void updateBlendFunc()
        {
            Debug.Assert(m_pBatchNode == null, "Can't change blending functions when the particle is being batched");

            if (m_pTexture != null)
            {
                bool premultiplied = m_pTexture.HasPremultipliedAlpha;

                m_bOpacityModifyRGB = false;

                if (m_tBlendFunc == CCBlendFunc.AlphaBlend)
                {
                    if (premultiplied)
                    {
                        m_bOpacityModifyRGB = true;
                    }
                    else
                    {
                        m_tBlendFunc = CCBlendFunc.NonPremultiplied;
                    }
                }
            }
        }
Exemplo n.º 19
0
        protected virtual bool InitWithTexture(CCTexture2D tex, int capacity)
        {
            m_blendFunc = CCBlendFunc.AlphaBlend;

            m_pobTextureAtlas = new CCTextureAtlas();

            if (capacity == 0)
            {
                capacity = kDefaultSpriteBatchCapacity;
            }

            ContentSize= tex.ContentSize; // @@ TotallyEvil - contentSize should return the size of the sprite sheet
            m_pobTextureAtlas.InitWithTexture(tex, capacity);

            UpdateBlendFunc();

            // no lazy alloc in this node
            m_pChildren = new CCRawList<CCNode>(capacity);

            m_pobDescendants = new CCRawList<CCSprite>(capacity);

            return true;
        }
Exemplo n.º 20
0
        /// <summary>
        /// initializes a CCLayer with color, width and height in Points
        /// </summary>
        public virtual bool InitWithColor(CCColor4B color, float width, float height)
        {
            base.Init();

            // default blend function
            m_tBlendFunc = CCBlendFunc.NonPremultiplied;

            _displayedColor.R = _realColor.R = color.R;
            _displayedColor.G = _realColor.G = color.G;
            _displayedColor.B = _realColor.B = color.B;
            _displayedOpacity = _realOpacity = color.A;

            for (int i = 0; i < m_pSquareVertices.Length; i++)
            {
                m_pSquareVertices[i].Position.X = 0.0f;
                m_pSquareVertices[i].Position.Y = 0.0f;
            }

            UpdateColor();
            ContentSize = new CCSize(width, height);

            return(true);
        }
Exemplo n.º 21
0
 protected virtual void OnHandlePropTypeBlendFunc(CCNode node, CCNode parent, string propertyName, CCBlendFunc blendFunc,
                                                  CCBReader reader)
 {
     CCLog.Log("Unexpected property type: '{0}'!", propertyName);
     Debug.Assert(false);
 }
Exemplo n.º 22
0
        public bool InitWithTexture(CCTexture2D pTexture, CCRect rect, bool rotated)
        {
            base.Init();

            m_pobBatchNode = null;

            // shader program
            //setShaderProgram(CCShaderCache::sharedShaderCache()->programForKey(kCCShader_PositionTextureColor));

            m_bRecursiveDirty = false;
            Dirty = false;

            m_bOpacityModifyRGB = true;
            m_sBlendFunc = CCBlendFunc.AlphaBlend;

            m_bFlipX = m_bFlipY = false;

            // default transform anchor: center
            AnchorPoint = new CCPoint(0.5f, 0.5f);

            // zwoptex default values
            m_obOffsetPosition = CCPoint.Zero;

            m_bHasChildren = false;

            // clean the Quad
            m_sQuad = new CCV3F_C4B_T2F_Quad();

            // Atlas: Color
            var tmpColor = new CCColor4B(255, 255, 255, 255);
            m_sQuad.BottomLeft.Colors = tmpColor;
            m_sQuad.BottomRight.Colors = tmpColor;
            m_sQuad.TopLeft.Colors = tmpColor;
            m_sQuad.TopRight.Colors = tmpColor;

            // update texture (calls updateBlendFunc)
            Texture = pTexture;
            SetTextureRect(rect, rotated, rect.Size);

            // by default use "Self Render".
            // if the sprite is added to a batchnode, then it will automatically switch to "batchnode Render"
            BatchNode = null;

            return true;
        }
Exemplo n.º 23
0
        protected void UpdateBlendFunc()
        {
            Debug.Assert(m_pobBatchNode == null,
                         "CCSprite: updateBlendFunc doesn't work when the sprite is rendered using a CCSpriteSheet");

            // it's possible to have an untextured sprite
            if (m_pobTexture == null || !m_pobTexture.HasPremultipliedAlpha)
            {
                m_sBlendFunc = CCBlendFunc.NonPremultiplied;
                IsOpacityModifyRGB = false;
            }
            else
            {
                m_sBlendFunc = CCBlendFunc.AlphaBlend;
                IsOpacityModifyRGB = true;
            }
        }
Exemplo n.º 24
0
        public virtual void ParseProperties(CCNode node, CCNode parent, CCBReader reader)
        {
            int numRegularProps = reader.ReadInt(false);
            int numExturaProps  = reader.ReadInt(false);
            int propertyCount   = numRegularProps + numExturaProps;

            for (int i = 0; i < propertyCount; i++)
            {
                bool   isExtraProp  = (i >= numRegularProps);
                int    type         = reader.ReadInt(false);
                string propertyName = reader.ReadCachedString();

                // Check if the property can be set for this platform
                bool setProp = false;

                var platform = (CCBPlatform)reader.ReadByte();
                if (platform == CCBPlatform.All)
                {
                    setProp = true;
                }
#if __CC_PLATFORM_IOS
                if (platform == kCCBPlatform.kCCBPlatformIOS)
                {
                    setProp = true;
                }
#elif __CC_PLATFORM_MAC
                if (platform == kCCBPlatform.kCCBPlatformMac)
                {
                    setProp = true;
                }
#endif

                // Forward properties for sub ccb files
                if (node is CCBFile)
                {
                    var ccbNode = (CCBFile)node;
                    if (ccbNode.FileNode != null && isExtraProp)
                    {
                        node = ccbNode.FileNode;

                        // Skip properties that doesn't have a value to override
                        var extraPropsNames = (List <string>)node.UserObject;
                        setProp &= extraPropsNames.Contains(propertyName);
                    }
                }
                else if (isExtraProp && node == reader.AnimationManager.RootNode)
                {
                    var extraPropsNames = (List <string>)node.UserObject;
                    if (extraPropsNames == null)
                    {
                        extraPropsNames = new List <string>();
                        node.UserObject = extraPropsNames;
                    }

                    extraPropsNames.Add(propertyName);
                }

                switch ((CCBPropType)type)
                {
                case CCBPropType.Position:
                {
                    CCPoint position = ParsePropTypePosition(node, parent, reader, propertyName);
                    if (setProp)
                    {
                        OnHandlePropTypePosition(node, parent, propertyName, position, reader);
                    }
                    break;
                }

                case CCBPropType.Point:
                {
                    CCPoint point = ParsePropTypePoint(node, parent, reader);
                    if (setProp)
                    {
                        OnHandlePropTypePoint(node, parent, propertyName, point, reader);
                    }
                    break;
                }

                case CCBPropType.PointLock:
                {
                    CCPoint pointLock = ParsePropTypePointLock(node, parent, reader);
                    if (setProp)
                    {
                        OnHandlePropTypePointLock(node, parent, propertyName, pointLock, reader);
                    }
                    break;
                }

                case CCBPropType.Size:
                {
                    CCSize size = ParsePropTypeSize(node, parent, reader);
                    if (setProp)
                    {
                        OnHandlePropTypeSize(node, parent, propertyName, size, reader);
                    }
                    break;
                }

                case CCBPropType.ScaleLock:
                {
                    float[] scaleLock = ParsePropTypeScaleLock(node, parent, reader, propertyName);
                    if (setProp)
                    {
                        OnHandlePropTypeScaleLock(node, parent, propertyName, scaleLock, reader);
                    }
                    break;
                }

                case CCBPropType.Float:
                {
                    float f = ParsePropTypeFloat(node, parent, reader);
                    if (setProp)
                    {
                        OnHandlePropTypeFloat(node, parent, propertyName, f, reader);
                    }
                    break;
                }

                case CCBPropType.Degrees:
                {
                    float degrees = ParsePropTypeDegrees(node, parent, reader, propertyName);
                    if (setProp)
                    {
                        OnHandlePropTypeDegrees(node, parent, propertyName, degrees, reader);
                    }
                    break;
                }

                case CCBPropType.FloatScale:
                {
                    float floatScale = ParsePropTypeFloatScale(node, parent, reader);
                    if (setProp)
                    {
                        OnHandlePropTypeFloatScale(node, parent, propertyName, floatScale, reader);
                    }
                    break;
                }

                case CCBPropType.Integer:
                {
                    int integer = ParsePropTypeInteger(node, parent, reader);
                    if (setProp)
                    {
                        OnHandlePropTypeInteger(node, parent, propertyName, integer, reader);
                    }
                    break;
                }

                case CCBPropType.IntegerLabeled:
                {
                    int integerLabeled = ParsePropTypeIntegerLabeled(node, parent, reader);
                    if (setProp)
                    {
                        OnHandlePropTypeIntegerLabeled(node, parent, propertyName, integerLabeled, reader);
                    }
                    break;
                }

                case CCBPropType.FloatVar:
                {
                    float[] floatVar = ParsePropTypeFloatVar(node, parent, reader);
                    if (setProp)
                    {
                        OnHandlePropTypeFloatVar(node, parent, propertyName, floatVar, reader);
                    }
                    break;
                }

                case CCBPropType.Check:
                {
                    bool check = ParsePropTypeCheck(node, parent, reader, propertyName);
                    if (setProp)
                    {
                        OnHandlePropTypeCheck(node, parent, propertyName, check, reader);
                    }
                    break;
                }

                case CCBPropType.SpriteFrame:
                {
                    CCSpriteFrame ccSpriteFrame = ParsePropTypeSpriteFrame(node, parent, reader, propertyName);
                    if (setProp)
                    {
                        OnHandlePropTypeSpriteFrame(node, parent, propertyName, ccSpriteFrame, reader);
                    }
                    break;
                }

                case CCBPropType.Animation:
                {
                    CCAnimation ccAnimation = ParsePropTypeAnimation(node, parent, reader);
                    if (setProp)
                    {
                        OnHandlePropTypeAnimation(node, parent, propertyName, ccAnimation, reader);
                    }
                    break;
                }

                case CCBPropType.Texture:
                {
                    CCTexture2D ccTexture2D = ParsePropTypeTexture(node, parent, reader);
                    if (setProp)
                    {
                        OnHandlePropTypeTexture(node, parent, propertyName, ccTexture2D, reader);
                    }
                    break;
                }

                case CCBPropType.Byte:
                {
                    byte b = ParsePropTypeByte(node, parent, reader, propertyName);
                    if (setProp)
                    {
                        OnHandlePropTypeByte(node, parent, propertyName, b, reader);
                    }
                    break;
                }

                case CCBPropType.Color3:
                {
                    CCColor3B color3B = ParsePropTypeColor3(node, parent, reader, propertyName);
                    if (setProp)
                    {
                        OnHandlePropTypeColor3(node, parent, propertyName, color3B, reader);
                    }
                    break;
                }

                case CCBPropType.Color4FVar:
                {
                    CCColor4F[] color4FVar = ParsePropTypeColor4FVar(node, parent, reader);
                    if (setProp)
                    {
                        OnHandlePropTypeColor4FVar(node, parent, propertyName, color4FVar, reader);
                    }
                    break;
                }

                case CCBPropType.Flip:
                {
                    bool[] flip = ParsePropTypeFlip(node, parent, reader);
                    if (setProp)
                    {
                        OnHandlePropTypeFlip(node, parent, propertyName, flip, reader);
                    }
                    break;
                }

                case CCBPropType.Blendmode:
                {
                    CCBlendFunc blendFunc = ParsePropTypeBlendFunc(node, parent, reader);
                    if (setProp)
                    {
                        OnHandlePropTypeBlendFunc(node, parent, propertyName, blendFunc, reader);
                    }
                    break;
                }

                case CCBPropType.FntFile:
                {
                    string fntFile = ParsePropTypeFntFile(node, parent, reader);
                    if (setProp)
                    {
                        OnHandlePropTypeFntFile(node, parent, propertyName, fntFile, reader);
                    }
                    break;
                }

                case CCBPropType.FontTTF:
                {
                    string fontTTF = ParsePropTypeFontTTF(node, parent, reader);
                    if (setProp)
                    {
                        OnHandlePropTypeFontTTF(node, parent, propertyName, fontTTF, reader);
                    }
                    break;
                }

                case CCBPropType.String:
                {
                    string s = ParsePropTypeString(node, parent, reader);
                    if (setProp)
                    {
                        OnHandlePropTypeString(node, parent, propertyName, s, reader);
                    }
                    break;
                }

                case CCBPropType.Text:
                {
                    string text = ParsePropTypeText(node, parent, reader);
                    if (setProp)
                    {
                        OnHandlePropTypeText(node, parent, propertyName, text, reader);
                    }
                    break;
                }

                case CCBPropType.Block:
                {
                    BlockData blockData = ParsePropTypeBlock(node, parent, reader);
                    if (setProp)
                    {
                        OnHandlePropTypeBlock(node, parent, propertyName, blockData, reader);
                    }
                    break;
                }

                case CCBPropType.BlockCCControl:
                {
                    BlockCCControlData blockCCControlData = ParsePropTypeBlockCcControl(node, parent, reader);
                    if (setProp && blockCCControlData != null)
                    {
                        OnHandlePropTypeBlockCcControl(node, parent, propertyName, blockCCControlData, reader);
                    }
                    break;
                }

                case CCBPropType.CCBFile:
                {
                    CCNode ccbFileNode = ParsePropTypeCcbFile(node, parent, reader);
                    if (setProp)
                    {
                        OnHandlePropTypeCCBFile(node, parent, propertyName, ccbFileNode, reader);
                    }
                    break;
                }

                default:
                    //ASSERT_FAIL_UNEXPECTED_PROPERTYTYPE(type);
                    break;
                }
            }
        }
Exemplo n.º 25
0
        public virtual bool InitWithTotalParticles(int numberOfParticles)
        {
            m_uTotalParticles = numberOfParticles;

            m_pParticles = new CCParticle[m_uTotalParticles];

            m_uAllocatedParticles = numberOfParticles;

            if (m_pBatchNode != null)
            {
                for (int i = 0; i < m_uTotalParticles; i++)
                {
                    m_pParticles[i].atlasIndex = i;
                }
            }
            // default, active
            m_bIsActive = true;

            // default blend function
            m_tBlendFunc = CCBlendFunc.AlphaBlend;
                
            // default movement type;
            m_ePositionType = CCPositionType.Free;

            // by default be in mode A:
            m_nEmitterMode = CCEmitterMode.Gravity;

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

            m_bIsAutoRemoveOnFinish = false;

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

            return true;
        }
Exemplo n.º 26
0
        public override void OnEnter()
        {
            base.OnEnter();

            Color = CCTypes.CCBlack;
            RemoveChild(m_background, true);
            m_background = null;

            m_emitter = new CCParticleSystemQuad("Particles/BoilingFoam");

            // Particle Designer "normal" blend func causes black halo on premul textures (ignores multiplication)
            //this->emitter.blendFunc = (ccBlendFunc){ GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA };

            // Cocos2d "normal" blend func for premul causes alpha to be ignored (oversaturates colors)
            var tBlendFunc = new CCBlendFunc(CCOGLES.GL_ONE, CCOGLES.GL_ONE_MINUS_SRC_ALPHA);
            m_emitter.BlendFunc = tBlendFunc;

            //Debug.Assert(m_emitter.OpacityModifyRGB, "Particle texture does not have premultiplied alpha, test is useless");

            // Toggle next line to see old behavior
            //	this->emitter.opacityModifyRGB = NO;

            m_emitter.StartColor = new CCColor4F(1, 1, 1, 1);
            m_emitter.EndColor = new CCColor4F(1, 1, 1, 0);
            m_emitter.StartColorVar = new CCColor4F(0, 0, 0, 0);
            m_emitter.EndColorVar = new CCColor4F(0, 0, 0, 0);

            AddChild(m_emitter, 10);
        }
Exemplo n.º 27
0
        /// <summary>
        /// initializes a CCLayer with color, width and height in Points
        /// </summary>
        public virtual bool InitWithColor(CCColor4B color, float width, float height)
        {
            base.Init();

            // default blend function
            m_tBlendFunc = CCBlendFunc.NonPremultiplied;

            _displayedColor.R = _realColor.R = color.R;
            _displayedColor.G = _realColor.G = color.G;
            _displayedColor.B = _realColor.B = color.B;
            _displayedOpacity = _realOpacity = color.A;

            for (int i = 0; i < m_pSquareVertices.Length; i++)
            {
                m_pSquareVertices[i].Position.X = 0.0f;
                m_pSquareVertices[i].Position.Y = 0.0f;
            }

            UpdateColor();
            ContentSize = new CCSize(width, height);
            
            return true;
        }
Exemplo n.º 28
0
        public bool InitWithTexture(CCTexture2D texture, int tileWidth, int tileHeight, int itemsToRender)
        {
            m_uItemWidth = tileWidth;
            m_uItemHeight = tileHeight;

            m_tColorUnmodified = CCTypes.CCWhite;
            m_bIsOpacityModifyRGB = true;

            m_tBlendFunc = CCBlendFunc.AlphaBlend; 

            m_pTextureAtlas = new CCTextureAtlas();
            m_pTextureAtlas.InitWithTexture(texture, itemsToRender);

            UpdateBlendFunc();
            UpdateOpacityModifyRgb();

            CalculateMaxItems();

            m_uQuadsToDraw = itemsToRender;

            return true;
        }
Exemplo n.º 29
0
        // override addChild:
        public override void AddChild(CCNode child, int zOrder, int tag)
        {
            Debug.Assert(child != null, "Argument must be non-null");
            Debug.Assert(child is CCParticleSystem, "CCParticleBatchNode only supports CCQuadParticleSystems as children");
            var pChild = (CCParticleSystem) child;
            Debug.Assert(pChild.Texture.Name == TextureAtlas.Texture.Name, "CCParticleSystem is not using the same texture id");

            // If this is the 1st children, then copy blending function
            if (m_pChildren.Count == 0)
            {
                BlendFunc = pChild.BlendFunc;
            }

            Debug.Assert(m_tBlendFunc.Source == pChild.BlendFunc.Source && m_tBlendFunc.Destination == pChild.BlendFunc.Destination,
                         "Can't add a PaticleSystem that uses a differnt blending function");

            //no lazy sorting, so don't call super addChild, call helper instead
            int pos = AddChildHelper(pChild, zOrder, tag);

            //get new atlasIndex
            int atlasIndex;

            if (pos != 0)
            {
                var p = (CCParticleSystem) m_pChildren[pos - 1];
                atlasIndex = p.AtlasIndex + p.TotalParticles;
            }
            else
            {
                atlasIndex = 0;
            }

            InsertChild(pChild, atlasIndex, tag);

            // update quad info
            pChild.BatchNode = this;
        }
Exemplo n.º 30
0
 protected virtual void OnHandlePropTypeBlendFunc(CCNode node, CCNode parent, string propertyName, CCBlendFunc blendFunc,
                                                  CCBReader reader)
 {
     CCLog.Log("Unexpected property type: '{0}'!", propertyName);
     Debug.Assert(false);
 }
Exemplo n.º 31
0
        /** Pointers */

        public CCMotionStreak()
        {
            m_tBlendFunc = CCBlendFunc.NonPremultiplied;
        }
Exemplo n.º 32
0
        private void updateBlendFunc()
        {
            Debug.Assert(m_pBatchNode == null, "Can't change blending functions when the particle is being batched");

            if (m_pTexture != null)
            {
                bool premultiplied = m_pTexture.HasPremultipliedAlpha;

                m_bOpacityModifyRGB = false;

                if (m_tBlendFunc == CCBlendFunc.AlphaBlend)
                {
                    if (premultiplied)
                    {
                        m_bOpacityModifyRGB = true;
                    }
                    else
                    {
                        m_tBlendFunc = CCBlendFunc.NonPremultiplied;
                    }
                }
            }
        }
Exemplo n.º 33
0
        /** Pointers */

        public CCMotionStreak()
        {
            m_tBlendFunc = new CCBlendFunc(CCOGLES.GL_SRC_ALPHA, CCOGLES.GL_ONE_MINUS_SRC_ALPHA);
        }
Exemplo n.º 34
0
        public bool InitWithFade(float fade, float minSeg, float stroke, CCColor3B color, CCTexture2D texture)
        {
            Position = CCPoint.Zero;
            AnchorPoint = CCPoint.Zero;
            IgnoreAnchorPointForPosition = true;
            m_bStartingPositionInitialized = false;

            m_tPositionR = CCPoint.Zero;
            m_bFastMode = true;
            m_fMinSeg = (minSeg == -1.0f) ? stroke / 5.0f : minSeg;
            m_fMinSeg *= m_fMinSeg;

            m_fStroke = stroke;
            m_fFadeDelta = 1.0f / fade;

            m_uMaxPoints = (int) (fade * 60.0f) + 2;
            m_uNuPoints = 0;
            m_pPointState = new float[m_uMaxPoints];
            m_pPointVertexes = new CCPoint[m_uMaxPoints];

            m_pVertices = new CCV3F_C4B_T2F[(m_uMaxPoints + 1) * 2];

            // Set blend mode
            m_tBlendFunc = CCBlendFunc.NonPremultiplied;

            Texture = texture;
            Color = color;
            ScheduleUpdate();

            return true;
        }
Exemplo n.º 35
0
        // CCParticleBatchNode - CocosNodeTexture protocol

        private void UpdateBlendFunc()
        {
            if (!TextureAtlas.Texture.HasPremultipliedAlpha)
            {
                m_tBlendFunc = CCBlendFunc.NonPremultiplied;
            }
        }
Exemplo n.º 36
0
        /** Pointers */

        public CCMotionStreak()
        {
            m_tBlendFunc = CCBlendFunc.NonPremultiplied;
        }
Exemplo n.º 37
0
        /** Pointers */

        public CCMotionStreak()
        {
            m_tBlendFunc = new CCBlendFunc(OGLES.GL_SRC_ALPHA, OGLES.GL_ONE_MINUS_SRC_ALPHA);
        }
Exemplo n.º 38
0
        public void initialize()
        {
            atlas = null;
            debugSlots = false;
            debugBones = false;
            timeScale = 1;

            blendFunc = new CCBlendFunc(CCOGLES.GL_ONE, CCOGLES.GL_ONE_MINUS_SRC_ALPHA);
            CCDrawManager.BlendFunc(blendFunc);

            setOpacityModifyRGB(true);

            //SetShaderProgram(CCShaderCache::sharedShaderCache()->programForKey(kCCShader_PositionTextureColor));

            ScheduleUpdate();
        }