void spRegionAttachment_updateQuad(ref RegionAttachment self, ref Slot slot, CCV3F_C4B_T2F_Quad quad, bool premultipliedAlpha)
        {
            float[] vertices = new float[8];

            self.ComputeWorldVertices(slot.Skeleton.X, slot.Skeleton.Y, slot.Bone, vertices);

            float r = (slot.Skeleton.R * slot.R * 255);
            float g = (slot.Skeleton.G * slot.G * 255);
            float b = (slot.Skeleton.B * slot.B * 255);

            float normalizedAlpha = slot.Skeleton.A * slot.A;
            if (premultipliedAlpha)
            {

                r *= normalizedAlpha;
                g *= normalizedAlpha;
                b *= normalizedAlpha;
            }

            float a = normalizedAlpha * 255;

            quad.BottomLeft.Colors.R = Convert.ToByte(r);
            quad.BottomLeft.Colors.G = Convert.ToByte(g);
            quad.BottomLeft.Colors.B = Convert.ToByte(b);
            quad.BottomLeft.Colors.A = Convert.ToByte(a);
            quad.TopLeft.Colors.R = Convert.ToByte(r);
            quad.TopLeft.Colors.G = Convert.ToByte(g);
            quad.TopLeft.Colors.B = Convert.ToByte(b);
            quad.TopLeft.Colors.A = Convert.ToByte(a);
            quad.TopRight.Colors.R = Convert.ToByte(r);
            quad.TopRight.Colors.G = Convert.ToByte(g);
            quad.TopRight.Colors.B = Convert.ToByte(b);
            quad.TopRight.Colors.A = Convert.ToByte(a);
            quad.BottomRight.Colors.R = Convert.ToByte(r);
            quad.BottomRight.Colors.G = Convert.ToByte(g);
            quad.BottomRight.Colors.B = Convert.ToByte(b);
            quad.BottomRight.Colors.A = Convert.ToByte(a);

            quad.BottomLeft.Vertices.X = vertices[RegionAttachment.X1];
            quad.BottomLeft.Vertices.Y = vertices[RegionAttachment.Y1];
            quad.TopLeft.Vertices.X = vertices[RegionAttachment.X2];
            quad.TopLeft.Vertices.Y = vertices[RegionAttachment.Y2];
            quad.TopRight.Vertices.X = vertices[RegionAttachment.X3];
            quad.TopRight.Vertices.Y = vertices[RegionAttachment.Y3];
            quad.BottomRight.Vertices.X = vertices[RegionAttachment.X4];
            quad.BottomRight.Vertices.Y = vertices[RegionAttachment.Y4];

            quad.BottomLeft.TexCoords.U = self.UVs[RegionAttachment.X1];
            quad.BottomLeft.TexCoords.V = self.UVs[RegionAttachment.Y1];
            quad.TopLeft.TexCoords.U = self.UVs[RegionAttachment.X2];
            quad.TopLeft.TexCoords.V = self.UVs[RegionAttachment.Y2];
            quad.TopRight.TexCoords.U = self.UVs[RegionAttachment.X3];
            quad.TopRight.TexCoords.V = self.UVs[RegionAttachment.Y3];
            quad.BottomRight.TexCoords.U = self.UVs[RegionAttachment.X4];
            quad.BottomRight.TexCoords.V = self.UVs[RegionAttachment.Y4];
        }
        void spRegionAttachment_updateQuad(RegionAttachment self, Slot slot, CCV3F_C4B_T2F_Quad quad, bool premultipliedAlpha = false)
        {
            float[] vertices = new float[8];

            self.ComputeWorldVertices(slot.Skeleton.X, slot.Skeleton.Y, slot.Bone, vertices);

            byte r = Convert.ToByte(slot.Skeleton.R * slot.R * 255);
            byte g =Convert.ToByte( slot.Skeleton.G * slot.G * 255);
            byte b = Convert.ToByte(slot.Skeleton.B * slot.B * 255);

            byte normalizedAlpha = Convert.ToByte( slot.Skeleton.A * slot.A);
            if (premultipliedAlpha)
            {
                r *= normalizedAlpha;
                g *= normalizedAlpha;
                b *= normalizedAlpha;
            }

            byte a = Convert.ToByte(normalizedAlpha * 255);
            quad.BottomLeft.Colors.R = r;
            quad.BottomLeft.Colors.G = g;
            quad.BottomLeft.Colors.B = b;
            quad.BottomLeft.Colors.A = a;
            quad.TopLeft.Colors.R = r;
            quad.TopLeft.Colors.G = g;
            quad.TopLeft.Colors.B = b;
            quad.TopLeft.Colors.A = a;
            quad.TopRight.Colors.R = r;
            quad.TopRight.Colors.G = g;
            quad.TopRight.Colors.B = b;
            quad.TopRight.Colors.A = a;
            quad.BottomRight.Colors.R = r;
            quad.BottomRight.Colors.G = g;
            quad.BottomRight.Colors.B = b;
            quad.BottomRight.Colors.A = a;

            quad.BottomLeft.Vertices.X = vertices[VERTEX_X1];
            quad.BottomLeft.Vertices.Y = vertices[VERTEX_Y1];
            quad.TopLeft.Vertices.X = vertices[VERTEX_X2];
            quad.TopLeft.Vertices.Y = vertices[VERTEX_Y2];
            quad.TopRight.Vertices.X = vertices[VERTEX_X3];
            quad.TopRight.Vertices.Y = vertices[VERTEX_Y3];
            quad.BottomRight.Vertices.X = vertices[VERTEX_X4];
            quad.BottomRight.Vertices.Y = vertices[VERTEX_Y4];

            quad.BottomLeft.TexCoords.U = self.UVs[VERTEX_X1];
            quad.BottomLeft.TexCoords.V = self.UVs[VERTEX_Y1];
            quad.TopLeft.TexCoords.U = self.UVs[VERTEX_X2];
            quad.TopLeft.TexCoords.V = self.UVs[VERTEX_Y2];
            quad.TopRight.TexCoords.U = self.UVs[VERTEX_X3];
            quad.TopRight.TexCoords.V = self.UVs[VERTEX_Y3];
            quad.BottomRight.TexCoords.U = self.UVs[VERTEX_X4];
            quad.BottomRight.TexCoords.V = self.UVs[VERTEX_Y4];
        }
        protected CCTex2F TextureCoordFromAlphaPoint(CCPoint alpha)
        {
            var ret = new CCTex2F(0.0f, 0.0f);

            if (m_pSprite == null)
            {
                return(ret);
            }

            CCV3F_C4B_T2F_Quad quad = m_pSprite.Quad;

            var min = new CCPoint(quad.BottomLeft.TexCoords.U, quad.BottomLeft.TexCoords.V);
            var max = new CCPoint(quad.TopRight.TexCoords.U, quad.TopRight.TexCoords.V);

            //  Fix bug #1303 so that progress timer handles sprite frame texture rotation
            if (m_pSprite.IsTextureRectRotated)
            {
                float tmp = alpha.X;
                alpha.X = alpha.Y;
                alpha.Y = tmp;
            }
            return(new CCTex2F(min.X * (1f - alpha.X) + max.X * alpha.X, min.Y * (1f - alpha.Y) + max.Y * alpha.Y));
        }
        private void UpdateQuad(ref CCV3F_C4B_T2F_Quad quad, ref CCParticle particle)
        {
            CCPoint newPosition;

            if (m_ePositionType == CCPositionType.Free || m_ePositionType == CCPositionType.Relative)
            {
                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_obPosition.X;
                newPosition.Y += m_obPosition.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  = -CCMathHelper.ToRadians(particle.rotation);
                float cr = CCMathHelper.Cos(r);
                float sr = CCMathHelper.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;
            }
        }
Exemple #5
0
 /// <summary>
 /// Inserts a Quad (texture, vertex and color) at a certain index
 /// index must be between 0 and the atlas capacity - 1
 /// @since v0.8
 /// </summary>
 public void InsertQuad(ref CCV3F_C4B_T2F_Quad quad, int index)
 {
     Debug.Assert(index < m_pQuads.Capacity, "insertQuadWithTexture: Invalid index");
     m_pQuads.Insert(index, quad);
     Dirty = true;
 }
Exemple #6
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;
        }
        private void UpdateQuad(ref CCV3F_C4B_T2F_Quad quad, ref CCParticle particle)
        {
            CCPoint newPosition;

            if (m_ePositionType == CCPositionType.Free || m_ePositionType == CCPositionType.Relative)
            {
                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_obPosition.X;
                newPosition.Y += m_obPosition.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 = -CCMathHelper.ToRadians(particle.rotation);
                float cr = CCMathHelper.Cos(r);
                float sr = CCMathHelper.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;
            }
        }
 /// <summary>
 /// Inserts a Quad (texture, vertex and color) at a certain index
 /// index must be between 0 and the atlas capacity - 1
 /// @since v0.8
 /// </summary>
 public void InsertQuad(ref CCV3F_C4B_T2F_Quad quad, int index)
 {
     Debug.Assert(index < m_pQuads.Capacity, "insertQuadWithTexture: Invalid index");
     m_pQuads.Insert(index, quad);
     Dirty = true;
 }
 /// <summary>
 /// updates a Quad (texture, vertex and color) at a certain index
 /// index must be between 0 and the atlas capacity - 1
 /// @since v0.8
 /// </summary>
 public void UpdateQuad(ref CCV3F_C4B_T2F_Quad quad, int index)
 {
     Debug.Assert(index >= 0 && index < m_pQuads.Capacity, "updateQuadWithTexture: Invalid index");
     m_pQuads.count = Math.Max(index + 1, m_pQuads.count);
     m_pQuads.Elements[index] = quad;
     Dirty = true;
 }
        public void FillWithEmptyQuadsFromIndex(int index, int amount)
        {
            int to = index + amount;
            CCV3F_C4B_T2F_Quad[] elements = m_pQuads.Elements;
            var empty = new CCV3F_C4B_T2F_Quad();

            for (int i = index; i < to; i++)
            {
                elements[i] = empty;
            }

            Dirty = true;
        }
        public void MoveQuadsFromIndex(int oldIndex, int amount, int newIndex)
        {
            Debug.Assert(newIndex + amount <= m_pQuads.count, "insertQuadFromIndex:atIndex: Invalid index");
            Debug.Assert(oldIndex < m_pQuads.count, "insertQuadFromIndex:atIndex: Invalid index");

            if (oldIndex == newIndex)
            {
                return;
            }

            var tmp = new CCV3F_C4B_T2F_Quad[amount];
            Array.Copy(m_pQuads.Elements, oldIndex, tmp, 0, amount);

            if (newIndex < oldIndex)
            {
                // move quads from newIndex to newIndex + amount to make room for buffer
                Array.Copy(m_pQuads.Elements, newIndex + amount, m_pQuads.Elements, newIndex, oldIndex - newIndex);
                //memmove(&m_pQuads[newIndex], &m_pQuads[newIndex + amount], (oldIndex - newIndex) * quadSize);
            }
            else
            {
                // move quads above back
                Array.Copy(m_pQuads.Elements, oldIndex + amount, m_pQuads.Elements, oldIndex, newIndex - oldIndex);
                //memmove(&m_pQuads[oldIndex], &m_pQuads[oldIndex + amount], (newIndex - oldIndex) * quadSize);
            }
            //memcpy(&m_pQuads[newIndex], tempQuads, amount * quadSize);
            Array.Copy(tmp, 0, m_pQuads.Elements, newIndex, amount);

            Dirty = true;
        }
Exemple #12
0
        public override void Draw()
        {
            base.Draw();

            // CC_NODE_DRAW_SETUP();

            CCDrawManager.BlendFunc(blendFunc);
            CCColor3B color = Color;
            skeleton.R = color.R / 255f ;
            skeleton.G = color.G / 255f;
            skeleton.B = color.B / 255f;
            skeleton.A = Opacity / 255f;

            bool additive = false;

            CCTextureAtlas textureAtlas = null;

            CCV3F_C4B_T2F_Quad quad = new CCV3F_C4B_T2F_Quad();

            quad.TopLeft.Vertices.Z = 0;
            quad.TopRight.Vertices.Z = 0;
            quad.BottomLeft.Vertices.Z = 0;
            quad.BottomRight.Vertices.Z = 0;

            for (int i = 0; i < skeleton.Slots.Count; i++)
            {
                Slot slot = skeleton.DrawOrder[i];

                if (slot.Attachment == null || slot.Attachment.GetType().ToString() != "Spine.RegionAttachment") continue;  //=> ??????????????

                RegionAttachment attachment = (RegionAttachment)slot.Attachment;
                CCTextureAtlas regionTextureAtlas = GetTextureAtlas(attachment);
                regionTextureAtlas.DrawQuads(); //retain();

                //self.rendererObject = textureAtlas;
                //self.width = texture.PixelsWide;
                //self.height = texture.PixelsHigh;

                if (slot.Data.AdditiveBlending != additive)
                {
                    if (textureAtlas != null)
                    {
                        textureAtlas.DrawQuads();
                        textureAtlas.RemoveAllQuads();
                    }

                    additive = !additive;

                    CCDrawManager.BlendFunc(new CCBlendFunc(blendFunc.Source, (additive) ? CCOGLES.GL_ONE : blendFunc.Destination) );

                }
                else if (textureAtlas != null && regionTextureAtlas != textureAtlas)
                {
                    textureAtlas.DrawQuads();
                    textureAtlas.RemoveAllQuads();
                }

                textureAtlas = regionTextureAtlas;

                int quadCount = textureAtlas.TotalQuads;
                if (textureAtlas.Capacity == quadCount)
                {
                    textureAtlas.DrawQuads();
                    textureAtlas.RemoveAllQuads();

                    if (!textureAtlas.ResizeCapacity(textureAtlas.Capacity * 2)) return;
                }

                spRegionAttachment_updateQuad(attachment, slot, ref quad, premultipliedAlpha);

                textureAtlas.UpdateQuad(ref quad, quadCount);

            }

            if (textureAtlas != null)
            {
                textureAtlas.DrawQuads();
                textureAtlas.RemoveAllQuads();
            }

            if (debugSlots)
            {

                CCPoint[] points = new CCPoint[4];

                CCV3F_C4B_T2F_Quad quada = new CCV3F_C4B_T2F_Quad();

                for (int i = 0, n = skeleton.Slots.Count; i < n; i++)
                {

                    Slot slot = skeleton.DrawOrder[i];

                    if (slot.Attachment == null || slot.Attachment.Name != "ATTACHMENT_REGION") continue;

                    RegionAttachment attachment = (RegionAttachment)slot.Attachment;
                    spRegionAttachment_updateQuad(attachment, slot, ref quad);

                    points[0] = new CCPoint(quada.BottomLeft.Vertices.X, quada.BottomLeft.Vertices.Y);
                    points[1] = new CCPoint(quada.BottomRight.Vertices.X, quada.BottomRight.Vertices.Y);
                    points[2] = new CCPoint(quada.TopRight.Vertices.X, quada.TopRight.Vertices.Y);
                    points[3] = new CCPoint(quada.TopLeft.Vertices.X, quada.TopLeft.Vertices.Y);

                    CCDrawingPrimitives.DrawPoly(points, 4, true, new CCColor4B(0, 0, 255, 255));
                }
            }

            if (debugBones)
            {
                // Bone lengths.
                for (int i = 0; i < skeleton.Bones.Count; i++)
                {
                    Bone bone = skeleton.Bones[i];
                    float x = bone.Data.Length * bone.M00 + bone.WorldX;
                    float y = bone.Data.Length * bone.M10 + bone.WorldY;

                    CCDrawingPrimitives.Begin();
                    CCDrawingPrimitives.DrawLine(new CCPoint(bone.WorldX, bone.WorldY), new CCPoint(x, y), new CCColor4B(255, 0, 0, 255));
                    CCDrawingPrimitives.End();
                }

                // Bone origins.
                for (int i = 0; i < skeleton.Bones.Count; i++)
                {
                    Bone bone = skeleton.Bones[i];
                    CCDrawingPrimitives.Begin();
                    CCDrawingPrimitives.DrawPoint(new CCPoint(bone.WorldX, bone.WorldY), 4, new CCColor4B(0, 0, 255, 255));
                    CCDrawingPrimitives.End();

                }
            }
        }