1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
|
/*
* ***** BEGIN GPL LICENSE BLOCK *****
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software Foundation,
* Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*
* The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
* All rights reserved.
*
* The Original Code is: all of this file.
*
* Contributor(s): none yet.
*
* ***** END GPL LICENSE BLOCK *****
*/
/** \file BL_ArmatureObject.h
* \ingroup bgeconv
*/
#ifndef __BL_ARMATUREOBJECT_H__
#define __BL_ARMATUREOBJECT_H__
#include "KX_GameObject.h"
#include "BL_ArmatureConstraint.h"
#include "BL_ArmatureChannel.h"
#include "SG_IObject.h"
#include <vector>
#include <algorithm>
struct bArmature;
struct Bone;
struct bConstraint;
class BL_ActionActuator;
class BL_ArmatureActuator;
class MT_Matrix4x4;
struct Object;
class KX_BlenderSceneConverter;
class BL_ArmatureObject : public KX_GameObject
{
Py_Header
public:
double GetLastFrame ();
virtual void ProcessReplica();
virtual void ReParentLogic();
virtual void Relink(CTR_Map<CTR_HashedPtr, void*> *obj_map);
virtual bool UnlinkObject(SCA_IObject* clientobj);
BL_ArmatureObject(
void* sgReplicationInfo,
SG_Callbacks callbacks,
Object *armature,
Scene *scene,
int vert_deform_type
);
virtual ~BL_ArmatureObject();
virtual CValue* GetReplica();
void GetPose(struct bPose **pose);
void SetPose (struct bPose *pose);
struct bPose *GetOrigPose() {return m_pose;} // never edit this, only for accessing names
void ApplyPose();
void SetPoseByAction(struct bAction* action, float localtime);
void BlendInPose(struct bPose *blend_pose, float weight, short mode);
void RestorePose();
bool UpdateTimestep(double curtime);
struct bArmature *GetArmature() { return (bArmature*)m_objArma->data; }
const struct bArmature * GetArmature() const { return (bArmature*)m_objArma->data; }
const struct Scene * GetScene() const { return m_scene; }
Object* GetArmatureObject() {return m_objArma;}
Object* GetOrigArmatureObject() {return m_origObjArma;}
int GetVertDeformType() {return m_vert_deform_type;}
// for constraint python API
void LoadConstraints(KX_BlenderSceneConverter* converter);
size_t GetConstraintNumber() const { return m_constraintNumber; }
BL_ArmatureConstraint* GetConstraint(const char* posechannel, const char* constraint);
BL_ArmatureConstraint* GetConstraint(const char* posechannelconstraint);
BL_ArmatureConstraint* GetConstraint(int index);
// for pose channel python API
void LoadChannels();
size_t GetChannelNumber() const { return m_channelNumber; }
BL_ArmatureChannel* GetChannel(bPoseChannel* channel);
BL_ArmatureChannel* GetChannel(const char* channel);
BL_ArmatureChannel* GetChannel(int index);
/// Retrieve the pose matrix for the specified bone.
/// Returns true on success.
bool GetBoneMatrix(Bone* bone, MT_Matrix4x4& matrix);
/// Returns the bone length. The end of the bone is in the local y direction.
float GetBoneLength(Bone* bone) const;
virtual int GetGameObjectType() { return OBJ_ARMATURE; }
#ifdef WITH_PYTHON
// PYTHON
static PyObject *pyattr_get_constraints(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef);
static PyObject *pyattr_get_channels(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef);
KX_PYMETHOD_DOC_NOARGS(BL_ArmatureObject, update);
#endif /* WITH_PYTHON */
protected:
/* list element: BL_ArmatureConstraint. Use SG_DListHead to have automatic list replication */
SG_DListHead<BL_ArmatureConstraint> m_controlledConstraints;
/* list element: BL_ArmatureChannel. Use SG_DList to avoid list replication */
SG_DList m_poseChannels;
Object *m_objArma;
Object *m_origObjArma;
struct bPose *m_pose;
struct bPose *m_armpose;
struct Scene *m_scene; // need for BKE_pose_where_is
double m_lastframe;
double m_timestep; // delta since last pose evaluation.
int m_vert_deform_type;
size_t m_constraintNumber;
size_t m_channelNumber;
// store the original armature object matrix
float m_obmat[4][4];
double m_lastapplyframe;
};
#endif /* __BL_ARMATUREOBJECT_H__ */
|
