//Static
CAnimation* CSkeleton::AnimationParser(const std::string& p_crszKey, std::ifstream& p_rFile)
{
DEBUG(3, __FUNCTION__, "Parsing skeletal animation");
std::string szData;
CSkeleton* pSkele = new CSkeleton("data/skeletons/" + p_crszKey + ".skel");
CAnimation* pAnim = new CAnimation();
while(!p_rFile.eof())
{
p_rFile >> szData;
DEBUG(3, __FUNCTION__, szData);
if(szData == "end")
break;
if(szData == "nxt") //Next frame
{
DEBUG(3, __FUNCTION__, "Frame added");
pAnim->AddFrame(pSkele);
pSkele = new CSkeleton("data/skeletons/" + p_crszKey + ".skel");
}
else //Transformations
{
pSkele->ApplyTransformation(szData);
}
}
pAnim->AddFrame(pSkele);
return pAnim;
}
int APIENTRY WinMain(HINSTANCE hInstance,
HINSTANCE hPrevInstance,
LPSTR lpCmdLine,
int nCmdShow)
{
CSkeleton app;
if (!app.Create())
return 0;
return app.Run();
}
void CDialogSkinAuto::LoadSkel()
{
const string skel = QFileDialog::getOpenFileName(this, tr("Charger un squelette"),
"Model/", tr("Fichier squelette (*.chr)"));
if (!skel.isEmpty())
{
QFileInfo fileInfo(skel);
ModelMng->SetModelPath(fileInfo.path() % '/');
CSkeleton* skl = ModelMng->GetSkeleton(fileInfo.fileName());
if (skl)
{
Delete(m_mesh->m_skeleton);
m_mesh->m_skeleton = skl;
DeleteArray(m_mesh->m_bones);
ui.bonesList->clear();
m_items.clear();
ui.skelName->setText(fileInfo.fileName());
m_mesh->m_bones = new D3DXMATRIX[skl->GetBoneCount() * 2];
m_mesh->m_invBones = m_mesh->m_bones + skl->GetBoneCount();
skl->ResetBones(m_mesh->m_bones, m_mesh->m_invBones);
QList<QTreeWidgetItem*> items;
QTreeWidgetItem* item;
Bone* bone;
for (int i = 0; i < skl->GetBoneCount(); i++)
{
bone = &skl->m_bones[i];
item = new QTreeWidgetItem(QStringList(bone->name));
item->setFlags(item->flags() | Qt::ItemIsUserCheckable);
item->setCheckState(0, Qt::Unchecked);
item->setData(0, Qt::UserRole + 1, QVariant(i));
m_items[i] = item;
if (bone->parentID == -1)
items.append(item);
else
m_items[bone->parentID]->addChild(item);
}
ui.bonesList->insertTopLevelItems(0, items);
ui.bonesList->expandAll();
ui.okSkel->setEnabled(true);
}
}
}
void CDlgClient::OnBtConvert()
{
HTREEITEM hSelected = m_Tree.GetSelectedItem();
// just in case that no item is seleceted
if(hSelected==NULL) {
return;
}
NodeInfo &niSelected = theApp.m_dlgBarTreeView.GetNodeInfo(hSelected);
// if selected type is mesh list
if(niSelected.ni_iType == NT_MESHLODLIST) {
MeshInstance *pmshi = (MeshInstance*)niSelected.ni_pPtr;
CTString fnMesh = pmshi->mi_pMesh->GetName();
// save and convert mesh instance
if(theApp.SaveMeshListFile(*pmshi,TRUE)) {
theApp.NotificationMessage("Mesh list file '%s' converted",(const char*)fnMesh);
theApp.UpdateRootModelInstance();
} else {
theApp.ErrorMessage("Cannot convert mesh file '%s'",(const char*)fnMesh);
}
// if selected type is skeleton list
} else if(niSelected.ni_iType == NT_SKELETONLODLIST) {
// Get pointer to skeleton
CSkeleton *pskl = (CSkeleton*)niSelected.ni_pPtr;
CTString fnSkeleton = pskl->GetName();
// save and convert mesh instance
if(theApp.SaveSkeletonListFile(*pskl,TRUE)) {
theApp.NotificationMessage("Skeleton list file '%s' converted",(const char*)fnSkeleton);
theApp.UpdateRootModelInstance();
} else {
theApp.ErrorMessage("Cannot convert skeleton list file '%s'",(const char*)fnSkeleton);
}
// if selected type is animset
} else if(niSelected.ni_iType == NT_ANIMSET) {
// Get pointer to animset
CAnimSet *pas = (CAnimSet*)niSelected.ni_pPtr;
CTString fnAnimSet = pas->GetName();
// save and convert mesh instance
if(theApp.SaveAnimSetFile(*pas,TRUE)) {
theApp.NotificationMessage("AnimSet file '%s' converted",(const char*)fnAnimSet);
theApp.UpdateRootModelInstance();
} else {
theApp.ErrorMessage("Cannot convert animset file '%s'",(const char*)fnAnimSet);
}
}
CSeriousSkaStudioDoc *pDoc = theApp.GetDocument();
pDoc->MarkAsChanged();
}
CSkeleton* CModelMng::GetSkeleton(const string& filename)
{
const string name = filename.toLower();
auto it = m_skeletons.find(name);
if (it != m_skeletons.end())
return it.value();
CSkeleton* skel = new CSkeleton();
if (!skel->Load(m_modelPath % filename))
Delete(skel);
#ifndef MODEL_EDITOR
m_skeletons[name] = skel;
#endif // MODEL_EDITOR
return skel;
}
//------------------------------------------------------------------------------------------
Bool CSkeletonParameterProvider::BuildFromSkeleton( const CSkeleton& skeleton )
{
const CSkeleton::TMatrixArray& boneMatrices = skeleton.GetBoneMatrices();
for( u64 i=0; i<boneMatrices.Size(); i++ )
{
m_boneMatrices[ThNumericCast<u32>(i)] = boneMatrices[i];
}
return true;
}
XMVECTOR CSkeletonGroup::CalculateAlignment()
{
// Calculate the avarage velocity
XMVECTOR avgVelocity = XMVECTOR();
for (size_t i = 0; i < m_vSkeletons.size(); i++)
{
CSkeleton* other = reinterpret_cast<CSkeleton*>(m_vSkeletons[i]);
XMFLOAT3 vec = other->GetWorldVelocity();
XMVECTOR otherVelocity = XMLoadFloat3(&vec);
avgVelocity += otherVelocity;
}
avgVelocity /= (float)m_vSkeletons.size();
avgVelocity.m128_f32[1] = 0.0f;
if (XMVector3Length(avgVelocity).m128_f32[0] > 1.0f)
avgVelocity = XMVector3Normalize(avgVelocity);
return avgVelocity * ALIGNMENT_STRENGTH;
}
XMVECTOR CSkeletonGroup::CalculateSeparation(CSkeleton* _current)
{
XMVECTOR mathOutput = XMVECTOR();
// For all skeletons
for (size_t i = 0; i < m_vSkeletons.size(); i++)
{
// Cast the skeleton for future use
CSkeleton* other = reinterpret_cast<CSkeleton*>(m_vSkeletons[i]);
// Convert the positions for math
XMVECTOR mathOtherPos = XMLoadFloat3(other->GetPosition());
XMVECTOR mathCurrentPos = XMLoadFloat3(_current->GetPosition());
// Find the distance between them
XMVECTOR mathFromVector = mathCurrentPos - mathOtherPos;
float fDistance = XMVector3Length(mathFromVector).m128_f32[0];
// If within safe distance
if (fDistance < SEPARATION_DISTANCE)
{
mathFromVector = XMVector3Normalize(mathFromVector);
mathFromVector *= (SEPARATION_DISTANCE - fDistance) / SEPARATION_DISTANCE;
mathOutput += mathFromVector;
}
}
// Rescale the velocity
if (XMVector3Length(mathOutput).m128_f32[0] > 1.0f)
mathOutput = XMVector3Normalize(mathOutput);
// Scale by modifier
return mathOutput * SEPARATION_STRENGTH;
}
// save skeleton list file
BOOL CSeriousSkaStudioApp::SaveSkeletonListFile(CSkeleton &skl, BOOL bConvert)
{
DisableRendering();
CTFileName fnSkeletonList = skl.GetName();
fnSkeletonList = fnSkeletonList.NoExt() + ".asl";
try {
fnSkeletonList.RemoveApplicationPath_t();
}
catch(char *){}
// back up current skeleton list file
CTString strBackUp;
try {
strBackUp.Load_t(fnSkeletonList);
}
catch(char*){}
CTFileStream ostrFile;
try {
ostrFile.Create_t(fnSkeletonList,CTStream::CM_TEXT);
SaveSkeletonList_t(skl,ostrFile);
ostrFile.Close();
} catch(char *strError) {
ErrorMessage(strError);
EnableRendering();
return FALSE;
}
if(bConvert) {
if(!ConvertSkeleton(fnSkeletonList)) {
// convert failed
if(strBackUp.Length()>0) {
// try returning old mesh list file
try {
strBackUp.Save_t(fnSkeletonList);
}
catch(char*){}
}
}
}
EnableRendering();
return TRUE;
}
// convert ascii skeleton into binary
BOOL CSeriousSkaStudioApp::ConvertSkeleton(CTFileName fnSkeleton)
{
CSkeleton skeleton;
_yy_pSkeleton = &skeleton;
if(!StartParser(fnSkeleton))
{
//if failed clear skeleton and return
skeleton.Clear();
return FALSE;
}
// sort bones
skeleton.SortSkeleton();
try
{
// save binary skeleton
skeleton.Save_t(fnSkeleton.NoExt() + ".bs");
}
catch(char *strErr)
{
ErrorMessage(strErr);
}
// clear skeleton
skeleton.Clear();
_yy_pSkeleton = NULL;
// reload skeleton in stock
CSkeleton *pSkeleton;
try
{
// load skeleton
pSkeleton = _pSkeletonStock->Obtain_t(fnSkeleton.NoExt() + ".bs");
// reload skeleton
pSkeleton->Reload();
// release skeleton
_pSkeletonStock->Release(pSkeleton);
}
catch(char *strError)
{
if(strError != NULL) ErrorMessage("%s",strError);
return FALSE;
}
return TRUE;
}
void ParseModelNode( Node* node, CSkeleton& skeleton, const String& parentName )
{
Transform transf;
transf.rotation = Quat(node->transform.rotation[3], node->transform.rotation[0], node->transform.rotation[1], node->transform.rotation[2]);
transf.position = Vec3(node->transform.translation[0], node->transform.translation[1], node->transform.translation[2]);
transf.scale = Vec3(node->transform.scale[0], node->transform.scale[1], node->transform.scale[2]);
if (transf.rotation.w < 0.0f)
{
transf.rotation = -1.0f * transf.rotation;
}
String boneName = node->id.c_str();
skeleton.AddBone( boneName, parentName, transf );
for ( Node* child : node->children )
{
ParseModelNode( child, skeleton, boneName );
}
}
void CIntersection::ApplyConvexIntersection(CSkeleton &skeleton, CVertexList &vl, IntersectionQueue &iq)
{
#ifdef FELKELDEBUG
VTLOG("ApplyConvexIntersection\n");
#endif
// create new vertex and link into current contour
CVertex vtx (m_poi, *m_leftVertex, *m_rightVertex);
#if VTDEBUG
if(!(vtx.m_point != C3DPoint(CN_INFINITY, CN_INFINITY, CN_INFINITY)))
VTLOG("%s %d Assert failed\n", __FILE__, __LINE__);
#endif
// Link vertex into overall chain
CVertex *newNext = m_rightVertex->m_nextVertex;
CVertex *newPrev = m_leftVertex->m_prevVertex;
vtx.m_prevVertex = newPrev;
vtx.m_nextVertex = newNext;
vl.push_back (vtx);
CVertex *vtxPointer = &vl.back();
newPrev->m_nextVertex = vtxPointer;
newNext->m_prevVertex = vtxPointer;
// Set this vertex as the higher skeleton point for the vertices which have been
// removed from the active contour
m_leftVertex->m_higher = vtxPointer;
m_rightVertex->m_higher = vtxPointer;
// mark vertices as inactive
m_leftVertex->m_done = true;
m_rightVertex->m_done = true;
CIntersection newI(vl, *vtxPointer);
if (newI.m_height != CN_INFINITY)
iq.push(newI);
skeleton.push_back(CSkeletonLine(*m_leftVertex, *vtxPointer));
CSkeletonLine *lLinePtr = &skeleton.back();
skeleton.push_back(CSkeletonLine (*m_rightVertex, *vtxPointer));
CSkeletonLine *rLinePtr = &skeleton.back();
lLinePtr->m_lower.m_right = m_leftVertex->m_leftSkeletonLine;
lLinePtr->m_lower.m_left = m_leftVertex->m_rightSkeletonLine;
lLinePtr->m_higher.m_right = rLinePtr;
rLinePtr->m_lower.m_right = m_rightVertex->m_leftSkeletonLine;
rLinePtr->m_lower.m_left = m_rightVertex->m_rightSkeletonLine;
rLinePtr->m_higher.m_left = lLinePtr;
if (m_leftVertex->m_leftSkeletonLine)
m_leftVertex->m_leftSkeletonLine->m_higher.m_left = lLinePtr;
if (m_leftVertex->m_rightSkeletonLine)
m_leftVertex->m_rightSkeletonLine->m_higher.m_right = lLinePtr;
if (m_rightVertex->m_leftSkeletonLine)
m_rightVertex->m_leftSkeletonLine->m_higher.m_left = rLinePtr;
if (m_rightVertex->m_rightSkeletonLine)
m_rightVertex->m_rightSkeletonLine->m_higher.m_right = rLinePtr;
vtxPointer->m_leftSkeletonLine = lLinePtr;
vtxPointer->m_rightSkeletonLine = rLinePtr;
m_leftVertex->m_advancingSkeletonLine = lLinePtr;
m_rightVertex->m_advancingSkeletonLine = rLinePtr;
}
void CIntersection::ApplyNonconvexIntersection(CSkeleton &skeleton, CVertexList &vl, IntersectionQueue &iq, bool bCheckVertexinCurrentContour)
{
#ifdef FELKELDEBUG
VTLOG("ApplyNonconvexIntersection\n");
#endif
#if VTDEBUG
// Left and right vertices must always be the same point
if (!(m_leftVertex == m_rightVertex))
VTLOG("%s %d Assert failed\n", __FILE__, __LINE__);
// Check to see of they are the same data structure RFJ !!!
if (!(m_leftVertex->m_ID == m_rightVertex->m_ID))
VTLOG("%s %d Assert failed\n", __FILE__, __LINE__);
#endif
CVertex *leftPointer, *rightPointer;
C3DPoint p;
CNumber d3 = CN_INFINITY;
d3 = m_leftVertex->NearestIntersection(vl, &leftPointer, &rightPointer, p);
if (d3 == CN_INFINITY)
return;
if (p != m_poi)
return;
if (!m_leftVertex->VertexInCurrentContour(*leftPointer))
{
if (bCheckVertexinCurrentContour) // Temporary hack to disable checking in multiple contour buildings !!!! NEEDS FIXING
return;
else
VTLOG("Vertex in current contour check failed - needs to be fixed - this check is not valid if one (or both?) of the contours is clockwise\n");
}
// Left and right vertex are actually the same in this case
if (!m_rightVertex->VertexInCurrentContour(*rightPointer))
{
if (bCheckVertexinCurrentContour) // Temporary hack to disable checking in multiple contour buildings !!!! NEEDS FIXING
return;
else
VTLOG("Vertex in current contour check failed - needs to be fixed - this check is not valid if one (or both?) of the contours is clockwise\n");
}
#ifdef FELKELDEBUG
VTLOG("left vertex %d left ptr %d right ptr %d right vertex %d\n",
m_leftVertex->m_ID,
leftPointer->m_ID,
rightPointer->m_ID,
m_rightVertex->m_ID);
#endif
// Treat as a split event
CVertex v1 (p, *rightPointer, *m_rightVertex);
CVertex v2 (p, *m_leftVertex, *leftPointer);
#if VTDEBUG
if (!(v1.m_point != C3DPoint(CN_INFINITY, CN_INFINITY, CN_INFINITY)))
VTLOG("%s %d Assert failed\n", __FILE__, __LINE__);
if (!(v2.m_point != C3DPoint(CN_INFINITY, CN_INFINITY, CN_INFINITY)))
VTLOG("%s %d Assert failed\n", __FILE__, __LINE__);
#endif
m_leftVertex->m_done = true;
// i.rightVertex -> done = true;
CVertex *newNext1 = m_rightVertex->m_nextVertex;
CVertex *newPrev1 = leftPointer->Highest();
v1.m_prevVertex = newPrev1;
v1.m_nextVertex = newNext1;
vl.push_back(v1);
CVertex *v1Pointer = &vl.back();
newPrev1->m_nextVertex = v1Pointer;
newNext1->m_prevVertex = v1Pointer;
m_rightVertex->m_higher = v1Pointer;
CVertex *newNext2 = rightPointer->Highest();
CVertex *newPrev2 = m_leftVertex->m_prevVertex;
v2.m_prevVertex = newPrev2;
v2.m_nextVertex = newNext2;
vl.push_back(v2);
CVertex *v2Pointer = &vl.back();
newPrev2->m_nextVertex = v2Pointer;
newNext2->m_prevVertex = v2Pointer;
m_leftVertex->m_higher = v2Pointer;
skeleton.push_back(CSkeletonLine(*m_rightVertex, *v1Pointer));
CSkeletonLine *linePtr = &skeleton.back();
skeleton.push_back(CSkeletonLine(*v1Pointer, *v2Pointer));
CSkeletonLine *auxLine1Ptr = &skeleton.back ();
skeleton.push_back(CSkeletonLine(*v2Pointer, *v1Pointer));
CSkeletonLine *auxLine2Ptr = &skeleton.back();
linePtr->m_lower.m_right = m_leftVertex->m_leftSkeletonLine;
linePtr->m_lower.m_left = m_leftVertex->m_rightSkeletonLine;
v1Pointer->m_rightSkeletonLine = v2Pointer->m_leftSkeletonLine = linePtr;
v1Pointer->m_leftSkeletonLine = auxLine1Ptr;
v2Pointer->m_rightSkeletonLine = auxLine2Ptr;
auxLine1Ptr->m_lower.m_right = auxLine2Ptr;
auxLine2Ptr->m_lower.m_left = auxLine1Ptr;
if (m_leftVertex->m_leftSkeletonLine)
m_leftVertex->m_leftSkeletonLine ->m_higher.m_left = linePtr;
if (m_leftVertex->m_rightSkeletonLine)
m_leftVertex->m_rightSkeletonLine->m_higher.m_right = linePtr;
m_leftVertex->m_advancingSkeletonLine = linePtr;
if (newNext1 == newPrev1)
{
v1Pointer->m_done = true;
newNext1->m_done = true;
skeleton.push_back(CSkeletonLine(*v1Pointer, *newNext1));
CSkeletonLine *linePtr = &skeleton.back();
linePtr->m_lower.m_right = v1Pointer->m_leftSkeletonLine;
linePtr->m_lower.m_left = v1Pointer->m_rightSkeletonLine;
linePtr->m_higher.m_right = newNext1->m_leftSkeletonLine;
linePtr->m_higher.m_left = newNext1->m_rightSkeletonLine;
if (v1Pointer->m_leftSkeletonLine)
v1Pointer->m_leftSkeletonLine->m_higher.m_left = linePtr;
if (v1Pointer->m_rightSkeletonLine)
v1Pointer->m_rightSkeletonLine->m_higher.m_right = linePtr;
if (newNext1->m_leftSkeletonLine)
newNext1->m_leftSkeletonLine->m_higher.m_left = linePtr;
if (newNext1->m_rightSkeletonLine)
newNext1->m_rightSkeletonLine->m_higher.m_right = linePtr;
}
else
{
CIntersection i1(vl, *v1Pointer);
if (i1.m_height != CN_INFINITY)
iq.push (i1);
}
if (newNext2 == newPrev2)
{
v2Pointer->m_done = true;
newNext2 ->m_done = true;
skeleton.push_back(CSkeletonLine (*v2Pointer, *newNext2));
CSkeletonLine *linePtr = &skeleton.back();
linePtr->m_lower.m_right = v2Pointer->m_leftSkeletonLine;
linePtr->m_lower.m_left = v2Pointer->m_rightSkeletonLine;
linePtr->m_higher.m_right = newNext2->m_leftSkeletonLine;
linePtr->m_higher.m_left = newNext2->m_rightSkeletonLine;
if (v2Pointer->m_leftSkeletonLine)
v2Pointer->m_leftSkeletonLine->m_higher.m_left = linePtr;
if (v2Pointer->m_rightSkeletonLine)
v2Pointer->m_rightSkeletonLine->m_higher.m_right = linePtr;
if (newNext2->m_leftSkeletonLine)
newNext2 ->m_leftSkeletonLine->m_higher.m_left = linePtr;
if (newNext2->m_rightSkeletonLine)
newNext2->m_rightSkeletonLine->m_higher.m_right = linePtr;
}
else
{
CIntersection i2 (vl, *v2Pointer);
if (i2.m_height != CN_INFINITY)
iq.push(i2);
}
}
void display(void) {
float component = -0.8213f;
Quat q(-1,0,0,0);
ushort s0,s1,s2;
Quat::EncodeQuat( q, s0, s1, s2 );
Quat q2;
Quat::DecodeQuat( s0, s1, s2, q2 );
WbLog( "Default", "(%.5f, %.5f,%.5f,%.5f)\n", q2.w, q2.x, q2.y, q2.z );
short val = Quat::EncodeComponent( component );
float comp2 = Quat::DecodeComponent( val );
WbLog( "Default", "Quantizing: %.5f -> %d -> %.5f\n", component, val, comp2);
//clear white, draw with black
glClearColor(0, 0, 0, 0);
// glColor3f(1.0f, 1.0f, 1.0f);
// Enable Texture Mapping ( NEW )
glShadeModel(GL_SMOOTH); // Enable Smooth Shading
glClearDepth(1.0f); // Depth Buffer Setup
glEnable(GL_DEPTH_TEST); // Enables Depth Testing
glDepthFunc(GL_LEQUAL); // The Type Of Depth Testing To Do
glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST); // Really Nice Perspectiv
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glEnable(GL_TEXTURE_2D);
/*
GLfloat mat[] = { 1.0, 1.0, 1.0, 1.0 };
glEnable(GL_LIGHTING);
glEnable(GL_LIGHT0);
GLfloat zero[] = { 0,0,0,1.f};
GLfloat ambient[] = {1.0f, 1.0f, 1.0f, 1.0f};
glLightfv( GL_LIGHT0, GL_AMBIENT, zero);
glLightfv( GL_LIGHT0, GL_DIFFUSE, ambient);
glLightfv( GL_LIGHT0, GL_SPECULAR, zero);*/
glLoadIdentity();
//rot += 0.1f;
//glBindTexture(GL_TEXTURE_2D, textureID);
//glScalef(4,4,4);
glTranslatef(0.0f,-1.0f, -9.6f); //
//glTranslatef(0.0f,-10.0f, -40.6f);
// glRotatef( rot, 0, 1,0 );
//if(pMesh1);
//pMesh1->Render();
if (pMesh )
{
// WhiteBox::gVars->pRenderer->BindTexture( pTex->GetTextureId(), 0 );
//pMesh->Render();
}
//glRotatef( -rot, 0, 1, 0 );
// glTranslatef( 1.5f, 0.0f, 6.0f);
//glTranslatef(1.5f,0.0f,-6.0f);
// glRotatef( rot, 0, 1,0 );
//if(pMesh2)
//pMesh2->Render();
// glRotatef( -rot, 0, 1, 0 );
/*
glColorPointer(3, GL_FLOAT, decl.GetSize(), (void*)decl.GetSingleElementOffset( WhiteBox::CVertexDeclaration::eSE_Color ) );
//glColorPointer(3, GL_UNSIGNED_BYTE, sizeof(SVertex), BUFFER_OFFSET(ColorOffset));
glVertexPointer(3, GL_FLOAT, decl.GetSize(), (void*)decl.GetSingleElementOffset( WhiteBox::CVertexDeclaration::eSE_Position ) );
glEnableClientState(GL_VERTEX_ARRAY);
glEnableClientState(GL_COLOR_ARRAY);
glDrawArrays(GL_TRIANGLES, 0, 3);
glDisableClientState(GL_COLOR_ARRAY);
glDisableClientState(GL_VERTEX_ARRAY);*/
//pMesh2->Render();
/*
glBegin(GL_TRIANGLES); // Drawing Using Triangles
glVertex3f( 0.0f, 1.0f, 0.0f); // Top
glVertex3f(-1.0f,-1.0f, 0.0f); // Bottom Left
glVertex3f( 1.0f,-1.0f, 0.0f); // Bottom Right
glEnd(); */
//WhiteBox::gVars->pRenderer->BindTexture( pTex->GetTextureId(), 0 );
//WhiteBox::gVars->pRenderer->BindTexture( new int(12), 0 );
//WhiteBox::gVars->pRenderer->BindTexture( new int(1), 0 );
//glTranslatef(3.0f,0.0f, -1.0f) ;//0.0f);
/*
glBegin(GL_QUADS); // Draw A Quad
glVertex3f(-1.0f, 1.0f, 0.0f); // Top Left
glVertex3f( 1.0f, 1.0f, 0.0f); // Top Right
glVertex3f( 1.0f,-1.0f, 0.0f); // Bottom Right
glVertex3f(-1.0f,-1.0f, 0.0f); // Bottom Left
glEnd(); */
// glColor3f( 0.0f, 0.0f, 1.0f );
//glTranslatef(-8,0.0f,0.0f);
// glMaterialfv(GL_FRONT, GL_AMBIENT, mat);
phase += 0.5f;
float angle = Cos( Degree(phase) ) * 40.0f;
float angle3 = Cos( Degree(phase * 0.2f) ) * 90.0f;
if (true)
{
size_t count = skel.GetBones().size();
skel.ComputeInvertedGlobalBindPose();
CPose pose;
pose.m_boneTransforms.resize( count );
pose.m_boneTransforms[ 1 ].rotation = Quat::CreateRotX( Degree(angle3 ) ) * Quat::CreateRotZ( Degree(angle) );
//pose.m_boneTransforms[ 1 ].position.x = 0.5f;
skel.ConvertFromBindToLocalSpace( pose );
skel.ComputeGlobalPose( pose, pose );
WbLog( "Default", "Skel\n" );
for( size_t i=0 ; i < count ; ++i )
{
CBone& bone = skel.GetBones()[ i ];
if ( bone.GetParentIndex() >= 0 )
{
Vec3 parentPos = pose.m_boneTransforms[ bone.GetParentIndex() ].position;
gVars->pRenderer->DrawLine( parentPos, pose.m_boneTransforms[ i ].position, Color::White );
}
WbLog( "Default", "Bone %s, father:%d, Pos(%.2f,%.2f,%.2f)\n", bone.GetName().c_str(), bone.GetParentIndex(), pose.m_boneTransforms[ i ].position.x, pose.m_boneTransforms[ i ].position.y, pose.m_boneTransforms[ i ].position.z );
}
CPose skinPose;
skel.ComputeSkinningPose( pose, skinPose );
for(int i=0 ; i<vert*hori ; ++i)
{
float w = points[ i ].y / 3.0f;
points2[ i ] = (1.0f - w)*(skinPose.m_boneTransforms[ 0] * points[ i ]) + w*(skinPose.m_boneTransforms[ 2] * points[ i ]);
}
for( size_t i=0 ; i < vert ; ++i )
for( size_t j=0 ; j < hori-1 ; ++j )
{
Vec3& pt1 = points2[ hori * i + j ];
Vec3& pt2 = points2[ hori * i + j + 1 ];
gVars->pRenderer->DrawLine( pt1, pt2, Color::Blue );
}
WbLog( "Default", " %.2f\n", points[ 0].y );
WbLog( "Default", " %.2f\n", points2[ 0].x );
}
glTranslatef(0.55f,0.0f,0.0f);
//this draws a square using vertices
/* glBegin(GL_QUADS);
glVertex2i(0, 0);
glVertex2i(0, 128);
glVertex2i(128, 128);
glVertex2i(128, 0);
glEnd();*/
//a more useful helper
// glRecti(200, 200, 250, 250);
glutSwapBuffers();
}
void CIntersection::ApplyLast3(CSkeleton &skeleton, CVertexList &vl)
{
#ifdef FELKELDEBUG
VTLOG("ApplyLast3\n");
#endif
CVertex &v1 = *m_leftVertex;
CVertex &v2 = *m_rightVertex;
CVertex &v3 = *m_leftVertex->m_prevVertex;
v1.m_done = true;
v2.m_done = true;
v3.m_done = true;
C3DPoint is = m_poi;
CVertex v(is);
v.m_done = true;
vl.push_back(v);
CVertex *vtxPointer = &vl.back();
skeleton.push_back (CSkeletonLine(v1, *vtxPointer));
CSkeletonLine *line1Ptr = &skeleton.back();
skeleton.push_back (CSkeletonLine(v2, *vtxPointer));
CSkeletonLine *line2Ptr = &skeleton.back();
skeleton.push_back (CSkeletonLine(v3, *vtxPointer));
CSkeletonLine *line3Ptr = &skeleton.back ();
line1Ptr->m_higher.m_right = line2Ptr; // zapojeni okridlenych hran
line2Ptr->m_higher.m_right = line3Ptr;
line3Ptr->m_higher.m_right = line1Ptr;
line1Ptr->m_higher.m_left = line3Ptr;
line2Ptr ->m_higher.m_left = line1Ptr;
line3Ptr->m_higher.m_left = line2Ptr;
line1Ptr->m_lower.m_left = v1.m_rightSkeletonLine;
line1Ptr->m_lower.m_right = v1.m_leftSkeletonLine;
line2Ptr->m_lower.m_left = v2.m_rightSkeletonLine;
line2Ptr->m_lower.m_right = v2.m_leftSkeletonLine;
line3Ptr->m_lower.m_left = v3.m_rightSkeletonLine;
line3Ptr->m_lower.m_right = v3.m_leftSkeletonLine;
if (v1.m_leftSkeletonLine)
v1.m_leftSkeletonLine->m_higher.m_left = line1Ptr;
if (v1.m_rightSkeletonLine)
v1.m_rightSkeletonLine->m_higher.m_right = line1Ptr;
if (v2.m_leftSkeletonLine)
v2.m_leftSkeletonLine->m_higher.m_left = line2Ptr;
if (v2.m_rightSkeletonLine)
v2.m_rightSkeletonLine->m_higher.m_right = line2Ptr;
if (v3.m_leftSkeletonLine)
v3.m_leftSkeletonLine->m_higher.m_left = line3Ptr;
if (v3.m_rightSkeletonLine)
v3.m_rightSkeletonLine->m_higher.m_right = line3Ptr;
v1.m_advancingSkeletonLine = line1Ptr;
v2.m_advancingSkeletonLine = line2Ptr;
v3.m_advancingSkeletonLine = line3Ptr;
}
void CImporter::_createBones()
{
int boneCount = m_boneNodes.size();
Bone* bones = new Bone[boneCount];
memset(bones, 0, sizeof(Bone) * boneCount);
Bone* bone = null;
aiNode* node = null;
int i, j, k, l;
for (i = 0; i < boneCount; i++)
{
bone = &bones[i];
node = m_boneNodes[i];
strcpy(bone->name, node->mName.C_Str());
bone->localTM = _getMatrix(node->mTransformation);
if (node->mParent == m_scene->mRootNode
|| node->mParent == null)
bone->parentID = -1;
else
{
for (j = 0; j < boneCount; j++)
{
if (m_boneNodes[j] == node->mParent)
{
bone->parentID = j;
break;
}
}
}
}
for (i = 0; i < boneCount; i++)
{
bones[i].TM = bones[i].localTM;
if (bones[i].parentID != -1)
bones[i].TM *= bones[bones[i].parentID].TM;
}
aiMesh* mesh = null;
for (i = 0; i < m_objects.size(); i++)
{
for (j = 0; j < (int)m_objects[i]->mNumMeshes; j++)
{
mesh = m_scene->mMeshes[m_objects[i]->mMeshes[j]];
if (mesh->HasBones())
{
for (k = 0; k < (int)mesh->mNumBones; k++)
{
bone = null;
for (l = 0; l < boneCount; l++)
{
if (strcmp(bones[l].name, mesh->mBones[k]->mName.C_Str()) == 0)
{
bone = &bones[l];
break;
}
}
if (bone)
bone->inverseTM = _getMatrix(mesh->mBones[k]->mOffsetMatrix);
}
}
}
}
if (m_externBones)
{
CSkeleton* skel = m_mesh->m_skeleton = new CSkeleton();
skel->m_ID = _getNewID();
skel->m_boneCount = boneCount;
skel->m_bones = bones;
if (boneCount <= MAX_BONES)
skel->m_sendVS = true;
m_mesh->m_bones = new D3DXMATRIX[boneCount * 2];
m_mesh->m_invBones = m_mesh->m_bones + boneCount;
skel->ResetBones(m_mesh->m_bones, m_mesh->m_invBones);
}
else
{
m_obj3D->m_boneCount = boneCount;
if (boneCount <= MAX_BONES)
m_obj3D->m_sendVS = true;
m_obj3D->m_baseBones = new D3DXMATRIX[boneCount * 2];
m_obj3D->m_baseInvBones = m_obj3D->m_baseBones + boneCount;
for (i = 0; i < boneCount; i++)
{
m_obj3D->m_baseBones[i] = bones[i].TM;
m_obj3D->m_baseInvBones[i] = bones[i].inverseTM;
}
}
m_bones = bones;
}
void CSkeletonGroup::BuildPath()
{
// For offset spawning, will break with more then 4
XMVECTOR vecOffsets[NUM_SKELETONS] = { { -SPAWN_OFFSET_VALUE, 0, SPAWN_OFFSET_VALUE }, { SPAWN_OFFSET_VALUE, 0, SPAWN_OFFSET_VALUE }/*
{ -SPAWN_OFFSET_VALUE, 0, -SPAWN_OFFSET_VALUE }, { SPAWN_OFFSET_VALUE, 0, -SPAWN_OFFSET_VALUE }*/ };
// The new Path
vector<XMFLOAT3> newPath;
// Find an active skeleton
for (size_t i = 0; i < m_vSkeletons.size(); i++)
{
CSkeleton* curSkeleton = reinterpret_cast<CSkeleton*>(m_vSkeletons[i]);
if (curSkeleton->GetIsActive())
{
// Path to offset player position
XMVECTOR mathOffsetPos = XMLoadFloat3(m_cpPlayer->GetPosition());
mathOffsetPos += vecOffsets[i];
XMFLOAT3 offsetPosition; XMStoreFloat3(&offsetPosition, mathOffsetPos);
// Find the target node
int nPlayerNodeIndex = curSkeleton->GetPathPlanner()->FindClosestNode(&offsetPosition);
// Get the closest nodes
int nSkeletonNodeIndex = curSkeleton->GetPathPlanner()->FindClosestNode(curSkeleton->GetPosition());
// Build a path to the target
newPath = curSkeleton->GetPathPlanner()->GeneratePath(nSkeletonNodeIndex, nPlayerNodeIndex, false);
if (newPath.empty())
{
newPath.push_back(*curSkeleton->GetPlayer()->GetPosition());
newPath.push_back(*curSkeleton->GetPosition());
}
else if (newPath.size() == 1)
{
newPath.push_back(*curSkeleton->GetPlayer()->GetPosition());
}
// Set the new path
curSkeleton->SetPath(newPath);
// Set the node on path
curSkeleton->SetNodeOnPath(newPath.size() - 1);
}
}
// Went back to path finding for each
//// Set each skeleton's new path
//for (size_t ske = 0; ske < m_vSkeletons.size(); ske++)
//{
// reinterpret_cast<CSkeleton*>(m_vSkeletons[ske])->SetPath(newPath);
//
// // Set the current node
// reinterpret_cast<CSkeleton*>(m_vSkeletons[ske])->SetNodeOnPath(newPath.size() - 1);
//}
}
void CFbxExporter::Export( const String& assetFolder, const String& resourceFolder, const String& filePath )
{
log::Log log(new log::DefaultMessages(), -1);
FbxConv conv(&log);
Settings settings;
settings.flipV = false;
settings.packColors = false;
settings.verbose = true;
settings.maxNodePartBonesCount = 120;
settings.maxVertexBonesCount = 4;
settings.maxVertexCount = INT_MAX; // (1 << 15) - 1;
settings.maxIndexCount = INT_MAX; // (1 << 15) - 1;
settings.outType = FILETYPE_AUTO;
settings.inType = FILETYPE_FBX;
settings.inFile = std::string( (assetFolder + filePath).c_str() );
modeldata::Model *model = new modeldata::Model();
if (!conv.load(&settings, model))
{
return;
}
conv.info(model);
CSkeleton* pLastSkeleton = nullptr;
for (Node* node : model->nodes)
{
CSkeleton* pSkeleton = new CSkeleton();
ParseModelNode( node, *pSkeleton, "" );
pSkeleton->ComputeGlobalPose(pSkeleton->m_localBindPose, pSkeleton->m_globalBindPose);
String skeletonPath = resourceFolder + filePath.get_path_base() + filePath.get_path_name() + ".skel";
gVars->pFileSystem->CreateFileDir( skeletonPath );
pSkeleton->SaveToFile( skeletonPath );
if ( pLastSkeleton != nullptr )
{
delete pLastSkeleton;
}
pLastSkeleton = pSkeleton;
}
for (Animation* ani : model->animations)
{
CAnimation* pAnimation = new CAnimation();
for (NodeAnimation* nodeAnim : ani->nodeAnimations)
{
int idx = pLastSkeleton->m_boneNameToIndex[nodeAnim->node->id.c_str()];
if (idx < 0)
continue;
const std::vector< Keyframe* >& keyframes = nodeAnim->keyframes;
Transform* trackKeys = new Transform[ keyframes.size() ];
for (size_t iKey = 0; iKey < keyframes.size(); ++iKey)
{
const Keyframe& k = *(keyframes[ iKey ]);
Transform transf;
transf.rotation = Quat(k.rotation[3], k.rotation[0], k.rotation[1], k.rotation[2]);
if (transf.rotation.w < 0.0f)
{
transf.rotation = -1.0f * transf.rotation;
}
transf.position = Vec3(k.translation[0], k.translation[1], k.translation[2]);
transf.scale = Vec3(k.scale[0], k.scale[1], k.scale[2]);
transf = pLastSkeleton->m_localBindPose.m_boneTransforms[idx].GetInverse() * transf;
if (String(nodeAnim->node->id.c_str()).Contains("twist"))
{
transf = Transform();
}
trackKeys[ iKey ] = transf;
}
pAnimation->AddAnimationTack( new CAnimationTrack( CAnimationTrack::eKFF_Transform, trackKeys, keyframes.size() ), idx );
}
String animPath = resourceFolder + filePath.get_path_base() + filePath.get_path_name() + ".anim";
gVars->pFileSystem->CreateFileDir(animPath);
pAnimation->SaveToFile(animPath);
delete pAnimation;
}
if (pLastSkeleton != nullptr)
{
delete pLastSkeleton;
}
for (Mesh* mesh : model->meshes)
{
CMeshHelper mh;
size_t vertexCount = mesh->vertexCount();
size_t vertexFloatCount = mesh->vertexSize;
mh.m_positionArray.reserve(vertexCount);
mh.m_normalArray.reserve(vertexCount);
size_t attCount = mesh->attributes.length();
for (size_t att = 0; att < attCount; ++att)
{
size_t idx = mesh->attributes.get(att);
unsigned int offset = 0;
for (unsigned int i = 0; i < idx; i++)
if (mesh->attributes.has(i))
offset += (unsigned int)ATTRIBUTE_SIZE(i);
switch (idx)
{
case ATTRIBUTE_POSITION:
{
for (size_t i = 0; i < vertexCount; ++i)
{
mh.AddPosition(*(Vec3*)(&mesh->vertices[vertexFloatCount * i]));
}
break;
}
case ATTRIBUTE_NORMAL:
{
for (size_t i = 0; i < vertexCount; ++i)
{
mh.AddNormal(*(Vec3*)(&mesh->vertices[offset + vertexFloatCount * i]));
}
break;
}
case ATTRIBUTE_BLENDWEIGHT0:
case ATTRIBUTE_BLENDWEIGHT1:
case ATTRIBUTE_BLENDWEIGHT2:
case ATTRIBUTE_BLENDWEIGHT3:
case ATTRIBUTE_BLENDWEIGHT4:
case ATTRIBUTE_BLENDWEIGHT5:
case ATTRIBUTE_BLENDWEIGHT6:
case ATTRIBUTE_BLENDWEIGHT7:
{
size_t attributeIndex = idx - (size_t)ATTRIBUTE_BLENDWEIGHT0;
for (size_t i = 0; i < vertexCount; ++i)
{
mh.AddBlendWeight( attributeIndex, *((SVertexBlendWeight*)(&mesh->vertices[offset + vertexFloatCount * i])) );
}
break;
}
}
}
for (MeshPart* meshPart : mesh->parts)
{
mh.AddMeshPart();
CMeshPartHelper* part = mh.GetMeshPart(mh.m_meshParts.size()-1);
for (unsigned short indice : meshPart->indices)
{
part->AddIndex(indice);
}
}
String meshPath = resourceFolder + filePath.get_path_base() + filePath.get_path_name() + ".msh";
gVars->pFileSystem->CreateFileDir( meshPath );
mh.SaveToFile( meshPath );
}
}
