~cpp
// static function
/*
Func - LoadAse
Desc - μ§μ λ Ase νμΌμ μ½μ΄λ€μ΄κ³ κ·Έ νμΌμ μλ μ’νκ³μμΌλ‘ μ μ₯λ μ μ λ€μ λ‘컬 μ’νκ³λ‘ λ³ννλ©°
κ° λ
Έλλ§λ€ μμ μ μμ λ
Έλμ μ’νκ³μ κΈ°μ€ν΄μ μμ μ μ’νκ³λ‘ μ΄λμμΌμ£Όλ λ©νΈλ¦μ€λ₯Ό μμ±νλ€.( -> AniTM)
*/
bool CHS_GObject::LoadAse (char* filename)
{
FILE *s;
DWORD max_time = 0;
bool bResult;
if (!(s = fopen (filename, "r"))) {
char ds[255];
sprintf (ds, "# %s not found\n", filename);
OutputDebugString (ds);
return false;
}
else
bResult = GetAseAllInfo (s);
// 0λ² λͺ¨λΈμ μ€ν€λ ν΅μ§ λͺ¨λΈμ΄λΌ κ°μ
pNodeList [0]->bIsSkinModel = TRUE;
// λͺ¨λΈμ λ©λͺ¨λ¦¬ ν λΉ.
for (int i=0; i<nNodeNum; i++)
{
//pNodeList [i]->ModelAlloc ();
aseAllocate2CHS_Model (pNodeList [i]);
}
// νμ΄μ΄λΌν€ μ 보 μμ± -----------------------------------------------
// : λ£¨νΈ λ¦¬μ€νΈμ νΈλ¦¬ ꡬ쑰λ‘μ΄λ£¨μ΄μ§ λͺ¨λΈλ€μ λ§ν¬ νλ€.
for (int i1=0; i1<nNodeNum; i1++)
{
if (strcmp (pNodeList [i1]->ParentName, "")) {
for (int i2=0; i2<nNodeNum; i2++)
{
if (pNodeList [i1] != pNodeList [i2] &&
!strcmp (pNodeList [i1]->ParentName, pNodeList [i2]->Name))
{
pNodeList [i1]->SetParent (pNodeList [i2]); // μμμκ² λΆλͺ¨κ° λꡬμΈμ§ μ§μ
pNodeList [i2]->AddChildNum (); // λΆλͺ¨μ μμμ μΉ΄μ΄νΈλ₯Ό 1 λλ¦Ό
CHS_Model** pChildTmp = pNodeList [i2]->GetChildPointer (); // μμ 보κ΄
CHS_Model** pDest = new CHS_Model* [pNodeList [i2]->GetChildNum ()]; // μ λ©λͺ¨λ¦¬ ν λΉ
memcpy (pDest, pChildTmp, sizeof (CHS_Model*) * (pNodeList [i2]->GetChildNum ()-1)); // 볡μ¬
pDest[pNodeList [i2]->GetChildNum ()-1] = pNodeList [i1]; // λΆλͺ¨μκ² μΆκ°λ μ μμ μ μ₯
pNodeList [i2]->SetChildPointer (pDest); // μ λ©λͺ¨λ¦¬λ₯Ό μμ ν¬μΈν°λ‘ μ§μ
delete [] pChildTmp; // μμ λ³΄κ΄ μ₯μ μμ
}
}
}
}
// μ μ λ°μ΄ν μ½κΈ° ---------------------------------------------------
CHS_GObject::GetAseAllData (s, &max_time);
// μ μ μ wcs -> lcsλ‘ λ³ν -------------------------------------------
// ani_tm μ΅μ΄ update -------------------------------------------------
for (i=0; i<nNodeNum; i++) {
pNodeList[i]->InitObject (0);
if (i!=0) pNodeList[i]->MulMatInverse (FALSE);
// pNodeList[i]->MulMatInverse (FALSE);
pNodeList[i]->UpdateAniTM (FALSE);
// BoundingVolumn κ³μ°
pNodeList[i]->CreateVolumn (pNodeList[i]->verts, pNodeList[i]->numVertex);
}
// ν
μ€μ³ λ°μ΄ν μ½κΈ° -------------------------------------------------
// : 미ꡬν
// λ£¨νΈ λ
Έλ 리μ€νΈ κ°±μ ----------------------------------------------
// : λ£¨νΈ λ
Έλλ§ κ°μ§κ³ μλ 리μ€νΈλ₯Ό λ§λ λ€.
// StlLink* pRL = &(s_RootList);
// for(StlListItor itorAll = pSL->begin (); itorAll!= pSL->end (); ++itorAll) {
for (i=0; i<nNodeNum; i++) {
CHS_Model* pTmp = pNodeList[i];
if (!strcmp(pTmp->ParentName, "")) {
//pRL->push_back ((void*)pTmp);
pTmp->SetTimeSkip (800);
pTmp->SetMaxTime (max_time);
pRootList [nRootNum] = pTmp;
nRootNum++;
char debug_buf[255];
sprintf (debug_buf,"\n#ROOT NODE: %s", pTmp->Name);
OutputDebugString (debug_buf);
}
}
fclose (s);
return true;
}
// static function
// ν½νΉμ μν΄ ν΄λ¦ λ μ μ μ’νλ₯Ό κ³μ°νλ€.
// μ
λ ₯κ°: λ§μ°μ€ ν΄λ¦λ ν¬μΈνΈ
void CHS_GObject::UpdatePickedPoint (int &cl_x, int &cl_y, int &width, int &height)
{
// μμ κ³μ°
PickedPoint [0][0] = float(cl_x)*2.0f/float(width) - 1.0f;
PickedPoint [0][1] = float(cl_y)*2.0f/float(height) - 1.0f;
PickedPoint [0][1] = -PickedPoint [0][1];
PickedPoint [0][2] = 5.0f;
mat44_t mat_mv, inv_mat_mv;
glGetFloatv (GL_PROJECTION_MATRIX, mat_mv);
matrix44_inverse (inv_mat_mv, mat_mv);
vectorCopy (PickedPoint[0], PickedPoint[1]);
PickedPoint[1][2] -= 10.0;
matrixMultiplyVector3 (inv_mat_mv, PickedPoint[0]);
matrixMultiplyVector3 (inv_mat_mv, PickedPoint[1]);
}
// static function
// s_AllListμμ λͺ¨λ λ
Έλλ₯Ό μμ νλ€.
void CHS_GObject::ReleaseModels ()
{
/*
StlLink* pSL = &(CHS_GObject::s_AllList);
for(StlListItor itor=pSL->begin (); itor!=pSL->end ();++itor) {
delete (*itor);
itor = pSL->erase(itor);
}
*/
for (int i=0; i<nNodeNum; i++)
{
delete pNodeList[i];
}
}
// static function
bool CHS_GObject::GetAseAllInfo (FILE *s)
{
char data[255];
rewind (s); //νμΌν¬μΈν°λ₯Ό 맨 μμΌλ‘..
CHS_Model* pM;
while (!feof (s)) //νμΌ μ€νΈλ¦Όμ΄ λλ¬λμ§ check!
{
fscanf (s, "%s", &data);
if (!strcmp (data, OBJECT_BEGIN))
{
pM = new CHS_Model;
//pLink->AddTail(pModel);
//CHS_GObject::s_AllList.push_back ((void*)pM);
pNodeList [nNodeNum] = pM;
nNodeNum++;
}
else if (!strcmp (data, OBJECT_NAME))
{ // μκΈ° λ
Έλ μ΄λ¦
char temp[128];
int c_index = 0;
while (fgetc (s) != '"') {}
while (1) {
temp [c_index++] = (char) fgetc (s);
if (temp [c_index-1] == '"') {
temp [c_index-1] = '\0';
break;
}
}
memcpy (pM->Name, temp, strlen(temp));
}
else if (!strcmp (data, OBJECT_PARENT))
{ // λΆλͺ¨ λ
Έλ μ΄λ¦
char temp[128];
int c_index = 0;
while (fgetc (s) != '"') {}
while (1) {
temp [c_index++] = (char) fgetc (s);
if (temp [c_index-1] == '"') {
temp [c_index-1] = '\0';
break;
}
}
memcpy (pM->ParentName, temp, strlen(temp));
}
else if (!strcmp (data, OBJECT_POS))
{
// μΌλ°μ μΈ ascii export plug inμ μ¬μ©νμ κ²½μ°
// μ΄ pos κ°μ μλ μ’νλ‘ κ³μ°λμ΄ μ§λλ―ν¨. *MESHμ λ€μ΄μλ vertex μ’νλ€μ
// λͺ¨λ μλ μ’νλ€μ΄μμ΅λλ€. λͺ¨λΈ κ°κ°μ μμΉλ‘ Translate λ Rotateλ₯Ό
// ν νμλ μμμ.
fscanf (s, "%f %f %f", &pM->Pos[0]
, &pM->Pos[2]
, &pM->Pos[1]);
pM->Pos[2] = -pM->Pos[2];
}
else if (!strcmp (data, OBJECT_ROTAXIS))
{
fscanf (s, "%f %f %f", &pM->Axis[0]
, &pM->Axis[2]
, &pM->Axis[1]);
pM->Axis[2] = -pM->Axis[2];
}
else if (!strcmp (data, OBJECT_ROTANGLE)) {
vec_t x;
fscanf (s, "%f", &x);
// pM->Angle = -x;
pM->Angle = x;
matrix_t tmp_trans, tmp_rot;
matrixIdentity (tmp_trans);
matrixIdentity (tmp_rot);
matrixIdentity (pM->tm);
matrixTranslate (tmp_trans, pM->Pos);
AngleAxis2Matrix (tmp_rot, pM->Axis, pM->Angle);
matrixMultiply (tmp_rot, tmp_trans, pM->tm);
matrix44_inverse (pM->inv_tm, pM->tm);
}
else if (!strcmp (data, OBJECT_ROW0))
{
fscanf (s, "%f %f %f", &pM->tm[0]
, &pM->tm[2]
, &pM->tm[1]);
pM->tm[2] = -pM->tm[2];
pM->tm[3] = 0.0f;
}
else if (!strcmp (data, OBJECT_ROW1))
{
fscanf (s, "%f %f %f", &pM->tm[8]
, &pM->tm[10]
, &pM->tm[9]);
pM->tm[10] = -pM->tm[10];
pM->tm[11] = 0.0f;
}
else if (!strcmp (data, OBJECT_ROW2))
{
fscanf (s, "%f %f %f", &pM->tm[4]
, &pM->tm[6]
, &pM->tm[5]);
pM->tm[6] = -pM->tm[6];
pM->tm[7] = 0.0f;
}
else if (!strcmp (data, OBJECT_ROW3))
{
fscanf (s, "%f %f %f", &pM->tm[12]
, &pM->tm[14]
, &pM->tm[13]);
pM->tm[14] = -pM->tm[14];
pM->tm[15] = 1.0f;
// matrix44_inverse (pM->inv_tm, pM->tm);
}
else if (!strcmp (data, NUM_VERTEX))
fscanf (s, "%d", &pM->numVertex);
else if (!strcmp (data, NUM_FACES))
fscanf (s, "%d", &pM->numFaces);
else if (!strcmp (data, NUM_TVERTEX)) //texture mapped vertex?
{
fscanf (s, "%d", &pM->numTexVertex);
pM->bTexture_on = 1; //λ§μ½ ν
μ€μ³ λ²ν
μ€λ€μ΄ μ‘΄μ¬νλ€λ©΄ λͺ¨λΈκ°μ²΄μ ν
μ€μ³ νλκ·Έ μ¨
}
else if (!strcmp (data, NUM_TFACES)) //texture mapped face?
fscanf (s, "%d", &pM->numTexFaces);
else if (!strcmp (data, NUM_TEXTURE))
{
// μΌλ¨ ν
μ€μ³ μ 보 λΆλΆμ μμ
/*
int n = (int) aseGetFloatVal(s);
pTex = new char*[n]; //pTex λ μ΄μ€ ν¬μΈν°
app_con.numTex = n;
*/
}
else if (!strcmp (data, NORMALS))
pM->bNormals = true;
else if (!strcmp (data, TEXTURE))
{
// μΌλ¨ ν
μ€μ³ μ 보 λΆλΆμ μμ
/*
aseGetTextureName1 (s);
*/
}
else if (!strcmp (data, OBJECT_ANI))
{ // rotate sampleμ΄ μ‘΄μ¬ν¨μ νμ.
//pM->bRotKey = TRUE;
}
else if (!strcmp (data, OBJECT_ROT_EXIST))
{
pM->bRotKey = TRUE;
}
else if (!strcmp (data, OBJECT_POS_EXIST))
{
pM->bPosKey = TRUE;
}
else if (!strcmp (data, OBJECT_ROT_SAMPLE))
{
// pM->AddKeyNum (); // == pM->keyNum++
pM->rotkeyNum++;
}
else if (!strcmp (data, OBJECT_POS_SAMPLE))
{
pM->poskeyNum++;
}
else
fgets (data, sizeof (data), s);
}
// κ°κ°μ λ³Έμ ν λΉλλ PVμ κ°μ count
rewind (s);
while (!feof (s)) //νμΌ μ€νΈλ¦Όμ΄ λλ¬λμ§ check!
{
int x;
vec_t w;
char tmp_name[255];
char name[255];
fscanf (s, "%s", &data);
if (!strcmp (data, PV_NONBLEND)) {
fscanf (s, "%d ", &x);
int c_index = 0;
while (fgetc (s) != '"') {}
while (1) {
tmp_name [c_index++] = (char) fgetc (s);
if (tmp_name [c_index-1] == '"') {
tmp_name [c_index-1] = '\0';
break;
}
}
memcpy (name, tmp_name, strlen(tmp_name)+1);
for (int i=0;i<nNodeNum;i++) {
if (!strcmp (pNodeList [i]->Name, name))
pNodeList [i]->GetPSQInfo()->nPVertexCount++;
}
}
else if (!strcmp (data, PV_BLEND_ASSIGN)) {
fscanf (s, "%d %f ", &x, &w);
int c_index = 0;
while (fgetc (s) != '"') {}
while (1) {
tmp_name [c_index++] = (char) fgetc (s);
if (tmp_name [c_index-1] == '"') {
tmp_name [c_index-1] = '\0';
break;
}
}
memcpy (name, tmp_name, strlen(tmp_name)+1);
for (int i=0;i<nNodeNum;i++) {
if (!strcmp (pNodeList [i]->Name, name))
pNodeList [i]->GetPSQInfo()->nPVertexCount++;
}
}
else
fgets (data, sizeof (data), s);
}
// μ 체 ν€ μ€μ
for (int i=0;i<nNodeNum;i++) {
pNodeList [i]->SetKeyNum (1);
if (!pNodeList [i]->bPosKey)
pNodeList [i]->poskeyNum = 1;
if (!pNodeList [i]->bRotKey)
pNodeList [i]->rotkeyNum = 1;
if (pNodeList [i]->rotkeyNum > 1)
pNodeList [i]->SetKeyNum (pNodeList [i]->rotkeyNum);
if (pNodeList [i]->poskeyNum > pNodeList [i]->rotkeyNum)
pNodeList [i]->SetKeyNum (pNodeList [i]->poskeyNum);
}
return true;
}
// λͺ¨λΈμ λ©λͺ¨λ¦¬ ν λΉ.
void CHS_GObject::ModelAlloc (CHS_GObject* pO)
{
}
// static
vec_t CHS_GObject::GetFloatVal (FILE *s)
{
vec_t v;
fscanf (s, " %f", &v);
return v;
}
// λͺ¨λΈμ μ μ μ 보 μ
λ ₯
void CHS_GObject::GetAseAllData (FILE *s, DWORD *max_time)
{
char data[255];
int count = 0;
int pv_count[50] = {0,};
int nBlendAssignIndex;
CHS_Model* pM = 0;
// StlListItor itor = s_AllList.begin ();
// pM = (CHS_Model*)*itor;
pM = pNodeList[0];
rewind (s);
while (!feof (s))
{
fscanf (s, "%s", &data);
if (strcmp (data, OBJECT_BEGIN) == 0)
{
if (count == 0)
//itor = CHS_GObject::s_AllList.begin ();
pM = pNodeList [0];
else
//itor++;
pM = pNodeList [count];
count++;
//pM = (CHS_Model*)*itor;
}
else if (strcmp (data, VERTEX) == 0)
{
//CHS_GObject::GetVertex (s, pM);
int index;
fscanf (s, "%d", &index);
// swap y and z cause 3dsm likes too
fscanf (s, "%f %f %f",
&pM->verts[index][0],
&pM->verts[index][2],
&pM->verts[index][1]);
// in 3dsm negative z goes out of the screen, we want it to go in
pM->verts[index][2] = -(pM->verts[index][2]);
}
else if (strcmp (data, TVERTEX) == 0)
{
//CHS_GObject::GetTVertex (s, pM);
int index;
fscanf (s, "%d", &index);
fscanf (s, "%f %f", &pM->texVerts[index][0], &pM->texVerts[index][1]);
}
else if (strcmp (data, NVERTEX) == 0)
{
//CHS_GObject::GetNVertex (s, pM);
int index;
fscanf (s, "%d", &index);
fscanf (s, "%f %f %f",
&pM->vertNorms[index][0],
&pM->vertNorms[index][2],
&pM->vertNorms[index][1]);
pM->vertNorms[index][2] = -pM->vertNorms[index][2];
}
else if (strcmp (data, FACE_NORMAL) == 0)
{
//CHS_GObject::GetFaceNormal (s, pM);
int index;
fscanf (s, "%d", &index);
fscanf (s, "%f %f %f",
&pM->faces[index].normal[0],
&pM->faces[index].normal[2],
&pM->faces[index].normal[1]);
pM->faces[index].normal[2] = -pM->faces[index].normal[2];
}
else if (strcmp (data, FACE) == 0)
{
//CHS_GObject::GetFace (s, pM);
int index;
fscanf (s, "%d:", &index);
fscanf (s, "\tA:\t%d B:\t%d C:\t%d",
&pM->faces[index].vertIndex[0],
&pM->faces[index].vertIndex[1],
&pM->faces[index].vertIndex[2]);
/* &pM->faces[index].vertIndex[2],
&pM->faces[index].vertIndex[1]);*/
}
else if (strcmp (data, TFACE) == 0)
{
//CHS_GObject::GetTFace (s, pM);
int index;
fscanf (s, "%d:", &index);
fscanf (s, "%d %d %d",
&pM->faces[index].coordIndex[0],
&pM->faces[index].coordIndex[1],
&pM->faces[index].coordIndex[2]);
}
/*
else if (strcmp (data, TEXTURE) == 0)
{
aseGetTextureName (s, p); //λͺ¨λΈt ꡬ쑰체μ λ€μ΄κ°λ ν
μ€μ³ λ€μμ μ¬μ©x
//textureLink μ λ€κ±°λλ λ€μ μ¬μ©
}
*/
else if (!strcmp (data, OBJECT_ROT_SAMPLE))
{
// animation - rotate sampling
static int nTmpCount = 0;
vec3_t v;
vec_t t;
// νμ±ν angular displacement?? λ‘ μΆμ λλ κ²μ..
// fscanf (s, "%d", &(pM->pRotKey[nTmpCount].time)); fgetchar ();
// fscanf (s, "%f", &v[0]); fgetchar ();
// fscanf (s, "%f", &v[2]); fgetchar ();
// fscanf (s, "%f", &v[1]); fgetchar ();
// fscanf (s, "%f", &t);
fscanf (s, "%d", &(pM->pRotKey[nTmpCount].time)); fgetchar ();
fscanf (s, "%f", &v[0]); fgetchar ();
fscanf (s, "%f", &v[2]); fgetchar ();
fscanf (s, "%f", &v[1]); fgetchar ();
fscanf (s, "%f", &t);
// max_time κ° μ
λ°μ΄νΈ
if (pM->pRotKey[nTmpCount].time > *max_time) *max_time = pM->pRotKey[nTmpCount].time;
v[2] = -v[2];
// -----------------------------------------------------------
// 180λ μ΄μλλ νμ κ°μ κ°μ§ ν€μ λν μ²λ¦¬
// : νμ μΆμ λ€μ§κ³ νμ κ°μ 'κ° = 360-κ°'μΌλ‘ μ²λ¦¬ν΄μ€λ€.
// -----------------------------------------------------------
if (t >= degToRad(180)) {
t = degToRad(360) - t;
vectorScale (v, -1.0);
}
// μΏΌν°λμΈμΌλ‘ λ³νν΄μ μ μ₯.
// !! μ¬κΈ°μ.. angleμ μΌμ μ’νκ³λ₯Ό κΈ°μ€μΌλ‘ νλ€κ³ ν¨..
// μ€νμ§μμ μ€λ₯Έμ μ’νκ³μ΄λ―λ‘ λΆνΈλ₯Ό λ°λλ‘.. (-t)
// AngleAxis2Quat (&pM->pRotKey[nTmpCount].q, v, -t);
AngleAxis2Quat (&pM->pRotKey[nTmpCount].q, v, t);
nTmpCount++;
if (nTmpCount == pM->rotkeyNum)
nTmpCount = 0;
}
else if (!strcmp (data, OBJECT_POS_SAMPLE))
{
// animation - position sampling
static int nTmpCount2 = 0;
vec3_t p;
fscanf (s, "%d", &(pM->pPosKey[nTmpCount2].time)); fgetchar ();
fscanf (s, "%f", &p[0]); fgetchar ();
fscanf (s, "%f", &p[2]); fgetchar ();
fscanf (s, "%f", &p[1]);
p[2] = -p[2];
// max_time κ° μ
λ°μ΄νΈ
if (pM->pPosKey[nTmpCount2].time > *max_time) *max_time = pM->pPosKey[nTmpCount2].time;
memcpy (&pM->pPosKey[nTmpCount2].p, p, sizeof (vec3_t));
nTmpCount2++;
if (nTmpCount2 == pM->poskeyNum)
nTmpCount2 = 0;
}
else if (!strcmp (data, PV_NONBLEND))
{
int index;
char tmp_name[255];
char name[255];
fscanf (s, "%d ", &index);
int c_index = 0;
while (fgetc (s) != '"') {}
while (1) {
tmp_name [c_index++] = (char) fgetc (s);
if (tmp_name [c_index-1] == '"') {
tmp_name [c_index-1] = '\0';
break;
}
}
// memcpy (name, tmp_name+1, strlen(tmp_name)-2);
memcpy (name, tmp_name, strlen(tmp_name)+1);
// name [strlen(tmp_name)-2] = '\0';
for (int i=0;i<nNodeNum;i++) {
if (!strcmp (pNodeList [i]->Name, name))
{
pNodeList [i]->GetPSQInfo()->pV[pv_count[i]].nVIndex = index;
pNodeList [i]->GetPSQInfo()->pV[pv_count[i]].weight = 1.0;
pv_count[i]++;
}
}
}
else if (!strcmp (data, PV_BLEND_ASSIGNMODE))
{
fscanf (s, "%d", &nBlendAssignIndex);
}
else if (!strcmp (data, PV_BLEND_ASSIGN))
{
int index;
vec_t w;
char tmp_name[255];
char name[255];
//fscanf (s, "%d %f %s", &index, &w, &tmp_name);
fscanf (s, "%d %f ", &index, &w);
int c_index = 0;
while (fgetc (s) != '"') {}
while (1) {
tmp_name [c_index++] = (char) fgetc (s);
if (tmp_name [c_index-1] == '"') {
tmp_name [c_index-1] = '\0';
break;
}
}
memcpy (name, tmp_name, strlen(tmp_name)+1);
// memcpy (name, tmp_name+1, strlen(tmp_name)-2);
// name [strlen(tmp_name)-2] = '\0';
for (int i=0;i<nNodeNum;i++) {
if (!strcmp (pNodeList [i]->Name, name))
{
pNodeList [i]->GetPSQInfo()->pV[pv_count[i]].nVIndex = nBlendAssignIndex;
pNodeList [i]->GetPSQInfo()->pV[pv_count[i]].weight = w;
pv_count[i]++;
}
}
}
else if (strcmp (data, TEXTURE_ID) == 0)
{
pM->texture.texId = (int) GetFloatVal (s);
}
// μλ λΆλΆμ μμ λ λ λ―.. κ·Έλ¦¬κ³ textureλ λͺ¨λΈκ³Όλ λ³λλ‘ κ΄λ¦¬νλ κ²μ΄ μ’μ κ² κ°λ€.
// λͺ¨λΈμλ ν
μ€μ³μ μ°Έμ‘° λ²νΈ μ λλ§ μ μ₯νλ©΄ λ κ² κ°λ€.
else if (strcmp (data, UTILE) == 0)
{
pM->texture.uTile = GetFloatVal (s);
}
else if (strcmp (data, VTILE) == 0)
{
pM->texture.vTile = GetFloatVal (s);
}
else if (strcmp (data, UOFFSET) == 0)
{
pM->texture.uOffset = GetFloatVal (s);
}
else if (strcmp (data, VOFFSET) == 0)
{
pM->texture.vOffset = GetFloatVal (s);
}
else
fgets (data, sizeof (data), s);
}
mat44_t parent_inv, tmp_out;
for (int i=0;i<nNodeNum;i++) {
if (!pNodeList [i]->bPosKey) {
matrixIdentity (parent_inv);
matrixIdentity (tmp_out);
pNodeList[i]->pPosKey[0].time = 0;
// νμ΄μ΄λΌν€ μ 보λ₯Ό μμ±ν νμ΄λ―λ‘..
if (pNodeList [i]->RetParent ()) matrix44_inverse (parent_inv, pNodeList [i]->RetParent ()->tm);
matrixMultiply (pNodeList [i]->tm, parent_inv, tmp_out);
pNodeList[i]->pPosKey[0].p[0] = tmp_out[12];
pNodeList[i]->pPosKey[0].p[1] = tmp_out[13];
pNodeList[i]->pPosKey[0].p[2] = tmp_out[14];
}
if (!pNodeList [i]->bRotKey) {
pNodeList[i]->pRotKey[0].time = 0;
AngleAxis2Quat (&pNodeList[i]->pRotKey[0].q, pNodeList[i]->Axis, pNodeList[i]->Angle);
}
}
}