예제 #1
0
        public static Vector3 fetchScaleVector(TkAnimNodeData node, TkAnimMetadata animMeta, int frameCounter)
        {
            //Load Frames
            //Console.WriteLine("Setting Frame Index {0}", frameIndex);
            TkAnimNodeFrameData frame      = animMeta.AnimFrameData[frameCounter];
            TkAnimNodeFrameData stillframe = animMeta.StillFrameData;

            Vector3 v;

            if (node.ScaleIndex < frame.Scales.Count)
            {
                v = new Vector3(
                    frame.Scales[node.ScaleIndex].x / frame.Scales[node.ScaleIndex].t,
                    frame.Scales[node.ScaleIndex].y / frame.Scales[node.ScaleIndex].t,
                    frame.Scales[node.ScaleIndex].z / frame.Scales[node.ScaleIndex].t);
            }
            else //Load stillframedata
            {
                int scaleindex = node.ScaleIndex - frame.Scales.Count;
                v = new Vector3(
                    stillframe.Scales[scaleindex].x / stillframe.Scales[scaleindex].t,
                    stillframe.Scales[scaleindex].y / stillframe.Scales[scaleindex].t,
                    stillframe.Scales[scaleindex].z / stillframe.Scales[scaleindex].t);
            }

            return(v);
        }
예제 #2
0
        public static void fetchTransVector(TkAnimNodeData node, TkAnimMetadata animMeta, int frameCounter, ref Vector3 v)
        {
            //Load Frames
            //Console.WriteLine("Setting Frame Index {0}", frameIndex);
            TkAnimNodeFrameData frame      = animMeta.AnimFrameData[frameCounter];
            TkAnimNodeFrameData stillframe = animMeta.StillFrameData;
            TkAnimNodeFrameData activeFrame;
            int transIndex = -1;

            //Load Translations
            if (node.TransIndex < frame.Translations.Count)
            {
                transIndex  = node.TransIndex;
                activeFrame = frame;
            }
            else //Load stillframedata
            {
                transIndex  = node.TransIndex - frame.Translations.Count;
                activeFrame = stillframe;
            }


            v.X = activeFrame.Translations[transIndex].x;
            v.Y = activeFrame.Translations[transIndex].y;
            v.Z = activeFrame.Translations[transIndex].z;
        }
예제 #3
0
        public static Vector3 fetchTransVector(TkAnimNodeData node, TkAnimMetadata animMeta, int frameCounter)
        {
            //Load Frames
            //Console.WriteLine("Setting Frame Index {0}", frameIndex);
            TkAnimNodeFrameData frame      = animMeta.AnimFrameData[frameCounter];
            TkAnimNodeFrameData stillframe = animMeta.StillFrameData;

            Vector3 v;

            //Load Translations
            if (node.TransIndex < frame.Translations.Count)
            {
                v = new Vector3(frame.Translations[node.TransIndex].x,
                                frame.Translations[node.TransIndex].y,
                                frame.Translations[node.TransIndex].z);
            }
            else //Load stillframedata
            {
                int transindex = node.TransIndex - frame.Translations.Count;
                v = new Vector3(stillframe.Translations[transindex].x,
                                stillframe.Translations[transindex].y,
                                stillframe.Translations[transindex].z);
            }

            return(v);
        }
예제 #4
0
        public static void fetchRotQuaternion(TkAnimNodeData node, TkAnimMetadata animMeta, int frameCounter, ref Quaternion q)
        {
            //Load Frames
            //Console.WriteLine("Setting Frame Index {0}", frameIndex);
            TkAnimNodeFrameData frame       = animMeta.AnimFrameData[frameCounter];
            TkAnimNodeFrameData stillframe  = animMeta.StillFrameData;
            TkAnimNodeFrameData activeFrame = null;
            int rotIndex = -1;

            //Check if there is a rotation for that node

            if (node.RotIndex < frame.Rotations.Count)
            {
                activeFrame = frame;
                rotIndex    = node.RotIndex;
            }
            else //Load stillframedata
            {
                activeFrame = stillframe;
                rotIndex    = node.RotIndex - frame.Rotations.Count;
            }

            q.X = activeFrame.Rotations[rotIndex].x;
            q.Y = activeFrame.Rotations[rotIndex].y;
            q.Z = activeFrame.Rotations[rotIndex].z;
            q.W = activeFrame.Rotations[rotIndex].w;
        }
예제 #5
0
        //Animation frame data collection methods
        public static Quaternion fetchRotQuaternion(TkAnimNodeData node, TkAnimMetadata animMeta, int frameCounter)
        {
            //Load Frames
            //Console.WriteLine("Setting Frame Index {0}", frameIndex);
            TkAnimNodeFrameData frame      = animMeta.AnimFrameData[frameCounter];
            TkAnimNodeFrameData stillframe = animMeta.StillFrameData;

            OpenTK.Quaternion q;
            //Check if there is a rotation for that node
            if (node.RotIndex < frame.Rotations.Count)
            {
                int rotindex = node.RotIndex;
                q = new OpenTK.Quaternion(frame.Rotations[rotindex].x,
                                          frame.Rotations[rotindex].y,
                                          frame.Rotations[rotindex].z,
                                          frame.Rotations[rotindex].w);
            }
            else //Load stillframedata
            {
                int rotindex = node.RotIndex - frame.Rotations.Count;
                q = new OpenTK.Quaternion(stillframe.Rotations[rotindex].x,
                                          stillframe.Rotations[rotindex].y,
                                          stillframe.Rotations[rotindex].z,
                                          stillframe.Rotations[rotindex].w);
            }

            return(q);
        }
예제 #6
0
파일: GMDL.cs 프로젝트: LongJohnCoder/NMSMV
        public AnimMetadata(TkAnimMetadata amd)
        {
            //Copy struct info
            FrameCount     = amd.FrameCount;
            NodeCount      = amd.NodeCount;
            NodeData       = amd.NodeData;
            AnimFrameData  = amd.AnimFrameData;
            StillFrameData = amd.StillFrameData;

            duration = FrameCount * 1000.0f;
        }
예제 #7
0
        public AnimPoseComponent(TkAnimPoseComponentData apcd)
        {
            _poseFrameData = (TkAnimMetadata)NMSUtils.LoadNMSTemplate(apcd.Filename,
                                                                      ref Common.RenderState.activeResMgr);

            //Load PoseAnims
            for (int i = 0; i < apcd.PoseAnims.Count; i++)
            {
                AnimPoseData my_apd = new AnimPoseData(apcd.PoseAnims[i]);
                poseData.Add(my_apd);
            }
        }
예제 #8
0
 private void fetchAnimMetaData()
 {
     if (Common.RenderState.activeResMgr.Animations.ContainsKey(Filename))
     {
         animMeta = Common.RenderState.activeResMgr.Animations[Filename];
     }
     else
     {
         TkAnimMetadata amd = NMSUtils.LoadNMSTemplate(Filename,
                                                       ref Common.RenderState.activeResMgr) as TkAnimMetadata;
         animMeta = new AnimMetadata(amd);
         animMeta.load(); //Load data as well
         Common.RenderState.activeResMgr.Animations[Filename] = animMeta;
     }
     NotifyPropertyChanged("FrameCount");
 }
예제 #9
0
        public static void fetchScaleVector(TkAnimNodeData node, TkAnimMetadata animMeta, int frameCounter, ref Vector3 s)
        {
            //Load Frames
            //Console.WriteLine("Setting Frame Index {0}", frameIndex);
            TkAnimNodeFrameData frame       = animMeta.AnimFrameData[frameCounter];
            TkAnimNodeFrameData stillframe  = animMeta.StillFrameData;
            TkAnimNodeFrameData activeFrame = null;
            int scaleIndex = -1;

            if (node.ScaleIndex < frame.Scales.Count)
            {
                scaleIndex  = node.ScaleIndex;
                activeFrame = frame;
            }
            else //Load stillframedata
            {
                scaleIndex  = node.ScaleIndex - frame.Scales.Count;
                activeFrame = stillframe;
            }

            s.X = activeFrame.Scales[scaleIndex].x / activeFrame.Scales[scaleIndex].t;
            s.Y = activeFrame.Scales[scaleIndex].y / activeFrame.Scales[scaleIndex].t;
            s.Z = activeFrame.Scales[scaleIndex].z / activeFrame.Scales[scaleIndex].t;
        }