//----------------------------------------------------------------------------
Node* SkinnedBiped::GetNode (const std::string& name)
{
Node* node = new0 Node();
node->SetName(name);
// Load the keyframe controller.
std::string filename = name + ".keyf.raw";
std::string path = Environment::GetPathR(filename);
FileIO inFile(path, FileIO::FM_DEFAULT_READ);
int repeat;
float minTime, maxTime, phase, frequency;
inFile.Read(sizeof(float), &repeat);
inFile.Read(sizeof(float), &minTime);
inFile.Read(sizeof(float), &maxTime);
inFile.Read(sizeof(float), &phase);
inFile.Read(sizeof(float), &frequency);
int numTranslations, numRotations, numScales;
inFile.Read(sizeof(int), &numTranslations);
inFile.Read(sizeof(int), &numRotations);
inFile.Read(sizeof(int), &numScales);
KeyframeController* ctrl = new0 KeyframeController(0, numTranslations,
numRotations, numScales, Transform::IDENTITY);
ctrl->Repeat = (Controller::RepeatType)repeat;
ctrl->MinTime = (double)minTime;
ctrl->MaxTime = (double)maxTime;
ctrl->Phase = (double)phase;
ctrl->Frequency = (double)frequency;
if (numTranslations > 0)
{
float* translationTimes = ctrl->GetTranslationTimes();
APoint* translations = ctrl->GetTranslations();
inFile.Read(sizeof(float), numTranslations, translationTimes);
for (int i = 0; i < numTranslations; ++i)
{
inFile.Read(sizeof(float), 3, &translations[i]);
translations[i][3] = 1.0f;
}
}
else
{
APoint translate;
inFile.Read(sizeof(float), 3, &translate);
node->LocalTransform.SetTranslate(translate);
}
if (numRotations > 0)
{
float* rotationTimes = ctrl->GetRotationTimes();
HQuaternion* rotations = ctrl->GetRotations();
inFile.Read(sizeof(float), numRotations, rotationTimes);
inFile.Read(sizeof(float), 4*numRotations, rotations);
}
else
{
float entry[9];
inFile.Read(sizeof(float), 9, entry);
HMatrix rotate(
entry[0], entry[1], entry[2], 0.0f,
entry[3], entry[4], entry[5], 0.0f,
entry[6], entry[7], entry[8], 0.0f,
0.0f, 0.0f, 0.0f, 1.0f);
node->LocalTransform.SetRotate(rotate);
}
if (numScales > 0)
{
float* scaleTimes = ctrl->GetScaleTimes();
float* scales = ctrl->GetScales();
inFile.Read(sizeof(float), numScales, scaleTimes);
inFile.Read(sizeof(float), numScales, scales);
}
else
{
float scale;
inFile.Read(sizeof(float), &scale);
node->LocalTransform.SetUniformScale(scale);
}
ctrl->SetTransform(node->LocalTransform);
inFile.Close();
node->AttachController(ctrl);
return node;
}
TransformController* BipedManager::LoadTransformController(
std::string const& rootPath, std::string const& name,
std::string const& animation)
{
std::string filename = rootPath + "Animations/" + animation + "/" +
name + ".xfrmctrl.raw";
std::ifstream input(filename, std::ios::in | std::ios::binary);
int isKeyframeController;
input.read((char*)&isKeyframeController, sizeof(isKeyframeController));
TransformController* ctrl;
int repeatType, active;
double minTime, maxTime, phase, frequency;
input.read((char*)&repeatType, sizeof(repeatType));
input.read((char*)&minTime, sizeof(minTime));
input.read((char*)&maxTime, sizeof(maxTime));
input.read((char*)&phase, sizeof(phase));
input.read((char*)&frequency, sizeof(frequency));
input.read((char*)&active, sizeof(active));
float mat[9], trn[3], sca[3];
char isIdentity, isRSMatrix, isUniformScale, dummy;
input.read((char*)mat, 9 * sizeof(float));
input.read((char*)trn, 3 * sizeof(float));
input.read((char*)sca, 3 * sizeof(float));
input.read((char*)&isIdentity, sizeof(isIdentity));
input.read((char*)&isRSMatrix, sizeof(isRSMatrix));
input.read((char*)&isUniformScale, sizeof(isUniformScale));
input.read((char*)&dummy, sizeof(dummy));
Transform localTransform;
localTransform.SetTranslation(trn[0], trn[1], trn[2]);
if (isUniformScale)
{
localTransform.SetUniformScale(sca[0]);
}
else
{
localTransform.SetScale(sca[0], sca[1], sca[2]);
}
#if defined(GTE_USE_MAT_VEC)
if (isRSMatrix)
{
localTransform.SetRotation(Matrix4x4<float>({
mat[0], mat[1], mat[2], 0.0f,
mat[3], mat[4], mat[5], 0.0f,
mat[6], mat[7], mat[8], 0.0f,
0.0f, 0.0f, 0.0f, 1.0f }));
}
else
{
localTransform.SetMatrix(Matrix4x4<float>({
mat[0], mat[1], mat[2], 0.0f,
mat[3], mat[4], mat[5], 0.0f,
mat[6], mat[7], mat[8], 0.0f,
0.0f, 0.0f, 0.0f, 1.0f }));
}
#else
if (isRSMatrix)
{
localTransform.SetRotation(Matrix4x4<float>({
mat[0], mat[3], mat[6], 0.0f,
mat[1], mat[4], mat[7], 0.0f,
mat[2], mat[5], mat[8], 0.0f,
0.0f, 0.0f, 0.0f, 1.0f }));
}
else
{
localTransform.SetMatrix(Matrix4x4<float>({
mat[0], mat[3], mat[6], 0.0f,
mat[1], mat[4], mat[7], 0.0f,
mat[2], mat[5], mat[8], 0.0f,
0.0f, 0.0f, 0.0f, 1.0f }));
}
#endif
if (isKeyframeController)
{
int numTranslations, numRotations, numScales;
input.read((char*)&numTranslations, sizeof(numTranslations));
input.read((char*)&numRotations, sizeof(numRotations));
input.read((char*)&numScales, sizeof(numScales));
KeyframeController* keyfctrl = new KeyframeController(0,
numTranslations, numRotations, numScales, localTransform);
if (numTranslations > 0)
{
input.read((char*)keyfctrl->GetTranslationTimes(),
sizeof(float) * numTranslations);
input.read((char*)keyfctrl->GetTranslations(),
sizeof(Vector4<float>) * numTranslations);
}
if (numRotations > 0)
{
input.read((char*)keyfctrl->GetRotationTimes(),
sizeof(float) * numRotations);
input.read((char*)keyfctrl->GetRotations(),
sizeof(Quaternion<float>) * numRotations);
}
if (numScales > 0)
{
input.read((char*)keyfctrl->GetScaleTimes(),
sizeof(float) * numScales);
input.read((char*)keyfctrl->GetScales(),
sizeof(float) * numScales);
}
ctrl = keyfctrl;
}
else
{
// The adjustment to the "Biped" root node is an attempt to get the
// biped to idle/walk/run on a floor at height zero. The biped model
// should have minimally been created so that the foot steps occur at
// the same height for all animations.
if (name == "Biped")
{
Vector3<float> translate = localTransform.GetTranslation();
if (animation == "Idle")
{
translate[2] += 3.5f;
}
else if (animation == "Walk")
{
translate[2] += 2.0f;
}
else // animation == "Run"
{
translate[2] += 2.5f;
}
localTransform.SetTranslation(translate);
}
TransformController* xfrmctrl =
new TransformController(localTransform);
ctrl = xfrmctrl;
}
ctrl->name = name;
ctrl->repeat = Controller::RT_WRAP;
ctrl->minTime = minTime;
ctrl->maxTime = maxTime;
ctrl->phase = phase;
ctrl->frequency = frequency;
ctrl->active = (active > 0);
input.close();
return ctrl;
}
