예제 #1
0
        public void UpdateSprite()
        {
            if (SpriteList.SelectedIndex == -1 || ActiveDGRPImages == null)
            {
                return;
            }

            InternalChange    = true;
            ActiveDGRPSprites = new DGRPSprite[ActiveDGRPImages.Length];

            for (int i = 0; i < ActiveDGRPSprites.Length; i++)
            {
                ActiveDGRPSprites[i] = ActiveDGRPImages[i].Sprites[SpriteList.SelectedIndex];
            }

            //if dynamic, set the dynamic sprite flags to 0
            var sprID  = (ushort)ActiveDGRPSprites[0].SpriteID;
            var baseID = ActiveObject.OBJ.DynamicSpriteBaseId;

            if (sprID >= baseID && sprID < baseID + ActiveObject.OBJ.NumDynamicSprites)
            {
                DGRPEdit.SetDynamic(sprID - baseID);
            }

            xPx.Value = (int)ActiveDGRPSprites[0].SpriteOffset.X;
            yPx.Value = (int)ActiveDGRPSprites[0].SpriteOffset.Y;

            xPhys.Text = ActiveDGRPSprites[0].ObjectOffset.X.ToString();
            yPhys.Text = ActiveDGRPSprites[0].ObjectOffset.Y.ToString();
            zPhys.Text = ActiveDGRPSprites[0].ObjectOffset.Z.ToString();

            RotationCombo.Items.Clear();

            var spr2 = ActiveIff.Get <SPR2>(sprID);

            if (spr2 != null)
            {
                for (int i = 0; i < spr2.Frames.Length / 3; i++)
                {
                    RotationCombo.Items.Add("Rotation " + i);
                }
                RotationCombo.SelectedIndex = (int)(ActiveDGRPSprites[0].SpriteFrameIndex % (spr2.Frames.Length / 3));

                SPRLabel.Text = spr2.ChunkLabel;
            }
            else
            {
                SPRLabel.Text = "Unknown SPR2#" + ActiveDGRPSprites[0].SpriteID;
            }

            FlipCheck.Checked = ActiveDGRPSprites[0].Flip;

            InternalChange = false;
        }
예제 #2
0
        public void SetActiveObject(GameObject active)
        {
            ActiveObject = active;
            ActiveIff    = active.Resource;
            ActiveDGRP   = null;

            SelectSpriteBox.Enabled = false;
            groupBox3.Enabled       = false;

            int sprID = active.OBJ.DynamicSpriteBaseId;
            var spr2  = ActiveIff.Get <SPR2>((ushort)sprID);

            if (spr2 != null)
            {
                FirstDynLabel.Text = spr2.ChunkLabel;
            }
            else if (sprID == 0)
            {
                FirstDynLabel.Text = "None Selected";
            }
            else
            {
                FirstDynLabel.Text = "Unknown SPR2#" + sprID;
            }

            sprID = active.OBJ.DynamicSpriteBaseId + active.OBJ.NumDynamicSprites - 1;
            if (active.OBJ.NumDynamicSprites == 0)
            {
                sprID = 0;
            }
            spr2 = ActiveIff.Get <SPR2>((ushort)sprID);

            if (spr2 != null)
            {
                LastDynLabel.Text = spr2.ChunkLabel;
            }
            else if (sprID < 1)
            {
                LastDynLabel.Text = "None Selected";
            }
            else
            {
                LastDynLabel.Text = "Unknown SPR2#" + sprID;
            }

            DGRPEdit.ShowObject(active.OBJ.GUID);

            UpdateDGRPList(true);
            var allowEdit = (ActiveObject.OBJ.ObjectType != OBJDType.Person);

            groupBox1.Enabled = allowEdit;
            DGRPBox.Enabled   = allowEdit;
        }
예제 #3
0
        private void DGRPList_SelectedIndexChanged(object sender, EventArgs e)
        {
            if (DGRPList.SelectedIndices.Count == 0 || !DGRPChunkIDs.ContainsKey(DGRPList.SelectedItems[0]))
            {
                return;
            }
            ActiveDGRP = ActiveIff.Get <DGRP>(DGRPChunkIDs[DGRPList.SelectedItems[0]]);

            if (ActiveDGRP != null)
            {
                //change selected graphic
                DGRPEdit.ChangeGraphic(ActiveDGRP.ChunkID);
                UpdateImage();
            }
        }
예제 #4
0
        private void zPhys_TextChanged(object sender, EventArgs e)
        {
            if (ActiveDGRPSprites == null || InternalChange)
            {
                return;
            }
            float value = 0;

            float.TryParse(zPhys.Text, out value);
            GameContent.Get.Changes.BlockingResMod(new ResAction(() =>
            {
                foreach (var dgrpSpr in ActiveDGRPSprites)
                {
                    dgrpSpr.ObjectOffset.Z = value;
                }
            }, ActiveDGRP));
            DGRPEdit.ForceUpdate();
        }
예제 #5
0
        private void UpdateImage()
        {
            var oldIndex = SpriteList.SelectedIndex;

            DGRPEdit.ChangeWorld((int)RotationTrack.Value, (int)ZoomTrack.Value);
            DGRPEdit.ForceUpdate();
            if (ActiveDGRP == null)
            {
                SelectSpriteBox.Enabled = false;
                groupBox3.Enabled       = false;
                return;
            }
            else
            {
                //todo: verify that images can be zoom synced

                if (AutoRot.Checked)
                {
                    var dgrps = new List <DGRPImage>();
                    for (int i = 0; i < 4; i++)
                    {
                        dgrps.Add(ActiveDGRP.GetImage(0x10, 3, (uint)i));
                        dgrps.Add(ActiveDGRP.GetImage(0x10, 2, (uint)i));
                        dgrps.Add(ActiveDGRP.GetImage(0x10, 1, (uint)i));
                    }
                    ActiveDGRPImages = dgrps.ToArray();
                }
                else if (AutoZoom.Checked)
                {
                    ActiveDGRPImages = new DGRPImage[] {
                        ActiveDGRP.GetImage(0x10, 3, (uint)RotationTrack.Value),
                        ActiveDGRP.GetImage(0x10, 2, (uint)RotationTrack.Value),
                        ActiveDGRP.GetImage(0x10, 1, (uint)RotationTrack.Value)
                    };
                }
                else
                {
                    ActiveDGRPImages = new DGRPImage[] {
                        ActiveDGRP.GetImage(0x10, (uint)(3 - ZoomTrack.Value), (uint)RotationTrack.Value)
                    };
                }

                //populate sprite list

                SelectSpriteBox.Enabled = true;
                groupBox3.Enabled       = true;

                SpriteList.Items.Clear();
                foreach (var frame in ActiveDGRPImages[0].Sprites)
                {
                    //attempt to get spr
                    var sprID  = (ushort)frame.SpriteID;
                    var baseID = ActiveObject.OBJ.DynamicSpriteBaseId;
                    var isDyn  = (sprID >= baseID && sprID < baseID + ActiveObject.OBJ.NumDynamicSprites);

                    var spr  = ActiveIff.Get <SPR2>(sprID);
                    var dyn  = (isDyn) ? ("(^" + (sprID - baseID) + ") "):"";
                    var name = (spr != null) ? spr.ChunkLabel : ("SPR#" + frame.SpriteID);
                    SpriteList.Items.Add(dyn + name + " (" + frame.SpriteOffset.X + "," + frame.SpriteOffset.Y + ")");
                }
                if (SpriteList.Items.Count == 0)
                {
                    SelectSpriteBox.Enabled = false;
                }
                else
                {
                    SelectSpriteBox.Enabled = true;
                    if (OldDGRP == ActiveDGRP)
                    {
                        SpriteList.SelectedIndex = Math.Max(0, Math.Min(SpriteList.Items.Count - 1, oldIndex));
                    }
                    else
                    {
                        SpriteList.SelectedIndex = 0;
                    }
                }
                OldDGRP = ActiveDGRP;
            }
        }