///--------------------------------------------------------------------------------------
        /// <summary>
        /// Отрисовка: skeleton_robot
        /// </summary>
        public void render(ASpriteBatch spriteBatch, Vector2 posCenter)
        {
            TNode   nd_robot_tors = joint_root + m_robot_tors.rootNode();
            Vector2 vt_robot_tors = new Vector2(nd_robot_tors.x, nd_robot_tors.y) + posCenter;
            float   ra_robot_tors = nd_robot_tors.angle;
            Matrix  mx_robot_tors = Matrix.CreateRotationZ(ra_robot_tors);
 
 
            //joint_hand_left
            if (m_robot_hand_left != null)
            {
                TNode   nd_robot_hand_left = joint_hand_left +  m_robot_tors.node(ENodesName.hand_left);
                Vector2 vt_robot_hand_left = Vector2.Transform(new Vector2(nd_robot_hand_left.x, nd_robot_hand_left.y), mx_robot_tors) + vt_robot_tors;
                float   ra_robot_hand_left = nd_robot_hand_left.angle + ra_robot_tors;
                Matrix  mx_robot_hand_left = Matrix.CreateRotationZ(ra_robot_hand_left);
                m_robot_hand_left.render(spriteBatch, vt_robot_hand_left, ra_robot_hand_left);
            }
 
            //joint_hand_right
            if (m_robot_hand_right != null)
            {
                TNode   nd_robot_hand_right = joint_hand_right +  m_robot_tors.node(ENodesName.hand_right);
                Vector2 vt_robot_hand_right = Vector2.Transform(new Vector2(nd_robot_hand_right.x, nd_robot_hand_right.y), mx_robot_tors) + vt_robot_tors;
                float   ra_robot_hand_right = nd_robot_hand_right.angle + ra_robot_tors;
                Matrix  mx_robot_hand_right = Matrix.CreateRotationZ(ra_robot_hand_right);
                m_robot_hand_right.render(spriteBatch, vt_robot_hand_right, ra_robot_hand_right);
            }
 
            //joint_leg_left
            if (m_robot_leg_left != null)
            {
                TNode   nd_robot_leg_left = joint_leg_left +  m_robot_tors.node(ENodesName.leg_left);
                Vector2 vt_robot_leg_left = Vector2.Transform(new Vector2(nd_robot_leg_left.x, nd_robot_leg_left.y), mx_robot_tors) + vt_robot_tors;
                float   ra_robot_leg_left = nd_robot_leg_left.angle + ra_robot_tors;
                Matrix  mx_robot_leg_left = Matrix.CreateRotationZ(ra_robot_leg_left);
                m_robot_leg_left.render(spriteBatch, vt_robot_leg_left, ra_robot_leg_left);
            }
 
            //joint_leg_right
            if (m_robot_leg_right != null)
            {
                TNode   nd_robot_leg_right = joint_leg_right +  m_robot_tors.node(ENodesName.leg_right);
                Vector2 vt_robot_leg_right = Vector2.Transform(new Vector2(nd_robot_leg_right.x, nd_robot_leg_right.y), mx_robot_tors) + vt_robot_tors;
                float   ra_robot_leg_right = nd_robot_leg_right.angle + ra_robot_tors;
                Matrix  mx_robot_leg_right = Matrix.CreateRotationZ(ra_robot_leg_right);
                m_robot_leg_right.render(spriteBatch, vt_robot_leg_right, ra_robot_leg_right);
            }
 
            m_robot_tors.render(spriteBatch, posCenter + new Vector2(joint_root.x, joint_root.y), joint_root.angle);
 
 
            //joint_head
            if (m_robot_head != null)
            {
                TNode   nd_robot_head = joint_head +  m_robot_tors.node(ENodesName.head);
                Vector2 vt_robot_head = Vector2.Transform(new Vector2(nd_robot_head.x, nd_robot_head.y), mx_robot_tors) + vt_robot_tors;
                float   ra_robot_head = nd_robot_head.angle + ra_robot_tors;
                Matrix  mx_robot_head = Matrix.CreateRotationZ(ra_robot_head);
                m_robot_head.render(spriteBatch, vt_robot_head, ra_robot_head);
            }
        }
 
Добавлено за 0.023 секунд, используя GeSHi 1.0.8.2

[Bone:Head]
[Time0][Matrix[]]
[Time1][Matrix[]]
[Bone:Leg]
[Time0][Matrix[]]
/*И т.д.*/
Добавлено за 0.004 секунд, используя GeSHi 1.0.8.2

 
public struct AtlasTexture
    {
        public string AtlasName; //Атлас-родитель
        public string Name;//Имя текстуры или frm#. frm# - разрешает использовать атлас в качестве источника кадров для анимации.
        public Rectangle Rectangle;
        public int Width { get { return Rectangle.Width; } }
        public int Height { get { return Rectangle.Height; } }
        public AtlasTexture(string aname, string tname, Rectangle rect)
        {
            AtlasName = aname;
            Name = tname;
            Rectangle = rect;
        }
    }
 
Добавлено за 0.006 секунд, используя GeSHi 1.0.8.2