コード例 #1
0
    public void CreateTPose()
    {
        SkinnedMeshRenderer[] smr = GetComponentsInChildren <SkinnedMeshRenderer>();

        tPose = new PdxDataService.AnimationData();

        foreach (SkinnedMeshRenderer sm in smr)
        {
            foreach (Transform b in sm.bones)
            {
                var a = new PdxDataService.AnimationData.Animation();
                a.parent  = b;
                a.name    = b.name;
                a.sampleQ = a.sampleS = a.sampleT = true;

                var k = new PdxDataService.AnimationData.Key();
                k.pos = b.localPosition;
                k.rot = b.localRotation;
                k.scl = b.localScale;

                a.keys.Add(k);
                tPose.hierarchy.Add(a);
            }
        }
    }
コード例 #2
0
    void InitAnimation()
    {
        needInit = false;

        List <string> boneNames = new List <string>();

        foreach (var a in animationData.hierarchy)
        {
            boneNames.Add(a.name);

            if (!bones.ContainsKey(a.name))
            {
                continue;
            }
            //a.name - bone name
            Transform bone = bones[a.name];

            if (a.keys.Count == 0)
            {
                continue;
            }

            var key = a.keys[0];

            bone.localPosition = key.pos;
            bone.localRotation = key.rot;
            bone.localScale    = key.scl;
        }

        SkinnedMeshRenderer[] smr = GetComponentsInChildren <SkinnedMeshRenderer>();

        foreach (SkinnedMeshRenderer sm in smr)
        {
            foreach (Transform b in sm.bones)
            {
                if (!boneNames.Contains(b.name))
                {
                    var a = new PdxDataService.AnimationData.Animation();
                    a.parent = b;
                    a.name   = b.name;
                    //a.sampleQ = a.sampleS = a.sampleT = true;

                    var k = new PdxDataService.AnimationData.Key();

                    bool rt = false;

                    if (a.name.ToLower().Equals("root"))
                    {
                        rt = true;

                        k.pos = b.position;
                        k.rot = b.rotation;
                    }
                    else
                    {
                        k.pos = b.localPosition;
                        k.rot = b.localRotation;
                    }

                    k.scl = b.localScale;

                    a.keys.Add(k);
                    if (!rt)
                    {
                        animationData.hierarchy.Add(a);
                    }
                    else
                    {
                        animationData.hierarchy.Insert(0, a);
                    }
                }
            }
        }
    }
コード例 #3
0
ファイル: PdxLoader.cs プロジェクト: levelgd/EU4Viewer
    PdxDataService.AnimationData CreatePdxAnimation(PdxDataService.Base _baseAnim)
    {
        var pdxAnimProps = _baseAnim.subNodes["info"].subNodes;

        PdxDataService.AnimationData animationData = new PdxDataService.AnimationData()
        {
            name        = "",
            fps         = pdxAnimProps["fps"].value[0].f,
            length      = pdxAnimProps["sa"].value[0].i / pdxAnimProps["fps"].value[0].f,
            sampleCount = pdxAnimProps["sa"].value[0].i
        };

        Dictionary <string, string> alternativeNames = new Dictionary <string, string>();

        alternativeNames["attack_L_hand"] = "Left_hand_node";
        alternativeNames["attack_R_hand"] = "Right_hand_node";

        for (int k = 0; k < _baseAnim.subNodes["info"].subNodes.Count; k++)
        {
            List <string> kkeys = new List <string>(_baseAnim.subNodes["info"].subNodes.Keys);

            var pdxAnimBone = _baseAnim.subNodes["info"].subNodes[kkeys[k]];

            if (pdxAnimBone.type != "object")
            {
                continue;
            }

            Transform bone = null;

            if (bonesByName.ContainsKey(pdxAnimBone.name))
            {
                bone = bonesByName[pdxAnimBone.name];
            }

            if (bone == null && alternativeNames.ContainsKey(pdxAnimBone.name) && bonesByName.ContainsKey(alternativeNames[pdxAnimBone.name]))
            {
                bone = bonesByName[alternativeNames[pdxAnimBone.name]];
            }

            var    _t  = pdxAnimBone.subNodes["t"].value;
            var    _q  = pdxAnimBone.subNodes["q"].value;
            var    _s  = pdxAnimBone.subNodes["s"].value;
            string _sa = pdxAnimBone.subNodes["sa"].value[0].s;

            PdxDataService.AnimationData.Animation a = new PdxDataService.AnimationData.Animation()
            {
                parent = bone != null ? bone.parent : null,
                name   = pdxAnimBone.name,
                keys   = new List <PdxDataService.AnimationData.Key>()
                {
                    new PdxDataService.AnimationData.Key()
                    {
                        time = 0,
                        pos  = new Vector3(_t[0].f, _t[1].f, _t[2].f),
                        rot  = new Quaternion(_q[0].f, _q[1].f, _q[2].f, _q[3].f),
                        scl  = new Vector3(_s[0].f, _s[0].f, _s[0].f)
                    }
                },
                sampleT  = _sa.IndexOf('t') > -1,
                sampleQ  = _sa.IndexOf('q') > -1,
                sampleS  = _sa.IndexOf('s') > -1,
                skipData = false
            };

            animationData.hierarchy.Add(a);
        }

        int offsetT = 0;
        int offsetQ = 0;
        int offsetS = 0;

        var pdxAnimSamples = _baseAnim.subNodes["samples"].subNodes;

        for (int sample = 0; sample < animationData.sampleCount; sample++)
        {
            for (int k = 0; k < animationData.hierarchy.Count; k++)
            {
                var hier = animationData.hierarchy[k];

                if (hier.sampleT || hier.sampleQ || hier.sampleS)
                {
                    PdxDataService.AnimationData.Key key = new PdxDataService.AnimationData.Key();

                    key.time = (float)sample * (1f / animationData.fps);

                    if (hier.sampleT)
                    {
                        var _t = pdxAnimSamples["t"].value;
                        key.pos  = new Vector3(_t[offsetT].f, _t[offsetT + 1].f, _t[offsetT + 2].f);
                        offsetT += 3;
                    }

                    if (hier.sampleQ)
                    {
                        var _q = pdxAnimSamples["q"].value;
                        key.rot  = new Quaternion(_q[offsetQ].f, _q[offsetQ + 1].f, _q[offsetQ + 2].f, _q[offsetQ + 3].f);
                        offsetQ += 4;
                    }

                    if (hier.sampleS)
                    {
                        var _s = pdxAnimSamples["s"].value;
                        key.scl = new Vector3(_s[offsetS].f, _s[offsetS].f, _s[offsetS].f);
                        offsetS++;
                    }

                    hier.keys.Add(key);
                }
            }
        }

        return(animationData);
    }