private void listKeyframes_SelectedIndexChanged(object sender, EventArgs e)
        {
            int index = listKeyframes.SelectedIndex;

            if (index >= 0)
            {
                CameraAnimationFrame f = (CameraAnimationFrame)listKeyframes.SelectedItem;
                numFrame.Value = (decimal)(f.Index + 1);
            }
        }
        public void SetFrame(int index)
        {
            if (index > _maxFrame || index < 0)
            {
                return;
            }

            index = TargetModel == null ? 0 : index;

            CurrentFrame = index;

            if (stPersonToolStripMenuItem.Checked && _scn0 != null && scn0Editor._camera != null)
            {
                SCN0CameraNode       c = scn0Editor._camera;
                CameraAnimationFrame f = c.GetAnimFrame(index - 1);
                Vector3 r = f.GetRotate(index, c.Type);
                Vector3 t = f.Pos;
                ModelPanel._camera.Reset();
                ModelPanel._camera.Translate(t._x, t._y, t._z);
                ModelPanel._camera.Rotate(r._x, r._y, r._z);
                ModelPanel._aspect = f.Aspect;
                ModelPanel._farZ   = f.FarZ;
                ModelPanel._nearZ  = f.NearZ;
                ModelPanel._fovY   = f.FovY;
                ModelPanel.OnResized();
            }

            pnlPlayback.btnNextFrame.Enabled = _animFrame < _maxFrame;
            pnlPlayback.btnPrevFrame.Enabled = _animFrame > 0;

            pnlPlayback.btnLast.Enabled  = _animFrame != _maxFrame;
            pnlPlayback.btnFirst.Enabled = _animFrame > 1;

            if (_animFrame <= pnlPlayback.numFrameIndex.Maximum)
            {
                pnlPlayback.numFrameIndex.Value = _animFrame;
            }

            if (!_playing)
            {
                if (InterpolationEditor != null && InterpolationEditor.Visible)
                {
                    InterpolationEditor.Frame = CurrentFrame;
                }
                KeyframePanel.numFrame_ValueChanged();
            }
        }
Exemple #3
0
        private static Matrix34 ProjectionTexMtx(SCN0CameraNode c, float frame)
        {
            CameraAnimationFrame f = c.GetAnimFrame(frame);

            if (c.ProjectionType == Wii.Graphics.ProjectionType.Orthographic)
            {
                return(LightMtxOrtho(
                           f.Height / 2.0f,
                           -f.Height / 2.0f,
                           -f.Height * f.Aspect / 2.0f,
                           f.Height * f.Aspect / 2.0f,
                           0.5f, -0.5f, 0.5f, 0.5f));
            }

            return(LightMtxPersp(
                       f.FovY, 1.0f,
                       0.5f, -0.5f, 0.5f, 0.5f));
        }
        private void RefreshPage()
        {
            if (_target != null)
            {
                _currentFrame = _target.GetAnimFrame(_currentPage);

                numPosX.Value = _currentFrame.Pos._x;
                numPosY.Value = _currentFrame.Pos._y;
                numPosZ.Value = _currentFrame.Pos._z;

                numRotX.Value = _currentFrame.Rot._x;
                numRotY.Value = _currentFrame.Rot._y;
                numRotZ.Value = _currentFrame.Rot._z;

                numAimX.Value = _currentFrame.Aim._x;
                numAimY.Value = _currentFrame.Aim._y;
                numAimZ.Value = _currentFrame.Aim._z;

                numTwist.Value  = _currentFrame.Twist;
                numFovY.Value   = _currentFrame.FovY;
                numHeight.Value = _currentFrame.Height;
                numAspect.Value = _currentFrame.Aspect;
                numNearZ.Value  = _currentFrame.NearZ;
                numFarZ.Value   = _currentFrame.FarZ;

                for (int i = 0; i < 15; i++)
                {
                    UpdateBox(i);
                }

                btnPrev.Enabled = _currentPage > 0;
                btnNext.Enabled = _currentPage < (_numFrames - 1);

                listKeyframes.SelectedIndex = FindKeyframe(_currentPage);
            }
        }
Exemple #5
0
        public void UpdateKeyframe(int x)
        {
            if (!Visible)
            {
                return;
            }

            _updating = true;
            if (_target is CHR0EntryNode || _target is SRT0TextureNode)
            {
                IKeyframeSource entry = _target as IKeyframeSource;
                for (int w = 0; w < listKeyframes.Items.Count; w++)
                {
                    if (_target is CHR0EntryNode)
                    {
                        CHRAnimationFrame a = (CHRAnimationFrame)listKeyframes.Items[w];
                        if (a.Index == x)
                        {
                            CHRAnimationFrame r = ((CHR0EntryNode)entry).GetAnimFrame(x);

                            if (r.HasKeys)
                            {
                                listKeyframes.Items[w] = r;
                            }
                            else
                            {
                                listKeyframes.Items.RemoveAt(w);
                            }

                            _updating = false;
                            return;
                        }
                    }
                    else if (_target is SRT0TextureNode)
                    {
                        SRTAnimationFrame a = (SRTAnimationFrame)listKeyframes.Items[w];
                        if (a.Index == x)
                        {
                            SRTAnimationFrame r = ((SRT0TextureNode)entry).GetAnimFrame(x);

                            if (r.HasKeys)
                            {
                                listKeyframes.Items[w] = r;
                            }
                            else
                            {
                                listKeyframes.Items.RemoveAt(w);
                            }

                            _updating = false;
                            return;
                        }
                    }
                }

                UpdateKeyframes();
            }
            else if (_target is SHP0VertexSetNode)
            {
                SHP0VertexSetNode entry = _target as SHP0VertexSetNode;
                int w = 0;
                foreach (FloatKeyframe a in listKeyframes.Items)
                {
                    if (a.Index == x)
                    {
                        KeyframeEntry e = entry.GetKeyframe(x);

                        if (e != null)
                        {
                            listKeyframes.Items[w] = new FloatKeyframe(e);
                        }
                        else
                        {
                            listKeyframes.Items.RemoveAt(w);
                        }

                        _updating = false;
                        return;
                    }
                    w++;
                }

                UpdateKeyframes();
            }
            else if (_target is SCN0EntryNode)
            {
                if (_target is SCN0CameraNode)
                {
                    SCN0CameraNode entry = _target as SCN0CameraNode;
                    for (int w = 0; w < listKeyframes.Items.Count; w++)
                    {
                        CameraAnimationFrame a = (CameraAnimationFrame)listKeyframes.Items[w];
                        if (a.Index == x)
                        {
                            CameraAnimationFrame r = entry.GetAnimFrame(x);

                            if (r.HasKeys)
                            {
                                listKeyframes.Items[w] = r;
                            }
                            else
                            {
                                listKeyframes.Items.RemoveAt(w);
                            }

                            _updating = false;
                            return;
                        }
                    }

                    UpdateKeyframes();
                }
                else if (_target is SCN0LightNode)
                {
                    SCN0LightNode entry = _target as SCN0LightNode;
                    for (int w = 0; w < listKeyframes.Items.Count; w++)
                    {
                        LightAnimationFrame a = (LightAnimationFrame)listKeyframes.Items[w];
                        if (a.Index == x)
                        {
                            LightAnimationFrame r = entry.GetAnimFrame(x);

                            if (r.HasKeys)
                            {
                                listKeyframes.Items[w] = r;
                            }
                            else
                            {
                                listKeyframes.Items.RemoveAt(w);
                            }

                            _updating = false;
                            return;
                        }
                    }

                    UpdateKeyframes();
                }
                else if (_target is SCN0FogNode)
                {
                    SCN0FogNode entry = _target as SCN0FogNode;
                    for (int w = 0; w < listKeyframes.Items.Count; w++)
                    {
                        FogAnimationFrame a = (FogAnimationFrame)listKeyframes.Items[w];
                        if (a.Index == x)
                        {
                            FogAnimationFrame r = entry.GetAnimFrame(x);

                            if (r.HasKeys)
                            {
                                listKeyframes.Items[w] = r;
                            }
                            else
                            {
                                listKeyframes.Items.RemoveAt(w);
                            }

                            _updating = false;
                            return;
                        }
                    }

                    UpdateKeyframes();
                }
            }
            _updating = false;
        }