コード例 #1
0
 void setupForSubClip(CreaturePackPlayer pack_player, int idx, string anim_name)
 {
     if (composite_clips.ContainsKey(active_name))
     {
         var sublist = composite_clips[active_name];
         pack_player.setActiveAnimation(sublist[idx].name);
         pack_player.setRunTime(sublist[idx].start_frame, "");
     }
 }
コード例 #2
0
 public void InitData()
 {
     if (pack_asset && (pack_player == null))
     {
         var pack_loader = pack_asset.GetCreaturePackLoader();
         pack_player = new CreaturePackPlayer(pack_loader);
         pack_player.setActiveAnimation(active_animation_name);
     }
 }
コード例 #3
0
    public bool buildSkinSwapIndices(
        String swap_name,
        uint[] src_indices,
        List <int> skin_swap_indices,
        CreaturePackPlayer pack_player
        )
    {
        // Generate sorted names in mesh drawing order
        if (mesh_sorted_names.Count == 0)
        {
            genSortedMeshNames(pack_player);
        }

        // Now Generate Skin Swap indices
        if (!skin_swaps.ContainsKey(swap_name))
        {
            skin_swap_indices.Clear();
            return(false);
        }

        var swap_set = skin_swaps[swap_name];

        active_skin_swap_names.Clear();
        int total_size = 0;

        foreach (var cur_data in mesh_map)
        {
            var cur_name = cur_data.Key;
            if (swap_set.Contains(cur_name))
            {
                total_size += getNumMeshIndices(cur_name);
                active_skin_swap_names.Add(cur_name);
            }
        }

        skin_swap_indices.Clear();

        int offset = 0;

        foreach (var region_name in mesh_sorted_names)
        {
            if (swap_set.Contains(region_name))
            {
                var num_indices = getNumMeshIndices(region_name);
                var cur_range   = mesh_map[region_name];
                for (int j = 0; j < getNumMeshIndices(region_name); j++)
                {
                    var local_idx = cur_range.Item1 + j;
                    skin_swap_indices.Add((int)src_indices[local_idx]);
                }

                offset += num_indices;
            }
        }

        return(true);
    }
コード例 #4
0
    // Switches the animation to a new composite clip given its name
    public void setActiveName(string name_in, bool force_reset, CreaturePackPlayer pack_player)
    {
        if ((active_name == name_in) && (force_reset == false))
        {
            return;
        }

        active_name = name_in;
        active_idx  = 0;

        if (composite_clips.ContainsKey(active_name))
        {
            setupForSubClip(pack_player, active_idx, active_name);
        }
    }
コード例 #5
0
    // Update the composite clip animation step
    public void update(float delta_step, CreaturePackPlayer pack_player, bool should_loop)
    {
        var sublist  = composite_clips[active_name];
        var pre_time = pack_player.getRunTime("");

        if (!should_loop)
        {
            if ((pre_time >= sublist[active_idx].end_frame) &&
                (active_idx >= (sublist.Count - 1)))
            {
                return;
            }
        }

        pack_player.isLooping = true;
        pack_player.isPlaying = true;
        pack_player.stepTime(delta_step);

        var post_time = pack_player.getRunTime("");

        if ((post_time < pre_time) || (post_time > sublist[active_idx].end_frame))
        {
            var  old_idx         = active_idx;
            var  new_idx         = (active_idx + 1) % sublist.Count;
            bool advance_to_next = true;
            if (!should_loop && (new_idx <= old_idx))
            {
                advance_to_next = false;
            }

            if (advance_to_next)
            {
                active_idx = new_idx;
                setupForSubClip(pack_player, active_idx, active_name);
            }
            else
            {
                pack_player.setRunTime(sublist[active_idx].end_frame, "");
            }
        }
    }
コード例 #6
0
    public void InitData()
    {
        if (pack_asset && (pack_player == null))
        {
            var pack_loader = pack_asset.GetCreaturePackLoader();
            pack_player = new CreaturePackPlayer(pack_loader);
            pack_player.setActiveAnimation(active_animation_name);
        }

        if (pack_asset != null && pack_player != null)
        {
            if (use_anchor_pts || use_composite_clips || use_skin_swap || use_meta_data)
            {
                pack_asset.LoadMetaData();
                if (pack_asset.composite_player != null)
                {
                    pack_asset.composite_player.setActiveName(composite_anim, true, pack_player);
                }
            }
        }
    }
コード例 #7
0
    private void genSortedMeshNames(CreaturePackPlayer pack_player)
    {
        mesh_sorted_names.Clear();
        foreach (var meshData in pack_player.data.meshRegionsList)
        {
            foreach (var cmpMeshData in mesh_map)
            {
                uint cmpMinIdx = (uint)pack_player.data.points.Length, cmpMaxIdx = 0;
                for (int k = cmpMeshData.Value.Item1; k <= cmpMeshData.Value.Item2; k++)
                {
                    var cur_idx = pack_player.data.indices[k];
                    cmpMinIdx = Math.Min(cmpMinIdx, cur_idx);
                    cmpMaxIdx = Math.Max(cmpMaxIdx, cur_idx);
                }

                if ((meshData.first == cmpMinIdx) &&
                    (meshData.second == cmpMaxIdx))
                {
                    mesh_sorted_names.Add(cmpMeshData.Key);
                }
            }
        }
    }
コード例 #8
0
 public void InitData()
 {
     if(pack_asset)
     {
         var pack_loader = pack_asset.GetCreaturePackLoader();
         pack_player = new CreaturePackPlayer(pack_loader);
         pack_player.setActiveAnimation(active_animation_name);
     }
 }