/// output: a new motion primitive
void BVHMotionDatabaseCompiler::CreateMotionPrimitive( MotionPrimitiveDesc& desc,
const MotionPrimitiveDescGroup& desc_group,
BVHPlayer& bvh_player )
{
vector<Keyframe> vecKeyframe;
vecKeyframe.reserve( 64 );
// add a new motion primitive and get the reference to it
shared_ptr<MotionPrimitive> pMotion( new MotionPrimitive( desc.m_Name ) );
m_pvecpMotionPrimitive->push_back( pMotion );
desc.m_pMotionPrimitive = pMotion;
MotionPrimitive& motion = *(m_pvecpMotionPrimitive->back());
motion.SetSkeleton( desc_group.m_Skeleton );
motion.SetLoopedMotion( desc.m_bIsLoopMotion );
motion.SetStartsBoneName( desc.m_StartBoneName );
vecKeyframe.resize(0);
int i = 0;
int frame = 0;
int start = desc.m_StartFrame;
int end = desc.m_EndFrame;
float time_per_frame = bvh_player.GetFrameTime();
// create keyframes
for( frame = start, i=0;
frame <= end;
frame++, i++ )
{
float frame_time = (float)frame * time_per_frame;
bvh_player.SetWorldTransformation( frame_time );
// extract world transforms
BVHBone *pRootBone = bvh_player.GetRootBone();
// create keyframe from frametime and transformation hierarchy
vecKeyframe.push_back( Keyframe( (float)i * time_per_frame, TransformNode( *pRootBone ) ) );
}
// modify root position
if( 0 < vecKeyframe.size() && desc.m_bResetHorizontalRootPos )
{
Matrix34 root_pose = vecKeyframe[0].GetRootPose();
Vector3 vBasePosH = root_pose.vPosition;
vBasePosH.y = 0;
BOOST_FOREACH( Keyframe& keyframe, vecKeyframe )
{
root_pose = keyframe.GetRootPose();
root_pose.vPosition = root_pose.vPosition - vBasePosH;
keyframe.SetRootPose( root_pose );
}
void CCharShape::AdjustOrientation (CControl *ctrl, double dtime,
double dist_from_surface, TVector3 surf_nml) {
TVector3 new_x, new_y, new_z;
TMatrix cob_mat, inv_cob_mat;
TMatrix rot_mat;
TQuaternion new_orient;
double time_constant;
static TVector3 minus_z_vec = { 0, 0, -1};
static TVector3 y_vec = { 0, 1, 0 };
if (dist_from_surface > 0) {
new_y = ScaleVector (1, ctrl->cvel);
NormVector (&new_y);
new_z = ProjectToPlane (new_y, MakeVector(0, -1, 0));
NormVector (&new_z);
new_z = AdjustRollvector (ctrl, ctrl->cvel, new_z);
} else {
new_z = ScaleVector (-1, surf_nml);
new_z = AdjustRollvector (ctrl, ctrl->cvel, new_z);
new_y = ProjectToPlane (surf_nml, ScaleVector (1, ctrl->cvel));
NormVector(&new_y);
}
new_x = CrossProduct (new_y, new_z);
MakeBasismatrix_Inv (cob_mat, inv_cob_mat, new_x, new_y, new_z);
new_orient = MakeQuaternionFromMatrix (cob_mat);
if (!ctrl->orientation_initialized) {
ctrl->orientation_initialized = true;
ctrl->corientation = new_orient;
}
time_constant = dist_from_surface > 0 ? TO_AIR_TIME : TO_TIME;
ctrl->corientation = InterpolateQuaternions (
ctrl->corientation, new_orient,
min (dtime / time_constant, 1.0));
ctrl->plane_nml = RotateVector (ctrl->corientation, minus_z_vec);
ctrl->cdirection = RotateVector (ctrl->corientation, y_vec);
MakeMatrixFromQuaternion (cob_mat, ctrl->corientation);
// Trick rotations
new_y = MakeVector (cob_mat[1][0], cob_mat[1][1], cob_mat[1][2]);
RotateAboutVectorMatrix (rot_mat, new_y, (ctrl->roll_factor * 360));
MultiplyMatrices (cob_mat, rot_mat, cob_mat);
new_x = MakeVector (cob_mat[0][0], cob_mat[0][1], cob_mat[0][2]);
RotateAboutVectorMatrix (rot_mat, new_x, ctrl->flip_factor * 360);
MultiplyMatrices (cob_mat, rot_mat, cob_mat);
TransposeMatrix (cob_mat, inv_cob_mat);
TransformNode (0, cob_mat, inv_cob_mat);
}
void CCharShape::AdjustOrientation (CControl *ctrl, bool eps,
ETR_DOUBLE dist_from_surface, const TVector3d& surf_nml) {
TVector3d new_y, new_z;
static const TVector3d minus_z_vec(0, 0, -1);
static const TVector3d y_vec(0, 1, 0);
if (dist_from_surface > 0) {
new_y = ctrl->cvel;
new_y.Norm();
new_z = ProjectToPlane (new_y, TVector3d(0, -1, 0));
new_z.Norm();
new_z = AdjustRollvector (ctrl, ctrl->cvel, new_z);
} else {
new_z = -1.0 * surf_nml;
new_z = AdjustRollvector (ctrl, ctrl->cvel, new_z);
new_y = ProjectToPlane (surf_nml, ctrl->cvel);
new_y.Norm();
}
TVector3d new_x = CrossProduct (new_y, new_z);
TMatrix<4, 4> cob_mat(new_x, new_y, new_z);
TQuaternion new_orient = MakeQuaternionFromMatrix (cob_mat);
if (!ctrl->orientation_initialized) {
ctrl->orientation_initialized = true;
ctrl->corientation = new_orient;
}
ETR_DOUBLE time_constant = dist_from_surface > 0 ? TO_AIR_TIME : TO_TIME;
float dtime = eps ? EPS : g_game.time_step;
ctrl->corientation = InterpolateQuaternions (
ctrl->corientation, new_orient,
min (dtime / time_constant, 1.0));
ctrl->plane_nml = RotateVector (ctrl->corientation, minus_z_vec);
ctrl->cdirection = RotateVector (ctrl->corientation, y_vec);
cob_mat = MakeMatrixFromQuaternion(ctrl->corientation);
// Trick rotations
new_y = TVector3d (cob_mat[1][0], cob_mat[1][1], cob_mat[1][2]);
TMatrix<4, 4> rot_mat = RotateAboutVectorMatrix(new_y, (ctrl->roll_factor * 360));
cob_mat = rot_mat * cob_mat;
new_x = TVector3d (cob_mat[0][0], cob_mat[0][1], cob_mat[0][2]);
rot_mat = RotateAboutVectorMatrix (new_x, ctrl->flip_factor * 360);
cob_mat = rot_mat * cob_mat;
TransformNode (0, cob_mat, cob_mat.GetTransposed());
}
DisplayItemTransformTree::DisplayItemTransformTree()
{
// There is always a root node.
m_nodes.append(TransformNode(kInvalidIndex, SkMatrix44::kIdentity_Constructor));
ASSERT(m_nodes[0].isRoot());
}
/*
int MshExp::ExportMeshTiles(Interface* ip,INode* node,TimeValue t_start,TimeValue t_end,int tiles_count)
{
// Get animation range
Interval animRange = ip->GetAnimRange();
TimeValue curtime;
curtime = animRange.Start();
}
*/
int MshExp::ExportMesh(const TCHAR *filename,Interface* i,INode* node,TimeValue curtime)
{
char buf[4096];
void* cur=buf;
void* end=buf+sizeof(buf);
// Verifie les arguments
if(node==0){
NP_LOG("ExportMesh: !node");
return 0;
}
/*-----------------------------------------------------
Obtient l'objet Mesh
-----------------------------------------------------*/
// Frame a exporter
if(curtime<0)
curtime = i->GetTime();
// Obtient la matrice de transformation
Matrix3 tm = TransformNode(node,curtime,this->exportTransform);
// Evalue l'objet a partir du noeud
ObjectState os = node->EvalWorldState(curtime);
if(!os.obj || os.obj->SuperClassID()!=GEOMOBJECT_CLASS_ID){
NP_LOG("ExportMesh: !ObjectState");
return 0;
}
Interval objRange = os.obj->ObjectValidity(curtime);
// convertie l'objet en Tiangles
BOOL needDel;
TriObject* tri = GetTriObjectFromNode(node, curtime, needDel);
if (!tri) {
NP_LOG("ExportMesh: !TriObject");
return 0;
}
// obtient le maillage
Mesh* mesh = &tri->GetMesh();
// obtient le nombre de points
uint npoint=(uint)mesh->getNumVerts();
// construit les normals
mesh->buildNormals();
// obtient le nombre de faces
uint nfaces=(uint)mesh->getNumFaces();
//Supprime l'objet TriObject, si necessaire
if(needDel) {
delete tri;
}
/*-----------------------------------------------------
Exporte les triangles
-----------------------------------------------------*/
//Obtient la matrice de transformation
tm = TransformNode(node,curtime,this->exportTransform);
// Evalue l'objet a partir du node
os = node->EvalWorldState(curtime);
objRange = os.obj->ObjectValidity(curtime);
// convertie l'objet en Tiangles
tri = GetTriObjectFromNode(node, curtime, needDel);
if (!tri) {
NP_LOG("ExportMesh: !TriObject");
return 0;
}
// obtient le maillage
mesh = &tri->GetMesh();
// construit les normals
mesh->buildNormals();
// copie les faces
for(uint y=0; y<nfaces; y++)
{
Face* face;
uint facenumber=0;//numero de la face dans l'index du maillage 3DS
//obtient la face en cours
face = &mesh->faces[y];
facenumber = y;
//////////////////////////////////////////////
// Definit les 3 points de la face
//////////////////////////////////////////////
for(uint w=0;w<3;w++)
{
if((cur = descWriteText(cur,end,"point")==0)
return 0;
Point3 pos;
Point3 nml;
Point3 clr;
UVVert tex;
uint nvertex;
// obtient le point
nvertex = face->v[w];
pos = tm * mesh->verts[nvertex];
float point[3]={pos.x,pos.y,pos.z};
if((cur = descWriteStruct(cur,end,Point3_t,sizeof(Point3_t)/sizeof(Point3_t[0]),&point))==0)
return 0;
// obtient les normals
nvertex = face->getVert(w);
nml = GetVertexNormal(mesh, face, mesh->getRVertPtr(nvertex));
float normal[3]={nml.x,nml.y,nml.z};
if((cur = descWriteStruct(cur,end,Normal_t,sizeof(Normal_t)/sizeof(Normal_t[0]),&normal))==0)
return 0;
// obtient les coordonnees de texture
if(mesh->tvFace){
nvertex = mesh->tvFace[facenumber].t[w];
tex = mesh->tVerts[nvertex];
float textureMap[3]={tex.x,tex.y,tex.z};
if((cur = descWriteStruct(cur,end,TextureMap_t,sizeof(TextureMap_t)/sizeof(TextureMap_t[0]),&textureMap))==0)
return 0;
}
// obtient la couleur
if(mesh->vcFace){
nvertex = mesh->vcFace[facenumber].t[w];
clr = mesh->vertCol[nvertex];
float color[3]={clr.x,clr.y,clr.z};
if((cur = descWriteStruct(cur,end,Color_t,sizeof(Color_t)/sizeof(Color_t[0]),&color))==0)
return 0;
}
}
}
//Supprime l'objet TriObject, si necessaire
if(needDel) {
delete tri;
}
/* ecrit les donnees de la structure */
if(!fileWrite(filename,0,buf,(char*)cur))
return 0;
NP_LOG("done");
return 1;
}