Exemplo n.º 1
0
        public override void Init(Record record)
        {
            base.CopyRecord(record);              //wheww, this is ugly.

            BinaryFlashReader reader = record.GetDataReader();

            //I don't need these (start/end bounds):
            this.Id = reader.ReadUInt16();
            reader.ReadRect();
            reader.ReadRect();


            // Offset to EndEdges
            uint offset       = reader.ReadUInt32();
            int  posForShape2 = (int)(reader.BaseStream.Position + offset);

            this.FillStyles = reader.ReadFillStyleArray(true, true, true);
            this.LineStyles = reader.ReadLineStyleArray(true, true, true, false);

            this.CommandList = ReadShapeCommands(reader, this.FillStyles, this.LineStyles, true, true, true, false);

            if (posForShape2 > reader.BaseStream.Position)
            {
                throw new Exception("Morph target error");
            }
            //make sure we're at the right position
            reader.BaseStream.Position = posForShape2;

            this._morphCommandList = ReadShapeCommands(reader, this.FillStyles, this.LineStyles, true, true, true, false);

            //Style changes are defined only in start shape - copy them to end shape!
            object      carry     = null;
            EPoint      ptCurrent = new EPoint();
            ArrayList   corrected = new ArrayList();
            IEnumerator enTarget  = this._morphCommandList.GetEnumerator();

            foreach (ShapeCommand.Base cmd in this.CommandList)
            {
                if (cmd.IsStyle)
                {
                    continue;
                }

                if (carry != null)
                {
                    corrected.Add(carry);
                    carry = null;
                }
                else
                {
                    if (!enTarget.MoveNext())
                    {
                        throw new Exception("Morph target is missing edges");
                    }

                    ShapeCommand.Base cmdTo = (ShapeCommand.Base)enTarget.Current;
                    if (cmd is ShapeCommand.Move)
                    {
                        if (cmdTo is ShapeCommand.Move)
                        {
                            corrected.Add(cmdTo);
                        }
                        else
                        {
                            carry = cmdTo;
                            corrected.Add(new ShapeCommand.Move(ptCurrent));
                        }
                    }
                    else
                    {
                        corrected.Add(cmdTo);
                    }

                    if (cmdTo is ShapeCommand.Move)
                    {
                        ptCurrent = ((ShapeCommand.Move)cmdTo).GetNewLoc(ptCurrent);
                    }
                    else if (cmdTo is ShapeCommand.Draw)
                    {
                        ptCurrent = ((ShapeCommand.Draw)cmdTo).GetNewLoc(ptCurrent);
                    }
                }
            }
            this._morphCommandList = corrected;

            string s = this.WriteCommands(this._morphCommandList);

            Endogine.Files.FileReadWrite.Write("MS" + this.Id + ".txt", s);

            this.InitDone();
        }
Exemplo n.º 2
0
        public ArrayList CreateMorphedShape(float ratio)
        {
            ArrayList morphedCommands = new ArrayList();
            int       targetIndex     = -1;
            EPoint    ptCurrent       = new EPoint();

            foreach (ShapeCommand.Base cmd in this.CommandList)
            {
                if (!(cmd is ShapeCommand.Style))
                {
                    targetIndex++;
                }

                ShapeCommand.Base cmdTo = (ShapeCommand.Base) this._morphCommandList[targetIndex];

                if (cmd is ShapeCommand.Move)
                {
                    EPoint pt1 = ((ShapeCommand.Move)cmd).Target;
                    EPoint pt2 = ((ShapeCommand.Move)cmdTo).Target;
                    ptCurrent = this.GetPointBetween(pt1, pt2, ratio);
                    morphedCommands.Add(new ShapeCommand.Move(ptCurrent));
                }
                else if ((cmd is ShapeCommand.Line) || (cmd is ShapeCommand.Curve))
                {
                    ShapeCommand.Draw  draw  = (ShapeCommand.Draw)cmd;
                    ShapeCommand.Curve curve = draw.GetAsCurve();

                    if ((cmdTo is ShapeCommand.Line) || (cmdTo is ShapeCommand.Curve))
                    {
                        draw = (ShapeCommand.Draw)cmdTo;
                        ShapeCommand.Curve curveTo = draw.GetAsCurve();

                        EPoint ptControl = this.GetPointBetween(curve.Control, curveTo.Control, ratio);
                        EPoint ptAnchor  = this.GetPointBetween(curve.Anchor, curveTo.Anchor, ratio);

                        morphedCommands.Add(new ShapeCommand.Curve(ptControl, ptAnchor));
                        ptCurrent += ptControl + ptAnchor;
                    }
                    else
                    {
                        ShapeCommand.Move move = (ShapeCommand.Move)cmdTo;

                        EPoint ptFrom = ptCurrent + curve.Control + curve.Anchor;
                        EPoint ptTo   = move.Target;

                        ptCurrent = this.GetPointBetween(ptFrom, ptTo, ratio);
                        morphedCommands.Add(new ShapeCommand.Move(ptCurrent.Copy()));
                    }
                }
                else if (cmd is ShapeCommand.LineStyle)
                {
                    ShapeCommand.LineStyle ls = (ShapeCommand.LineStyle)cmd;
                    if (ls.StyleId > 0)
                    {
                        Style.LineStyle style = (Style.LineStyle) this.LineStyles[ls.StyleId - 1];
                        style.MorphPosition = ratio;
                        morphedCommands.Add(ls);                         //.GetMorphed(ratio));
                    }
                }
                else if (cmd is ShapeCommand.FillStyle)
                {
                    ShapeCommand.FillStyle fs = (ShapeCommand.FillStyle)cmd;
                    if (fs.StyleId > 0)
                    {
                        Style.FillStyle style = (Style.FillStyle) this.FillStyles[fs.StyleId - 1];
                        style.MorphPosition = ratio;
                        morphedCommands.Add(fs);                         //.GetMorphed(ratio));
                    }
                }
            }
            return(morphedCommands);
        }