void ElCamera::calcViewOrientation()
{
D3DXVec3Normalize(&mLook, &mLook);
D3DXVec3Cross(&mUp, &mLook, &mRight);
D3DXVec3Normalize(&mUp, &mUp);
D3DXVec3Cross(&mRight, &mUp, &mLook);
D3DXVec3Normalize(&mRight, &mRight);
D3DXMATRIX rot;
D3DXMatrixIdentity(&rot);
rot._11 = mRight.x;
rot._12 = mRight.y;
rot._13 = mRight.z;
rot._21 = mUp.x;
rot._22 = mUp.y;
rot._23 = mUp.z;
rot._31 = mLook.x;
rot._32 = mLook.y;
rot._33 = mLook.z;
D3DXQuaternionRotationMatrix(&mOrientation, &rot);
// transform to parent space
if (mParentNode)
{
D3DXQUATERNION parentOrientation = mParentNode->getDerivedOrientation();
D3DXQuaternionInverse(&parentOrientation, &parentOrientation);
mOrientation = parentOrientation * mOrientation;
}
}
void AnimationNode::set_transform(const D3DXMATRIX& transform)
{
transform_ = transform;
pos_ = get_translation(transform);
D3DXQuaternionRotationMatrix(&rot_, &transform);
scale_ = get_scale(transform);
}
void IObj::DirectionRotation( bool IsSmooth )
{
// D3DXVec3Normalize( &m_vDirection, &m_vDirection );
D3DXVECTOR3 vCoord;
D3DXVECTOR3 vCross;
D3DXMATRIXA16 matRotY;
D3DXMatrixRotationY( &matRotY, -D3DX_PI * 0.5f );
D3DXVec3TransformCoord( &vCoord, &m_vDirection, &matRotY );
D3DXVec3Normalize( &vCoord, &vCoord );
D3DXMatrixRotationX( &matRotY, D3DX_PI );
D3DXVec3Cross( &vCross, &vCoord, &m_vDirection );
D3DXVec3TransformCoord( &vCross, &vCross, &matRotY );
D3DXVec3Normalize( &vCross, &vCross );
memcpy( &m_matLookAt._11, &vCoord, sizeof( D3DXVECTOR3 ) );
memcpy( &m_matLookAt._21, &vCross, sizeof( D3DXVECTOR3 ) );
memcpy( &m_matLookAt._31, &m_vDirection, sizeof( D3DXVECTOR3 ) );
memcpy( &m_matLookAt._41, &D3DXVECTOR3( 0.0f, 0.0f, 0.0f ), sizeof( D3DXVECTOR3 ) );
D3DXQUATERNION q;
D3DXQuaternionRotationMatrix( &q, &m_matLookAt );
D3DXQuaternionSlerp( &m_quatLookAt, &m_quatLookAt, &q, 0.1f );
}
int CMotionPoint::MakeWorldMat( D3DXMATRIX* wmat )
{
m_worldmat = m_totalmat * *wmat;
D3DXQUATERNION tmpxq;
D3DXQuaternionRotationMatrix( &tmpxq, wmat );
CQuaternion wq;
wq.SetParams( tmpxq );
m_worldq = wq * m_totalq;
return 0;
}
/*****************************************************************
* D3DXMATRIX Interpolate(D3DXMATRIX _d3dPrevFrame, D3DXMATRIX _d3dNextFrame, float _fLambda):
* Interpolates between two Matrices based on Lambda time
*
* Ins: D3DXMATRIX _d3dPrevFrame
* D3DXMATRIX _d3dNextFrame
* float _fLambda
*
* Outs: void
*
* Returns: D3DXMATRIX
*
* Mod. Date: 02/20/2013
* Mod. Initials: SD
*****************************************************************/
D3DXMATRIX Interpolate(D3DXMATRIX& d3dMatrixA, D3DXMATRIX& d3dMatrixB, float fLambda)
{
D3DXQUATERNION quatA, quatB, tempQuat;
D3DXQuaternionRotationMatrix(&quatA, &d3dMatrixA);
D3DXQuaternionRotationMatrix(&quatB, &d3dMatrixB);
tempQuat = quatA;
D3DXQuaternionNormalize(&quatA, &tempQuat);
tempQuat = quatB;
D3DXQuaternionNormalize(&quatB, &tempQuat);
D3DXQuaternionSlerp(&tempQuat, &quatA, &quatB, fLambda);
D3DXMATRIX result;
D3DXMatrixRotationQuaternion(&result, &tempQuat);
D3DXVec3Lerp((D3DXVECTOR3*)&result[12], (D3DXVECTOR3*)&d3dMatrixA[12], (D3DXVECTOR3*)&d3dMatrixB[12], fLambda);
D3DXVECTOR3 scaleA = D3DXVECTOR3(d3dMatrixA[0],d3dMatrixA[5],d3dMatrixA[10]);
D3DXVECTOR3 scaleB = D3DXVECTOR3(d3dMatrixB[0],d3dMatrixB[5],d3dMatrixB[10]);
D3DXVECTOR3 finalScale;
D3DXVec3Lerp(&finalScale, &scaleA, &scaleB, fLambda);
result[0] = finalScale[0];
result[5] = finalScale[1];
result[10] = finalScale[2];
return result;
}
OvTransform ExtractTransformFromMatrix( const OvMatrix& mat )
{
OvTransform outPut;
outPut.Position.x = mat._41;
outPut.Position.y = mat._42;
outPut.Position.z = mat._43;
OvMatrix kExtractMat;
D3DXQuaternionRotationMatrix((D3DXQUATERNION*)&outPut.Quaternion,(D3DXMATRIX*)&mat);
kExtractMat = mat*OvMatrix().Rotate(outPut.Quaternion.Inverse());
outPut.Scale.x = kExtractMat._11;
outPut.Scale.y = kExtractMat._22;
outPut.Scale.z = kExtractMat._33;
return outPut;
}
void quater::setRotation(const matrix4& m)
{
#ifdef USE_D3DFUNC
D3DXMATRIX dxmat;
m.toDXmat(dxmat);
D3DXQuaternionRotationMatrix(*this,&dxmat);
#else
// jehee lee implementation
quater &q=*this;
double tr, s;
int i, j, k;
static int next[3] = { 1, 2, 0 };
tr = m.m[0][0] + m.m[1][1] + m.m[2][2];
if ( tr > 0.0 )
{
s = sqrt( tr + 1.0 );
q[0] = ( s * 0.5 );
s = 0.5 / s;
q.x = ( m.m[2][1] - m.m[1][2] ) * s;
q.y = ( m.m[0][2] - m.m[2][0] ) * s;
q.z = ( m.m[1][0] - m.m[0][1] ) * s;
}
else
{
i = 0;
if ( m.m[1][1] > m.m[0][0] ) i = 1;
if ( m.m[2][2] > m.m[i][i] ) i = 2;
j = next[i];
k = next[j];
s = sqrt( (m.m[i][i]
- (m.m[j][j] + m.m[k][k])) + 1.0 );
q[i+1] = s * 0.5;
s = 0.5 / s;
q.w = ( m.m[k][j] - m.m[j][k] ) * s;
q[j+1] = ( m.m[j][i] + m.m[i][j] ) * s;
q[k+1] = ( m.m[k][i] + m.m[i][k] ) * s;
}
#endif
}
//--------------------------------------------------------------------------------------
// Override for setting the view parameters
//--------------------------------------------------------------------------------------
void CModelViewerCamera::SetViewParams( D3DXVECTOR3* pvEyePt, D3DXVECTOR3* pvLookatPt )
{
CBaseCamera::SetViewParams( pvEyePt, pvLookatPt );
// Propogate changes to the member arcball
D3DXQUATERNION quat;
D3DXMATRIXA16 mRotation;
D3DXVECTOR3 vUp(0,1,0);
D3DXMatrixLookAtLH( &mRotation, pvEyePt, pvLookatPt, &vUp );
D3DXQuaternionRotationMatrix( &quat, &mRotation );
m_ViewArcBall.SetQuatNow( quat );
// Set the radius according to the distance
D3DXVECTOR3 vEyeToPoint;
D3DXVec3Subtract( &vEyeToPoint, pvLookatPt, pvEyePt );
SetRadius( D3DXVec3Length( &vEyeToPoint ) );
}
/*************************************************************************
* D3DXMatrixDecompose
*/
HRESULT WINAPI D3DXMatrixDecompose(D3DXVECTOR3 *poutscale, D3DXQUATERNION *poutrotation, D3DXVECTOR3 *pouttranslation, D3DXMATRIX *pm)
{
D3DXMATRIX normalized;
D3DXVECTOR3 vec;
/*Compute the scaling part.*/
vec.x=pm->u.m[0][0];
vec.y=pm->u.m[0][1];
vec.z=pm->u.m[0][2];
poutscale->x=D3DXVec3Length(&vec);
vec.x=pm->u.m[1][0];
vec.y=pm->u.m[1][1];
vec.z=pm->u.m[1][2];
poutscale->y=D3DXVec3Length(&vec);
vec.x=pm->u.m[2][0];
vec.y=pm->u.m[2][1];
vec.z=pm->u.m[2][2];
poutscale->z=D3DXVec3Length(&vec);
/*Compute the translation part.*/
pouttranslation->x=pm->u.m[3][0];
pouttranslation->y=pm->u.m[3][1];
pouttranslation->z=pm->u.m[3][2];
/*Let's calculate the rotation now*/
if ( (poutscale->x == 0.0f) || (poutscale->y == 0.0f) || (poutscale->z == 0.0f) )
{
return D3DERR_INVALIDCALL;
}
normalized.u.m[0][0]=pm->u.m[0][0]/poutscale->x;
normalized.u.m[0][1]=pm->u.m[0][1]/poutscale->x;
normalized.u.m[0][2]=pm->u.m[0][2]/poutscale->x;
normalized.u.m[1][0]=pm->u.m[1][0]/poutscale->y;
normalized.u.m[1][1]=pm->u.m[1][1]/poutscale->y;
normalized.u.m[1][2]=pm->u.m[1][2]/poutscale->y;
normalized.u.m[2][0]=pm->u.m[2][0]/poutscale->z;
normalized.u.m[2][1]=pm->u.m[2][1]/poutscale->z;
normalized.u.m[2][2]=pm->u.m[2][2]/poutscale->z;
D3DXQuaternionRotationMatrix(poutrotation,&normalized);
return S_OK;
}
void Camera::Place( D3DXVECTOR3& eye)
{
__super::Reset();
D3DXVECTOR3 center = STATE_GET(Render)->GetModelCenter();
float radius = STATE_GET(Render)->GetModelRadius();
__super::SetViewParams( &eye, ¢er );
__super::SetModelCenter( center );
__super::SetRadius( radius*2.5f, 0.0f/*radius*/, radius*10.0f );
D3DXQUATERNION quat;
D3DXMATRIXA16 mIdentity;
D3DXMatrixIdentity( &mIdentity );
D3DXQuaternionRotationMatrix( &quat, &mIdentity );
__super::SetWorldQuat( quat );
__super::SetWorldMatrix( mIdentity );
Resize();
}
int CMotionPoint::CalcQandTra( D3DXMATRIX srcmat, CBone* boneptr )
{
D3DXVECTOR3 aftpos;
D3DXVec3TransformCoord( &aftpos, &boneptr->m_jointfpos, &srcmat );
m_tra = aftpos - boneptr->m_jointfpos;
D3DXMATRIX tmpmat = srcmat;
tmpmat._41 = 0.0f;
tmpmat._42 = 0.0f;
tmpmat._43 = 0.0f;
D3DXQUATERNION rotqx;
D3DXQuaternionRotationMatrix( &rotqx, &tmpmat );
m_q.x = rotqx.x;
m_q.y = rotqx.y;
m_q.z = rotqx.z;
m_q.w = rotqx.w;
/***
D3DXMATRIX beftra, afttra;
D3DXMatrixIdentity( &beftra );
D3DXMatrixTranslation( &beftra, -boneptr->m_jointfpos.x, -boneptr->m_jointfpos.y, -boneptr->m_jointfpos.z );
D3DXMatrixIdentity( &afttra );
D3DXMatrixTranslation( &afttra, -boneptr->m_jointfpos.x, -boneptr->m_jointfpos.y, -boneptr->m_jointfpos.z );
D3DXMATRIX lbase;
lbase = beftra * tmpmat * afttra;
D3DXMATRIX invlbase;
D3DXMatrixInverse( &invlbase, NULL, &lbase );
D3DXVECTOR3 zeropos( 0.0f, 0.0f, 0.0f );
D3DXMATRIX xmat;
xmat = invlbase * srcmat;
D3DXVec3TransformCoord( &m_tra, &zeropos, &xmat );
***/
return 0;
}
bool ActionBox::isPointInside(Vec3 *point)
{
/*if(!(point->y < m_currentMax.y && point->y > m_currentMin.y))
return false;*/
/*point->y = 100.0f;
Vec3 p0 = m_min;
Vec3 p1 = m_max;
Vec3 p2 = Vec3(m_max.x, 0, m_min.z);
Vec3 p2_2 = Vec3(m_min.x, 0, m_max.z);
D3DXVec3TransformCoord(&p0, &p0, &m_world);
D3DXVec3TransformCoord(&p1, &p1, &m_world);
D3DXVec3TransformCoord(&p2, &p2, &m_world);
D3DXVec3TransformCoord(&p2_2, &p2_2, &m_world);
return D3DXIntersectTri(&p0, &p1, &p2, point, &Vec3(0, -1, 0), 0, 0, 0) || D3DXIntersectTri(&p0, &p1, &p2_2, point, &Vec3(0, -1, 0), 0, 0, 0);*/
Vec3 checkPoint = *point;
checkPoint = (*point) - m_position;
Mat temp;
temp = m_world;
D3DXQUATERNION quat;
D3DXQuaternionRotationMatrix(&quat, &temp);
D3DXQuaternionNormalize(&quat, &quat);
D3DXQuaternionInverse(&quat, &quat);
temp._41 = 0;
temp._42 = 0;
temp._43 = 0;
D3DXMatrixRotationQuaternion(&temp, &quat);
D3DXVec3TransformCoord(&checkPoint, &checkPoint, &temp);
if(checkPoint.x > m_min.x && checkPoint.x < m_max.x &&
//checkPoint.y > m_min.y && checkPoint.y < m_max.y &&
checkPoint.z > m_min.z && checkPoint.z < m_max.z)
return true;
return false;
}
int CMotionPoint::MakeDispMat()
{
m_disptra.x = m_worldmat._41;
m_disptra.y = m_worldmat._42;
m_disptra.z = m_worldmat._43;
D3DXMATRIX tmpwmat = m_worldmat;
tmpwmat._41 = 0.0f;
tmpwmat._42 = 0.0f;
tmpwmat._43 = 0.0f;
D3DXQUATERNION xtmpq;
D3DXQuaternionRotationMatrix( &xtmpq, &tmpwmat );
m_dispq.SetParams( xtmpq );
m_orderdispq = m_dispq;
m_dispmat = m_dispq.MakeRotMatX();
m_dispmat._41 = m_disptra.x;
m_dispmat._42 = m_disptra.y;
m_dispmat._43 = m_disptra.z;
return 0;
}
void CCameraReplay::processFrame( float frame, SMatrix4x4& viewerMat, float& zoom, float& tilt, bool& follow )
{
if( mMode == REC_NONE )
return;
frame *= RECORDS_PER_TURN;
int iframe0 = (int)frame;
int iframe1 = iframe0 + 1;
float alpha = frame - iframe0;
if( mMode == REC_READ )
{
if( iframe0 >= mData.size() ) iframe0 = mData.size()-1;
if( iframe1 >= mData.size() ) iframe1 = mData.size()-1;
SFrameData fd;
fd.lerp( mData[iframe0], mData[iframe1], alpha );
viewerMat = SMatrix4x4( fd.pos, fd.rot );
zoom = fd.megaZoom;
tilt = fd.megaTilt;
follow = fd.followMode;
}
else
{
SFrameData fd;
fd.pos = viewerMat.getOrigin();
D3DXQuaternionRotationMatrix( &fd.rot, &viewerMat );
fd.megaZoom = zoom;
fd.megaTilt = tilt;
fd.followMode = follow;
writeFrameDataToFile( mFile, iframe0, fd );
}
}
bool GBoneObj::Load(ID3D11Device* pDevice,const TCHAR* szLoadName,const TCHAR* pLoadShaderFile,bool bThread)
{
FILE *fp;
fp = _tfopen(szLoadName, _T("rb"));
if (!fp) return false;
char szBuffer[MAX_PATH] = { 0, };
size_t convertedChars = 0;
tm newtime;
fread(&newtime, sizeof(tm), 1, fp);
T_STR today = _tasctime(&newtime); // The date string has a \n appended.
today[today.size() - 1] = 0;
fread(&m_Scene, sizeof(TScene), 1, fp);
// 시작 프레임이 0일 아닐 경우가 있기 때문에 무조건
// 시작 프레임을 0으로 맞춘다.( 해당 프레임 만큼만 배열 할당 된다.)
m_iStartFrame = 0;//m_Scene.iFirstFrame;
m_iLastFrame = m_Scene.iLastFrame - m_Scene.iFirstFrame;
m_fElapseTime = (float)m_iStartFrame;
m_Scene.iFirstFrame = 0;
m_Scene.iLastFrame = m_iLastFrame;
SAFE_NEW_ARRAY_CLEAR(m_pMatrix, D3DXMATRIX, m_Scene.iNumMesh);
SAFE_NEW_ARRAY_CLEAR(m_ppAniMatrix, LPD3DXMATRIX, m_Scene.iNumMesh);
SAFE_NEW_ARRAY_CLEAR(m_ppAniQuater, LPD3DXQUATERNION, m_Scene.iNumMesh);
SAFE_NEW_ARRAY_CLEAR(m_ppScaleVector, LPD3DXVECTOR3, m_Scene.iNumMesh);
SAFE_NEW_ARRAY_CLEAR(m_ppTransVector, LPD3DXVECTOR3, m_Scene.iNumMesh);
int iNumFrame = m_iLastFrame - m_iStartFrame;
for (int i = 0; i < m_Scene.iNumMesh; i++)
{
SAFE_NEW_ARRAY(m_ppAniMatrix[i], D3DXMATRIX, iNumFrame);
SAFE_NEW_ARRAY(m_ppAniQuater[i], D3DXQUATERNION, iNumFrame);
SAFE_NEW_ARRAY(m_ppScaleVector[i], D3DXVECTOR3, iNumFrame);
SAFE_NEW_ARRAY(m_ppTransVector[i], D3DXVECTOR3, iNumFrame);
}
D3DXQUATERNION qRotate;
D3DXVECTOR3 vScale, vTrans;
D3DXMATRIX matFrameWorld;
for (int ibip = 0; ibip < m_Scene.iNumMesh; ibip++)
{
for (int iFrame = 0; iFrame < iNumFrame; iFrame++)
{
fread(&m_ppAniMatrix[ibip][iFrame], sizeof(D3DXMATRIX), 1, fp);
}
}
for (int ibip = 0; ibip < m_Scene.iNumMesh; ibip++)
{
shared_ptr<tMatMesh> pData = make_shared<tMatMesh>();
shared_ptr<GMesh> pMesh = make_shared<GMesh>();
int iCount;
TCHAR szBuffer[256] = { 0, };
TCHAR szName[256] = { 0, };
fread(&pMesh->m_ClassType, sizeof(int), 1, fp);
fread(&iCount, sizeof(int), 1, fp);
fread(szName, sizeof(TCHAR) * iCount, 1, fp);
pMesh->m_strNodeName = szName;
fread(&pMesh->m_matWorld, sizeof(D3DXMATRIX), 1, fp);
D3DXMatrixInverse(&pData->m_matInverse, 0, &pMesh->m_matWorld);
fread(&iCount, sizeof(int), 1, fp);
// 메쉬 버텍스 리스트
if (iCount == 2)
{
pData->m_VertexArray.resize(36);
m_iMaxVertex += 36;
}
else
{
pData->m_VertexArray.resize(iCount);
m_iMaxVertex += iCount;
}
for (int iVertex = 0; iVertex < iCount; iVertex++)
{
fread(&pData->m_VertexArray[iVertex], sizeof(PNC_VERTEX), 1, fp);
if (m_Scene.iBindPose)
{
D3DXVec3TransformCoord(&pData->m_VertexArray[iVertex].p,
&pData->m_VertexArray[iVertex].p,
&pData->m_matInverse);
}
}
// 본과 더미 오브젝트( 최대 및 최소값 2개 출력되어 있음 )
if (iCount == 2)
{
D3DXVECTOR3 Quad[8];
D3DXVECTOR3 vMax = pData->m_VertexArray[0].p;
D3DXVECTOR3 vMin = pData->m_VertexArray[1].p;
Quad[0] = D3DXVECTOR3(vMin.x, vMin.y, vMin.z);
Quad[1] = D3DXVECTOR3(vMin.x, vMax.y, vMin.z);
Quad[2] = D3DXVECTOR3(vMax.x, vMax.y, vMin.z);
Quad[3] = D3DXVECTOR3(vMax.x, vMin.y, vMin.z);
Quad[4] = D3DXVECTOR3(vMin.x, vMin.y, vMax.z);
Quad[5] = D3DXVECTOR3(vMin.x, vMax.y, vMax.z);
Quad[6] = D3DXVECTOR3(vMax.x, vMax.y, vMax.z);
Quad[7] = D3DXVECTOR3(vMax.x, vMin.y, vMax.z);
SetBoundBox(Quad, pData.get());
}
pMesh->m_iNumFace = pData->m_VertexArray.size() / 3;
m_pMesh.push_back(pMesh);
m_pData.push_back(pData);
}
for (int ibip = 0; ibip < m_Scene.iNumMesh; ibip++)
{
for (int jFrame = 0; jFrame < m_iLastFrame - m_iStartFrame; jFrame++)
{
if (m_Scene.iBindPose)
{
//m_ppAniMatrix[ibip][jFrame] = m_pData[ibip]->m_matWorld * m_ppAniMatrix[ibip][jFrame];
}
if (SUCCEEDED(D3DXMatrixDecompose(&vScale, &qRotate, &vTrans, &m_ppAniMatrix[ibip][jFrame])))
{
m_ppAniQuater[ibip][jFrame] = qRotate;
m_ppScaleVector[ibip][jFrame] = vScale;
m_ppTransVector[ibip][jFrame] = vTrans;
}
else
{
D3DXQuaternionRotationMatrix(&m_ppAniQuater[ibip][jFrame], &m_ppAniMatrix[ibip][jFrame]);
}
}
}
fclose(fp);
m_dxobj.m_iNumVertex = m_iMaxVertex;
m_dxobj.m_iNumIndex = m_iMaxIndex;
m_dxobj.m_iVertexSize = sizeof(PNC_VERTEX);
if (!bThread && !Create(pDevice, pLoadShaderFile))
{
return false;
}
return true;
}
/*!
*@brief 行列からクォータニオンを作成。
*/
void CQuaternion::SetRotation(const CMatrix& m)
{
D3DXQuaternionRotationMatrix((D3DXQUATERNION*)this, (D3DXMATRIX*)&m);
}
void Quaternion::Build(const Mat4x4& mat)
{
D3DXQuaternionRotationMatrix(this, &mat);
}
void GGbsModel::MultiAniFrame(){
D3DXMATRIX matWldTrans;
D3DXMATRIX matWldRotate;
D3DXMATRIX matWldScale;
D3DXMatrixIdentity(&matWldTrans);
D3DXMatrixIdentity(&matWldRotate);
D3DXMatrixIdentity(&matWldScale);
D3DXQUATERNION qR, qS;
D3DXMATRIX matCalc;
D3DXMatrixIdentity(&matCalc);
//m_fTickFrame = 6400.0f;
m_fTickFrame += g_fSecPerFrame * m_fFrameSpeed *m_fTickPerFrame;
if (m_fTickFrame >= m_fLastFrame * m_fTickPerFrame /*마지막 프레임 틱수*/)
{
m_fTickFrame = 0.0f;
}
//m_fTickFrame += 1000.0f;
//if (m_fTickFrame >= 8000.0f /*마지막 프레임 틱수*/)
//{
// m_fTickFrame = 0.0f;
//}
for (int i = 0; i < m_vGeomObj.size() ; i++) {
if (m_vGeomObj[i]->m_bUsed == false)
continue;
D3DXMatrixIdentity(&m_vGeomObj[i]->m_matCalculation);
matWldRotate = m_vGeomObj[i]->m_matWldRotate;
matWldTrans = m_vGeomObj[i]->m_matWldTrans;
matWldScale = m_vGeomObj[i]->m_matWldScale;
D3DXQuaternionRotationMatrix(&qR, &matWldRotate);
D3DXQuaternionRotationMatrix(&qS, &matWldScale);
//for (int j = 0; j < m_vGeomObj[i]->m_vObj.size(); j++) {
//if (m_vGeomObj[i].get()->m_bHasAniTrack) {
//Translation
if (m_vGeomObj[i].get()->m_vPosTrack.size() != 0) {
GAnimTrack* pStartTrack = NULL;
GAnimTrack* pEndTrack = NULL;
//현재 Tick이 어디인지 찾자.
GetAnimationTrack(m_fTickFrame, &pStartTrack, &pEndTrack, ANITRACK_TYPE_POS, i);
//애니메이션 보간.
D3DXVECTOR3 vResultVector;
D3DXVECTOR3 vP1 = pStartTrack->vecVector;
D3DXVECTOR3 vP2 = pEndTrack->vecVector;
float fTValue = (m_fTickFrame - pStartTrack->iTick) / (pEndTrack->iTick - pStartTrack->iTick);
if(pStartTrack != pEndTrack){
D3DXVec3Lerp(&vResultVector, &vP1, &vP2, fTValue);
//T행렬 값 대입
matWldTrans._41 = vResultVector.x;
matWldTrans._42 = vResultVector.y;
matWldTrans._43 = vResultVector.z;
}
else {
//T행렬 값 대입
matWldTrans._41 = pStartTrack->vecVector.x;
matWldTrans._42 = pStartTrack->vecVector.y;
matWldTrans._43 = pStartTrack->vecVector.z;
}
}
//Rotation
if (m_vGeomObj[i].get()->m_vRotTrack.size() != 0) {
GAnimTrack* pStartTrack = NULL;
GAnimTrack* pEndTrack = NULL;
//D3DXQUATERNION qR;
//현재 Tick이 어디인지 찾자.
GetAnimationTrack(m_fTickFrame, &pStartTrack, &pEndTrack, ANITRACK_TYPE_ROT, i);
//사원수간의 보간..
if (pStartTrack == NULL && pEndTrack == NULL) {
qR = m_vGeomObj[i].get()->m_vRotTrack[0]->qRotate;// = m_vGeomObj[i].get()->m_qRotation;
}
else if (pStartTrack == NULL) {
qR;// = m_vGeomObj[i].get()->m_qRotation;
float fTValue = (m_fTickFrame - 0) / (pEndTrack->iTick - 0);
D3DXQuaternionSlerp(&qR, &qR, &pEndTrack->qRotate, fTValue);
}
else if (pEndTrack == NULL) {
qR = m_vGeomObj[i].get()->m_vRotTrack[m_vGeomObj[i].get()->m_vRotTrack.size() - 1].get()->qRotate;
float fTValue = ((m_fTickFrame - pStartTrack->iTick) / (m_fFrameSpeed*m_fTickPerFrame));
D3DXQuaternionSlerp(&qR, &qR, &qR, fTValue);
}
else {
qR = pStartTrack->qRotate;
float fTValue = (m_fTickFrame - pStartTrack->iTick) / (pEndTrack->iTick - pStartTrack->iTick);
D3DXQuaternionSlerp(&qR, &qR, &pEndTrack->qRotate, fTValue);
}
//사원수에서 행렬로 변환.
D3DXMatrixRotationQuaternion(&matWldRotate, &qR);// 사원수에서 행렬로 변환
}
//Scale
if (m_vGeomObj[i].get()->m_vSclTrack.size() != 0) {
GAnimTrack* pStartTrack = NULL;
GAnimTrack* pEndTrack = NULL;
D3DXMATRIX matScaleRot, matInvScaleRot;
D3DXMatrixIdentity(&matScaleRot);
D3DXMatrixIdentity(&matInvScaleRot);
//D3DXQUATERNION qS;
float fStartTick = 0.0f, fEndTick = 0.0f;
D3DXVECTOR3 vScale(m_vGeomObj[i].get()->m_matWldScale._11, m_vGeomObj[i].get()->m_matWldScale._22, m_vGeomObj[i].get()->m_matWldScale._33);
//현재 Tick이 어디인지 찾자.
GetAnimationTrack(m_fTickFrame, &pStartTrack, &pEndTrack, ANITRACK_TYPE_SCL, i);
//신축트랙 보간
if (pStartTrack == NULL) {
//vScale = m_vGeomObj[i].get()->m_vecTM_SCALE;
//D3DXQuaternionRotationAxis(&qS, &m_vGeomObj[i].get()->m_vecTM_SCALE_AXIS, m_vGeomObj[i].get()->m_fTM_SCALEAXISANG);
fStartTick = 0.0f;
fEndTick = pEndTrack->iTick;
}
else if (pEndTrack == NULL) {
vScale = pStartTrack->vecVector;
qS = pStartTrack->qRotate;
fStartTick = pStartTrack->iTick;
fEndTick = pStartTrack->iTick + (m_fFrameSpeed*m_fTickPerFrame);
}
else {
vScale = pStartTrack->vecVector;
qS = pStartTrack->qRotate;
fStartTick = pStartTrack->iTick;
fEndTick = pEndTrack->iTick;
}
float fTValue = (m_fTickFrame - fStartTick) / (fEndTick - fStartTick);
D3DXVec3Lerp(&vScale, &vScale, &pEndTrack->vecVector, fTValue);
D3DXQuaternionSlerp(&qS, &qS, &pEndTrack->qRotate, fTValue);
//사원수 -> 행렬로 변환등...
D3DXMatrixScaling(&matWldScale, vScale.x, vScale.y, vScale.z);
D3DXMatrixRotationQuaternion(&matScaleRot, &qS);
D3DXMatrixInverse(&matInvScaleRot, NULL, &matScaleRot);
matWldScale = matInvScaleRot * matWldScale * matScaleRot;
}
if (m_vGeomObj[i].get()->m_pParentObj != NULL) {
m_vGeomObj[i].get()->m_matCalculation = matCalc = matWldScale * matWldRotate * matWldTrans
* m_vGeomObj[i].get()->m_pParentObj->m_matCalculation;
int iTest = 0;
// 인버스 매트릭스 확인 코드.
D3DXVECTOR3 v0, v1, v2, v3;
v0 = m_vGeomObj[i].get()->m_matCalculation.m[0];
v1 = m_vGeomObj[i].get()->m_matCalculation.m[1];
v2 = m_vGeomObj[i].get()->m_matCalculation.m[2];
D3DXVec3Cross(&v3, &v1, &v2);
if (D3DXVec3Dot(&v3, &v0) < 0.0f)
{
D3DXMATRIX matW;
D3DXMatrixScaling(&matW, -1.0f, -1.0f, -1.0f);
D3DXMatrixMultiply(&m_vGeomObj[i].get()->m_matCalculation,
&m_vGeomObj[i].get()->m_matCalculation, &matW);
}
}
else {
m_vGeomObj[i].get()->m_matCalculation = matCalc = matWldScale * matWldRotate * matWldTrans;
int iTest = 0;
// 인버스 매트릭스 확인 코드.
D3DXVECTOR3 v0, v1, v2, v3;
v0 = m_vGeomObj[i].get()->m_matCalculation.m[0];
v1 = m_vGeomObj[i].get()->m_matCalculation.m[1];
v2 = m_vGeomObj[i].get()->m_matCalculation.m[2];
D3DXVec3Cross(&v3, &v1, &v2);
if (D3DXVec3Dot(&v3, &v0) < 0.0f)
{
D3DXMATRIX matW;
D3DXMatrixScaling(&matW, -1.0f, -1.0f, -1.0f);
D3DXMatrixMultiply(&m_vGeomObj[i].get()->m_matCalculation,
&m_vGeomObj[i].get()->m_matCalculation, &matW);
}
}
}
//}
//}
//최종행렬.
}
inline void __Quaternion::operator = (const D3DXMATRIX& mtx)
{
D3DXQuaternionRotationMatrix(this, &mtx);
}
void CKrakenLeg::SwingAttack(float fElapsed)
{
float Distance = 0;
D3DXVECTOR3 CharPos = m_pInplay->GetCharacter()->GetPosition();
Distance = D3DXVec3Length( &D3DXVECTOR3(CharPos - m_vPos) );
if(Distance < 2.0)
{
D3DXMATRIX Rot;
D3DXQUATERNION QuaRot;
D3DXQUATERNION QuaStart;
D3DXQUATERNION QuaSlerp;
D3DXVECTOR3 ZVector(0,0,1);
m_vDirection = m_pInplay->GetCharacter()->GetPosition()- m_vPos;
D3DXMatrixIdentity(&Rot);
Rot._11 = m_pInplay->GetCamera()->GetViewMatrix()->_11;
Rot._13 = m_pInplay->GetCamera()->GetViewMatrix()->_13;
Rot._31 = m_pInplay->GetCamera()->GetViewMatrix()->_31;
Rot._33 = m_pInplay->GetCamera()->GetViewMatrix()->_33;
Rot._41 = m_vPos.x;
Rot._42 = m_vPos.y;
Rot._43 = m_vPos.z;
D3DXMatrixInverse( &Rot, NULL, &Rot );
D3DXQuaternionRotationMatrix( &QuaStart, &m_matRotate);
D3DXQuaternionRotationMatrix( &QuaRot, &Rot);
if( D3DXVec3Dot(&ZVector,&m_vDirection) < 0)
{
D3DXQuaternionSlerp(&QuaSlerp, &QuaRot, &QuaStart, fElapsed);
}
else
{
D3DXQuaternionSlerp(&QuaSlerp, &QuaStart, &QuaRot, fElapsed);
}
D3DXMatrixRotationQuaternion(&Rot,&QuaSlerp);
m_matRotate = Rot;
m_fAttackTimer += fElapsed;
if( m_fAttackTimer >4.0f )
{
ChangeAnimation(1);
}
if( m_fAttackTimer > 5.63f)
{
m_fAnimationTime = 0;
m_pInplay->GetCharacter()->AddHp( -200 ) ;
ChangeAnimation(2);
m_fAttackTimer = 0;
}
}
else
{
ChangeAnimation(2);
}
}
inline __Quaternion::__Quaternion(const D3DXMATRIX& mtx)
{
D3DXQuaternionRotationMatrix(this, &mtx);
}
void _X3PCamera::Advance( void )
{
BOOL changedcamerastatus = FALSE;
FLOAT abscamvel_x = fabs(m_CameraVelocity.x);
FLOAT abscamvel_y = fabs(m_CameraVelocity.y);
FLOAT abscamvel_z = fabs(m_CameraVelocity.z);
FLOAT abscamvel_dist = fabs(m_ZoominoutVelocity);
if( abscamvel_x > EPSILON3 || abscamvel_y > EPSILON3 || abscamvel_z > EPSILON3 || abscamvel_dist > EPSILON3 )
{
if( abscamvel_x > EPSILON3 )
{
m_CameraVelocity.x *= _XDEF_CAMERADECREASERATE;
// add yaw
mp_fYaw += m_CameraVelocity.x;
if( mp_fYaw > 360.0f ) mp_fYaw = (FLOAT)fmod(mp_fYaw, 360.0);
}
if( abscamvel_y > EPSILON3 )
{
m_CameraVelocity.y *= _XDEF_CAMERADECREASERATE;
//add pitch
mp_fPitch += m_CameraVelocity.y;
if(mp_fPitch < mp_fMinPitchLimit) mp_fPitch = mp_fMinPitchLimit;
else if(mp_fPitch > mp_fMaxPitchLimit) mp_fPitch = mp_fMaxPitchLimit;
}
if( abscamvel_z > EPSILON3 )
{
m_CameraVelocity.z *= _XDEF_CAMERADECREASERATE;
//add roll
mp_fRoll += m_CameraVelocity.z;
if(mp_fRoll < mp_fMinRollLimit) mp_fRoll = mp_fMinRollLimit;
else if(mp_fRoll > mp_fMaxRollLimit) mp_fRoll = mp_fMaxRollLimit;
}
if( abscamvel_dist > EPSILON3 )
{
#ifdef _XDWDEBUG
extern BOOL g_MouseLockFlag;
if( !g_MouseLockFlag )
{
#endif
if( m_MinDistance + m_AdditionalHeightMinDistance < m_TargetDistance )
{
m_ZoominoutVelocity *= _XDEF_CAMERAZOOMDECREASERATE;
}
else
{
m_ZoominoutVelocity *= 0.3f;
}
m_TargetDistance += m_ZoominoutVelocity;
if( m_MinDistance > m_TargetDistance )
{
m_TargetDistance = m_MinDistance;
}
else if( m_MaxDistance < m_TargetDistance )
{
m_TargetDistance = m_MaxDistance;
}
#ifdef _XDWDEBUG
}
#endif
}
changedcamerastatus = TRUE;
}
if( m_QuaterViewChanging )
{
D3DXQUATERNION nextrotquat;
D3DXQUATERNION orgrotquat;
D3DXQUATERNION targetrotquat;
D3DXQuaternionRotationYawPitchRoll( &orgrotquat, _X_RAD(mp_fYaw), _X_RAD(mp_fPitch), _X_RAD(mp_fRoll) );
if( m_DefaultViewChanging )
{
D3DXQuaternionRotationYawPitchRoll( &targetrotquat, _X_RAD(-45.0f), _X_RAD(30.0f), 0.0f );
}
else
{
D3DXQuaternionRotationYawPitchRoll( &targetrotquat, _X_RAD(180.0f), _X_RAD(30.0f), 0.0f );
}
FLOAT fElapsedTime = g_fElapsedFrameMilisecondTime*3.0f;
if( fElapsedTime > 1.0f ) fElapsedTime = 1.0f;
D3DXQuaternionSlerp( &nextrotquat, &orgrotquat, &targetrotquat, fElapsedTime );
FLOAT fyaw, fpitch, froll;
_XMeshMath_QuaternionToEulerAngle( nextrotquat, fyaw, fpitch, froll );
fyaw = _X_DEG(fyaw);
if( fyaw > 360.0f ) fyaw = (FLOAT)fmod(fyaw, 360.0);
fpitch = _X_DEG(fpitch);
if(fpitch < mp_fMinPitchLimit) fpitch = mp_fMinPitchLimit;
else if(fpitch > mp_fMaxPitchLimit) fpitch = mp_fMaxPitchLimit;
froll = _X_DEG(froll);
if(froll < mp_fMinRollLimit) froll = mp_fMinRollLimit;
else if(froll > mp_fMaxRollLimit) froll = mp_fMaxRollLimit;
if( fabs( mp_fYaw - fyaw ) > EPSILON1 ||
fabs( mp_fPitch - fpitch ) > EPSILON1 ||
fabs( mp_fRoll - froll ) > EPSILON1 )
{
mp_fYaw = fyaw;
mp_fPitch = fpitch;
mp_fRoll = froll;
changedcamerastatus = TRUE;
}
else
{
m_QuaterViewChanging = FALSE;
m_QuaterViewMode = TRUE;
m_DefaultViewChanging = FALSE;
}
_XWindow_WorldMinimap* pminimapwindow = (_XWindow_WorldMinimap*)g_MainWindowManager.FindWindow( _XDEF_WTITLE_MINIMAPWINDOW );
if( pminimapwindow )
{
// Set direction to minimap arrow
pminimapwindow->SetRotateFrustum( _X_RAD( 180 - mp_fYaw ) );
}
}
else if( m_DefaultViewChanging )
{
D3DXQUATERNION nextrotquat;
D3DXQUATERNION orgrotquat;
D3DXQUATERNION targetrotquat;
D3DXQuaternionRotationYawPitchRoll( &orgrotquat, _X_RAD(mp_fYaw), _X_RAD(mp_fPitch), _X_RAD(mp_fRoll) );
D3DXQuaternionRotationYawPitchRoll( &targetrotquat, _X_RAD(180.0f), _X_RAD(mp_fPitch), 0.0f );
FLOAT fElapsedTime = g_fElapsedFrameMilisecondTime*3.0f;
if( fElapsedTime > 1.0f ) fElapsedTime = 1.0f;
D3DXQuaternionSlerp( &nextrotquat, &orgrotquat, &targetrotquat, fElapsedTime );
FLOAT fyaw, fpitch, froll;
_XMeshMath_QuaternionToEulerAngle( nextrotquat, fyaw, fpitch, froll );
fyaw = _X_DEG(fyaw);
if( fyaw > 360.0f ) fyaw = (FLOAT)fmod(fyaw, 360.0);
fpitch = _X_DEG(fpitch);
if(fpitch < mp_fMinPitchLimit) fpitch = mp_fMinPitchLimit;
else if(fpitch > mp_fMaxPitchLimit) fpitch = mp_fMaxPitchLimit;
froll = _X_DEG(froll);
if(froll < mp_fMinRollLimit) froll = mp_fMinRollLimit;
else if(froll > mp_fMaxRollLimit) froll = mp_fMaxRollLimit;
if( fabs( mp_fYaw - fyaw ) > EPSILON1 ||
fabs( mp_fPitch - fpitch ) > EPSILON1 ||
fabs( mp_fRoll - froll ) > EPSILON1 )
{
mp_fYaw = fyaw;
mp_fPitch = fpitch;
mp_fRoll = froll;
changedcamerastatus = TRUE;
}
else
{
m_DefaultViewChanging = FALSE;
}
_XWindow_WorldMinimap* pminimapwindow = (_XWindow_WorldMinimap*)g_MainWindowManager.FindWindow( _XDEF_WTITLE_MINIMAPWINDOW );
if( pminimapwindow )
{
// Set direction to minimap arrow
pminimapwindow->SetRotateFrustum( _X_RAD( 180 - mp_fYaw ) );
}
}
else
{
if( !gpInput->GetMouseState()->bButton[1] &&
( g_pLocalUser->GetMotionClass() == _XACTION_MOVE &&
( g_pLocalUser->m_PathNodeCount >= 1 || g_pLocalUser->m_LeftFinalTargetLength > 64.0f ) ) &&
(fabs( g_pLocalUser->m_RotateAngle - g_pLocalUser->m_LastRotateAngle ) < EPSILON3) && m_AutoBackTrace )
{
D3DXQUATERNION nextrotquat;
D3DXQUATERNION orgrotquat;
D3DXQUATERNION targetrotquat;
D3DXMATRIX mtxRotate = g_pLocalUser->m_ModelDescriptor.m_Position;
mtxRotate._41 = mtxRotate._42 = mtxRotate._43 = 0.0f;
D3DXQuaternionRotationYawPitchRoll( &orgrotquat, 0.0f, _X_RAD(mp_fPitch), 0.0f );
D3DXQuaternionRotationMatrix( &targetrotquat, &mtxRotate );
D3DXQuaternionMultiply( &targetrotquat, &orgrotquat, &targetrotquat );
D3DXQuaternionRotationYawPitchRoll( &orgrotquat, _X_RAD(mp_fYaw), _X_RAD(mp_fPitch), _X_RAD(mp_fRoll) );
FLOAT fElapsedTime = g_fElapsedFrameMilisecondTime;
if( fElapsedTime > 1.0f ) fElapsedTime = 1.0f;
D3DXQuaternionSlerp( &nextrotquat, &orgrotquat, &targetrotquat, fElapsedTime );
FLOAT fyaw, fpitch, froll;
_XMeshMath_QuaternionToEulerAngle( nextrotquat, fyaw, fpitch, froll );
fyaw = _X_DEG(fyaw);
if( fyaw > 360.0f ) fyaw = (FLOAT)fmod(fyaw, 360.0);
fpitch = _X_DEG(fpitch);
if(fpitch < mp_fMinPitchLimit) fpitch = mp_fMinPitchLimit;
else if(fpitch > mp_fMaxPitchLimit) fpitch = mp_fMaxPitchLimit;
froll = _X_DEG(froll);
if(froll < mp_fMinRollLimit) froll = mp_fMinRollLimit;
else if(froll > mp_fMaxRollLimit) froll = mp_fMaxRollLimit;
if( fabs( mp_fYaw - fyaw ) > EPSILON3 ||
fabs( mp_fPitch - fpitch ) > EPSILON3 ||
fabs( mp_fRoll - froll ) > EPSILON3 )
{
mp_fYaw = fyaw;
mp_fPitch = fpitch;
mp_fRoll = froll;
changedcamerastatus = TRUE;
}
}
}
if( m_CameraShakeMode )
{
if( !m_CameraShakeDelayMode )
{
const FLOAT shakeadditionalfactor = 10.0f;
FLOAT fshakefactor = _XLinearGraph( 0.1f,0.05f, 0.5f,0.0f ).GetValueAt( g_fElapsedFrameMilisecondTime );
m_CameraShakeFactor.x = fshakefactor * sinf(rand());
m_CameraShakeFactor.y = fshakefactor * sinf(rand());
m_CameraShakeFactor.z = fshakefactor * sinf(rand());
D3DXMATRIX matOrientation;
D3DXMatrixInverse( &matOrientation, NULL, &mp_view_matrix );
D3DXVec3TransformNormal( &m_CameraShakeFactor, &m_CameraShakeFactor, &matOrientation );
changedcamerastatus = TRUE;
m_fCameraShakeTimer -= g_fElapsedFrameMilisecondTime;
if( m_fCameraShakeTimer < 0.0f )
{
m_CameraShakeMode = FALSE;
m_CameraShakeFactor = D3DXVECTOR3( 0.0f,0.0f,0.0f );
}
}
else
{
if( g_LocalSystemTime - m_fCameraShakeStartTimer < m_fCameraShakeTimer*1000 )
{
int temp = (int)(((g_LocalSystemTime - m_fCameraShakeStartTimer)/1000.0f)/5.0f)%2;
if( temp == 0 )
{
if( !m_ChangeCameraShakeAtDelayMode )
{
_XPlaySoundEffect(ID_SR_INTERFACE_EARTHQUAKE_WAV, g_pLocalUser->m_Position );
}
const FLOAT shakeadditionalfactor = 10.0f;
FLOAT fshakefactor = _XLinearGraph( 0.05f,0.025f, 0.25f,0.0f ).GetValueAt( g_fElapsedFrameMilisecondTime );
m_CameraShakeFactor.x = fshakefactor * sinf(rand());
m_CameraShakeFactor.y = fshakefactor * sinf(rand());
m_CameraShakeFactor.z = fshakefactor * sinf(rand());
D3DXMATRIX matOrientation;
D3DXMatrixInverse( &matOrientation, NULL, &mp_view_matrix );
D3DXVec3TransformNormal( &m_CameraShakeFactor, &m_CameraShakeFactor, &matOrientation );
changedcamerastatus = TRUE;
m_ChangeCameraShakeAtDelayMode = TRUE;
}
else
{
if( m_ChangeCameraShakeAtDelayMode )
{
_XPlaySoundEffect(ID_SR_INTERFACE_EARTHQUAKE01_WAV, g_pLocalUser->m_Position );
}
m_ChangeCameraShakeAtDelayMode = FALSE;
}
}
else
{
m_CameraShakeMode = FALSE;
m_CameraShakeFactor = D3DXVECTOR3( 0.0f,0.0f,0.0f );
}
}
}
if( changedcamerastatus )
{
UpdateViewMatrix( &g_LodTerrain, TRUE );
g_LodTerrain.m_ObjectQuadTree.UpdateCamera(g_LodTerrain.m_3PCamera);
g_LodTerrain.RebuildLevel();
}
}
void IK::solve()
{
//don't solve anything if this chain is simulated
if (checkSimulated())
return;
//set up local variables used in solving the IK chain
AMBone* destBone = _info.DestinationBone;
AMBone* endEffBone = _info.EndEffectorBone;
AMBone* curBone = NULL;
D3DXVECTOR3 dest = D3DXVECTOR3(destBone->getCombinedTrans()(3,0), destBone->getCombinedTrans()(3,1), destBone->getCombinedTrans()(3,2));
//lol I still have no clue how this crazy shit works
//algorithm is pretty much taken directly from MMD
IKLink *cl;
BoneInfo *ci;
for (int i=0;i<(int)_info.IterationCount;i++)
{
for (int b=0;b<(int)_info.NumberOfLinks;b++)
{
cl = &_info.BoneLinkList[b];
curBone = cl->LinkBone;
ci = curBone->getInfo();
D3DXVECTOR3 left = curBone->getPosWorld()-endEffBone->getPosWorld();
D3DXVECTOR3 right = curBone->getPosWorld()-destBone->getPosWorld();
D3DXVECTOR3 axis;
D3DXVECTOR3 vec = left - right;
if (D3DXVec3Length(&vec)*D3DXVec3Length(&vec) < 1E-04f)
{
i = _info.IterationCount;
break;
}
D3DXVec3Normalize(&left, &left);
D3DXVec3Normalize(&right, &right);
D3DXVec3Cross(&axis, &left, &right);
if (D3DXVec3Length(&axis)*D3DXVec3Length(&axis) < 1E-7 && i > 0)
continue;
D3DXVec3Normalize(&axis, &axis);
/*if (cl->AngleLimit && i < _info.IterationCount/2)
{
if (cl->LowerLimit.y == 0.0f && cl->UpperLimit.y == 0.0f && cl->LowerLimit.z == 0.0f && cl->UpperLimit.z == 0.0f)
{
float n = (axis.x*ci->Parent->getCombinedTrans()._11) + (axis.y*ci->Parent->getCombinedTrans()._12) + (axis.z*ci->Parent->getCombinedTrans()._13);
if (n >= 0.0f)
axis.x = 1.0f;
else
axis.x = -1.0f;
axis.y = 0.0f;
axis.z = 0.0f;
}
else
{
if (cl->LowerLimit.x == 0.0f && cl->UpperLimit.x == 0.0f && cl->LowerLimit.z == 0.0f && cl->UpperLimit.z == 0.0f)
{
float n = (axis.x*ci->Parent->getCombinedTrans()._21) + (axis.y*ci->Parent->getCombinedTrans()._22) + (axis.z*ci->Parent->getCombinedTrans()._23);
if (n >= 0.0f)
axis.y = 1.0f;
else
axis.y = -1.0f;
axis.x = 0.0f;
axis.z = 0.0f;
}
else
{
if (cl->LowerLimit.x == 0.0f && cl->UpperLimit.x == 0.0f && cl->LowerLimit.y == 0.0f && cl->UpperLimit.y == 0.0f)
{
float n = (axis.x*ci->Parent->getCombinedTrans()._31) + (axis.y*ci->Parent->getCombinedTrans()._32) + (axis.z*ci->Parent->getCombinedTrans()._33);
if (n >= 0.0f)
axis.z = 1.0f;
else
axis.z = -1.0f;
axis.x = 0.0f;
axis.y = 0.0f;
}
else
{
D3DXVECTOR3 v;
v.x = (axis.x*curBone->getCombinedTrans()._11)+(axis.y*curBone->getCombinedTrans()._12)+(axis.z*curBone->getCombinedTrans()._13);
v.y = (axis.x*curBone->getCombinedTrans()._21)+(axis.y*curBone->getCombinedTrans()._22)+(axis.z*curBone->getCombinedTrans()._23);
v.z = (axis.x*curBone->getCombinedTrans()._31)+(axis.y*curBone->getCombinedTrans()._32)+(axis.z*curBone->getCombinedTrans()._33);
D3DXVec3Normalize(&axis, &v);
}
}
}
}
else*/
{
D3DXVECTOR3 v;
v.x = (axis.x*curBone->getCombinedTrans()._11)+(axis.y*curBone->getCombinedTrans()._12)+(axis.z*curBone->getCombinedTrans()._13);
v.y = (axis.x*curBone->getCombinedTrans()._21)+(axis.y*curBone->getCombinedTrans()._22)+(axis.z*curBone->getCombinedTrans()._23);
v.z = (axis.x*curBone->getCombinedTrans()._31)+(axis.y*curBone->getCombinedTrans()._32)+(axis.z*curBone->getCombinedTrans()._33);
D3DXVec3Normalize(&axis, &v);
}
float dot = D3DXVec3Dot(&left, &right);
if (dot > 1.0f)
dot = 1.0f;
else if (dot < -1.0f)
dot = -1.0f;
float angle = acosf(dot);
if (angle > (_info.AngleConstraint * (b+1)*2))
{
angle = (_info.AngleConstraint * (b+1)*2);
}
D3DXQUATERNION newIkRot;
D3DXQuaternionRotationAxis(&newIkRot, &axis, angle);
D3DXQuaternionMultiply(&cl->IKQuat, &newIkRot, &cl->IKQuat);
if (i == 0) //on first loop, apply rotation taken from the motion data
D3DXQuaternionMultiply(&cl->IKQuat, &cl->IKQuat, &curBone->getRot());
D3DXMATRIX matrix;
D3DXMatrixRotationQuaternion(&matrix, &cl->IKQuat);
if (cl->AngleLimit)
{
if ((double)cl->LowerLimit.x > -1.5707963267948966 && (double)cl->UpperLimit.x < 1.5707963267948966)
{
float num5 = -matrix._32;
float num6 = asinf(num5);
if (abs(num6) > 1.535889f)
{
if (num6 < 0.0f)
num6 = -1.535889f;
else
num6 = 1.535889f;
}
float num7 = cosf(num6);
float num8 = matrix._31/num7;
float num9 = matrix._33/num7;
float num10 = atan2f(num8, num9);
float num11 = matrix._12/num7;
float num12 = matrix._22/num7;
float num13 = atan2f(num11, num12);
bool loopFlag = i<(int)_info.IterationCount/2;
num6 = GetUpperLowerRadian(num6, cl->LowerLimit.x, cl->UpperLimit.x, loopFlag);
num10 = GetUpperLowerRadian(num10, cl->LowerLimit.y, cl->UpperLimit.y, loopFlag);
num13 = GetUpperLowerRadian(num13, cl->LowerLimit.z, cl->UpperLimit.z, loopFlag);
D3DXMATRIX nx, ny, nz;
D3DXMatrixRotationX(&nx, num6);
D3DXMatrixRotationY(&ny, num10);
D3DXMatrixRotationZ(&nz, num13);
matrix = nz*nx*ny;
}
else
{
if ((double)cl->LowerLimit.y > -1.5707963267948966 && (double)cl->UpperLimit.y < 1.5707963267948966)
{
float num14 = -matrix._13;
float num15 = asinf(num14);
if (abs(num15) > 1.535889f)
{
if (num15 < 0.0f)
{
num15 = -1.535889f;
}
else
{
num15 = 1.535889f;
}
}
float num16 = cosf(num15);
float num17 = matrix._23 / num16;
float num18 = matrix._33 / num16;
float num19 = atan2f(num17, num18);
float num20 = matrix._12 / num16;
float num21 = matrix._11 / num16;
float num22 = atan2f(num20, num21);
bool loopFlag = i<(int)_info.IterationCount/2;
num19 = GetUpperLowerRadian(num19, cl->LowerLimit.x, cl->UpperLimit.x, loopFlag);
num15 = GetUpperLowerRadian(num15, cl->LowerLimit.y, cl->UpperLimit.y, loopFlag);
num22 = GetUpperLowerRadian(num22, cl->LowerLimit.z, cl->UpperLimit.z, loopFlag);
D3DXMATRIX nx, ny, nz;
D3DXMatrixRotationX(&nx, num19);
D3DXMatrixRotationY(&ny, num15);
D3DXMatrixRotationZ(&nz, num22);
matrix = nx*ny*nz;
}
else
{
float num23 = -matrix._21;
float num24 = asinf(num23);
if (abs(num24) > 1.535889f)
{
if (num24 < 0.0f)
{
num24 = -1.535889f;
}
else
{
num24 = 1.535889f;
}
}
float num25 = cosf(num24);
float num26 = matrix._23 / num25;
float num27 = matrix._22 / num25;
float num28 = atan2f(num26, num27);
float num29 = matrix._31 / num25;
float num30 = matrix._11 / num25;
float num31 = atan2f(num29, num30);
bool loopFlag = i<(int)_info.IterationCount/2;
num28 = GetUpperLowerRadian(num28, cl->LowerLimit.x, cl->UpperLimit.x, loopFlag);
num31 = GetUpperLowerRadian(num31, cl->LowerLimit.y, cl->UpperLimit.y, loopFlag);
num24 = GetUpperLowerRadian(num24, cl->LowerLimit.z, cl->UpperLimit.z, loopFlag);
D3DXMATRIX nx, ny, nz;
D3DXMatrixRotationX(&nx, num28);
D3DXMatrixRotationY(&ny, num31);
D3DXMatrixRotationZ(&nz, num24);
matrix = ny*nz*nx;
}
}
D3DXQuaternionRotationMatrix(&cl->IKQuat, &matrix);
}
curBone->setRot(cl->IKQuat);
//curBone->setCombTrans(matrix);
for (int j=b;j>=0;j--)
{
_info.BoneLinkList[j].LinkBone->UpdateFromIK();
}
endEffBone->UpdateFromIK();
}
}
for (int i=0;i<(int)_info.NumberOfLinks;i++)
{
_info.BoneLinkList[i].IKQuat = D3DXQUATERNION(0,0,0,1);
}
}
D3DXMATRIX GAnimation::Interpolate(GMesh* pMesh, D3DXMATRIX* matParents, float fFrameTick, TScene tScene)
{
// TM = AnimMat * ParentTM;
// AaniMat = TM * Inverse(ParentTM)
D3DXQUATERNION qR, qS;
D3DXMATRIX matAnim, matPos, matRotate, matScale, matCalculation;
D3DXMatrixIdentity(&matCalculation);
matRotate = pMesh->m_matWorldRotate;
matPos = pMesh->m_matWorldTrans;
matScale = pMesh->m_matWorldScale;
D3DXQuaternionRotationMatrix(&qR, &matRotate);
D3DXQuaternionRotationMatrix(&qS, &matScale);
// fFrameTick = m_Scene.iFirstFrame * m_Scene.iTickPerFrame + CurFame;
float fStartTick = tScene.iFirstFrame * tScene.iTickPerFrame;
float fEndTick = 0.0f;
TAnimTrack* pStartTrack = NULL;
TAnimTrack* pEndTrack = NULL;
if (pMesh->m_pRotTrack.size())
{
// pStartTrack를 찾을수 있으면
if (GetAnimationTrack(fFrameTick, pMesh->m_pRotTrack, &pStartTrack, &pEndTrack))
{
qR = pStartTrack->qRotate;
fStartTick = pStartTrack->iTick;
}
if (pEndTrack)
{
fEndTick = pEndTrack->iTick;
D3DXQuaternionSlerp(&qR, &qR, &pEndTrack->qRotate, (fFrameTick - fStartTick) / (fEndTick - fStartTick));
}
D3DXMatrixRotationQuaternion(&matRotate, &qR);
}
pStartTrack = NULL;
pEndTrack = NULL;
D3DXVECTOR3 Trans(matPos._41, matPos._42, matPos._43);
if (pMesh->m_pPosTrack.size())
{
// pStartTrack를 찾을수 있으면
if (GetAnimationTrack(fFrameTick, pMesh->m_pPosTrack, &pStartTrack, &pEndTrack))
{
Trans = pStartTrack->vVector;
fStartTick = pStartTrack->iTick;
}
if (pEndTrack)
{
fEndTick = pEndTrack->iTick;
D3DXVec3Lerp(&Trans, &Trans, &pEndTrack->vVector, (fFrameTick - fStartTick) / (fEndTick - fStartTick));
}
D3DXMatrixTranslation(&matPos, Trans.x, Trans.y, Trans.z);
}
pStartTrack = NULL;
pEndTrack = NULL;
D3DXMATRIX matScaleRot, matInvScaleRot;
D3DXVECTOR3 vScale(matScale._11, matScale._22, matScale._33);
if (pMesh->m_pSclTrack.size())
{
// pStartTrack를 찾을수 있으면
if (GetAnimationTrack(fFrameTick, pMesh->m_pSclTrack, &pStartTrack, &pEndTrack))
{
vScale = pStartTrack->vVector;
qS = pStartTrack->qRotate;
fStartTick = pStartTrack->iTick;
}
if (pEndTrack)
{
fEndTick = pEndTrack->iTick;
D3DXVec3Lerp(&vScale, &vScale, &pEndTrack->vVector, (fFrameTick - fStartTick) / (fEndTick - fStartTick));
D3DXQuaternionSlerp(&qS, &qS, &pEndTrack->qRotate, (fFrameTick - fStartTick) / (fEndTick - fStartTick));
}
D3DXMatrixScaling(&matScale, vScale.x, vScale.y, vScale.z);
D3DXMatrixRotationQuaternion(&matScaleRot, &qS);
D3DXMatrixInverse(&matInvScaleRot, NULL, &matScaleRot);
matScale = matInvScaleRot * matScale * matScaleRot;
}
pStartTrack = NULL;
pEndTrack = NULL;
float fCurAlpha, fNextAlpha, fOffSet;
fCurAlpha = 0.0f;
fNextAlpha = 0.0f;
if (pMesh->m_pVisTrack.size())
{
// pStartTrack를 찾을수 있으면
if (GetAnimationTrack(fFrameTick, pMesh->m_pVisTrack, &pStartTrack, &pEndTrack))
{
fCurAlpha = pStartTrack->vVector.x;
fStartTick = pStartTrack->iTick;
}
if (pEndTrack)
{
fNextAlpha = pEndTrack->vVector.x;
fEndTick = pEndTrack->iTick;
fOffSet = (fFrameTick - fStartTick) / (fEndTick - fStartTick);
fNextAlpha = (fNextAlpha - fCurAlpha)*fOffSet;
}
pMesh->m_fVisibility = (fCurAlpha + fNextAlpha);
}
else
{
pMesh->m_fVisibility = 1.0f;
}
D3DXMatrixMultiply(&matAnim, &matScale, &matRotate);
matAnim._41 = matPos._41;
matAnim._42 = matPos._42;
matAnim._43 = matPos._43;
// 최종 에미메이션 행렬을 완성한다.
D3DXMatrixMultiply(&matCalculation, &matAnim, matParents);
// 인버스 매트릭스 확인 코드.
D3DXVECTOR3 v0, v1, v2, v3;
v0 = pMesh->m_matCalculation.m[0];
v1 = pMesh->m_matCalculation.m[1];
v2 = pMesh->m_matCalculation.m[2];
D3DXVec3Cross(&v3, &v1, &v2);
if (D3DXVec3Dot(&v3, &v0) < 0.0f)
{
D3DXMATRIX matW;
D3DXMatrixScaling(&matW, -1.0f, -1.0f, -1.0f);
D3DXMatrixMultiply(&matCalculation, &pMesh->m_matCalculation, &matW);
}
return matCalculation;
}
void zz_bone::apply_channel_by_time (zz_time time, zz_motion * motion, int custum_fps, float blend_weight)
{
assert(motion && "apply_channel_by_time");
assert(blend_weight >= 0.0f && blend_weight <= 1.0f && "apply_channel_by_time");
if (position_channel_index >= 0) {
if (blend_weight < 1.0f) { // if use blend_weight
vec3 last_position = position;
motion->get_channel_data(position_channel_index, time, &position, custum_fps);
position = znzin->motion_tool.blend_position(last_position, position, blend_weight);
}
else { // no blend
motion->get_channel_data(position_channel_index, time, &position, custum_fps);
}
}
if (rotation_channel_index >= 0) {
if(!forced_rotation_onoff)
{
if (blend_weight < 1.0f) { // if use blend_weight
quat last_rotation = rotation;
motion->get_channel_data(rotation_channel_index, time, &rotation, custum_fps);
rotation = znzin->motion_tool.blend_rotation(last_rotation, rotation, blend_weight);
}
else { // no blend
motion->get_channel_data(rotation_channel_index, time, &rotation, custum_fps);
}
}
else
{
if(forced_rotation_calculate_onoff)
{
float diff_time = znzin->get_diff_time();
const float angle_per_time = 0.3f*3.141592f / ZZ_TICK_PER_SEC;
float new_angle_diff = angle_per_time * diff_time;
if( forced_rotation_angle_ + new_angle_diff > forced_rotation_angle)
{
forced_rotation_angle_ = forced_rotation_angle;
forced_rotation_calculate_onoff = false;
}
else
{
forced_rotation_angle_ += new_angle_diff;
}
}
D3DXQUATERNION dx_quat;
D3DXMATRIX buffer_m;
D3DXMATRIX buffer_m2, buffer_m3;
dx_quat.x = forcde_rotation_quat.x; dx_quat.y = forcde_rotation_quat.y; dx_quat.z = forcde_rotation_quat.z; dx_quat.w = forcde_rotation_quat.w;
D3DXMatrixRotationQuaternion(&buffer_m, &dx_quat);
D3DXMatrixRotationAxis(&buffer_m2, &forced_rotation_axis, forced_rotation_angle_);
buffer_m3 = buffer_m2 * buffer_m;
D3DXQuaternionRotationMatrix(&dx_quat, &buffer_m3);
rotation.x = dx_quat.x; rotation.y = dx_quat.y; rotation.z = dx_quat.z; rotation.w = dx_quat.w;
}
}
//invalidate_transform();
}
int CGPAnim::CalcFrameData( CShdHandler* lpsh, CMotHandler* lpmh, D3DXMATRIX* matWorld )
{
int ret;
int frameno;
if( !m_firstkey ) {
for( frameno = 0; frameno <= m_maxframe; frameno++ ) {
( m_framedata + frameno )->m_frameno = frameno;
( m_framedata + frameno )->m_gpe = *m_defgpeptr;
( m_framedata + frameno )->m_interp = *m_definterptr;
( m_framedata + frameno )->m_keyflag = 0;
}
return 0;//!!!!!!!
}
CGPKey* gpkptr = m_firstkey;
#ifdef INEASY3D
while( gpkptr ) {
CQuaternion orgq;
CQuaternion qx, qy, qz;
D3DXVECTOR3 axisX( 1.0f, 0.0f, 0.0f );
D3DXVECTOR3 axisY( 0.0f, 1.0f, 0.0f );
D3DXVECTOR3 axisZ( 0.0f, 0.0f, 1.0f );
qx.SetAxisAndRot( axisX, gpkptr->m_gpe.rot.x * (float)DEG2PAI );
qy.SetAxisAndRot( axisY, gpkptr->m_gpe.rot.y * (float)DEG2PAI );
qz.SetAxisAndRot( axisZ, gpkptr->m_gpe.rot.z * (float)DEG2PAI );
orgq = qy * qx * qz;
D3DXMATRIX orgmat;
orgmat = orgq.MakeRotMatX();
orgmat._41 = gpkptr->m_gpe.pos.x;
orgmat._42 = gpkptr->m_gpe.pos.y;
orgmat._43 = gpkptr->m_gpe.pos.z;
/////////
D3DXMATRIX multmat;
multmat = orgmat * *m_offmatptr;
//multmat = *m_offmatptr * orgmat;
gpkptr->m_gpe.e3dpos.x = multmat._41;
gpkptr->m_gpe.e3dpos.y = multmat._42;
gpkptr->m_gpe.e3dpos.z = multmat._43;
//////////
D3DXMATRIX rotmat;
rotmat = multmat;
rotmat._41 = 0.0f;
rotmat._42 = 0.0f;
rotmat._43 = 0.0f;
D3DXQUATERNION mqx, invmqx;
D3DXQuaternionRotationMatrix( &mqx, &rotmat );
D3DXQuaternionInverse( &invmqx, &mqx );
CQuaternion mq;
mq.x = mqx.x;
mq.y = mqx.y;
mq.z = mqx.z;
mq.w = mqx.w;
D3DXVECTOR3 neweul;
ret = qToEuler( 0, &mq, &neweul );
ret = modifyEuler( &neweul, &gpkptr->m_gpe.e3drot );
gpkptr->m_gpe.e3drot = neweul;
gpkptr = gpkptr->next;
}
#endif
//キーの接地計算
//CGPKey* gpkptr = m_firstkey;
gpkptr = m_firstkey;
if( lpsh ) {
while( gpkptr ) {
if( gpkptr->m_gpe.ongmode != GROUND_NONE ) {
//D3DXMATRIX inimat;
//D3DXMatrixIdentity( &inimat );
D3DXVECTOR3 befpos, newpos;
#ifdef INEASY3D
befpos = gpkptr->m_gpe.e3dpos;
befpos.y = gpkptr->m_gpe.rayy + m_offmatptr->_42;
newpos = gpkptr->m_gpe.e3dpos;
newpos.y = gpkptr->m_gpe.rayy - gpkptr->m_gpe.rayleng;
int result = 0;
D3DXVECTOR3 adjustv, nv;
ret = lpsh->ChkConfGround( 0, 0, matWorld, befpos, newpos, lpmh, 0, 200.0f, newpos.y - 100.0f, &result, &adjustv, &nv );
if( ret ) {
DbgOut( "GPAnim : CalcFrameData : sh ChkConfGround error !!!\n" );
_ASSERT( 0 );
return 1;
}
if( result ) {
gpkptr->m_gpe.e3dpos = adjustv;
gpkptr->m_gpe.e3dpos.y += gpkptr->m_gpe.offsety;
}
#else
befpos = gpkptr->m_gpe.pos;
befpos.y = gpkptr->m_gpe.rayy;
newpos = gpkptr->m_gpe.pos;
newpos.y = gpkptr->m_gpe.rayy - gpkptr->m_gpe.rayleng;
int result = 0;
D3DXVECTOR3 adjustv, nv;
ret = lpsh->ChkConfGround( 0, 0, matWorld, befpos, newpos, lpmh, 0, 200.0f, newpos.y - 100.0f, &result, &adjustv, &nv );
if( ret ) {
DbgOut( "GPAnim : CalcFrameData : sh ChkConfGround error !!!\n" );
_ASSERT( 0 );
return 1;
}
if( result ) {
gpkptr->m_gpe.pos = adjustv;
gpkptr->m_gpe.pos.y += gpkptr->m_gpe.offsety;
}
#endif
}
gpkptr = gpkptr->next;
}
}
CGPKey* prevkey = 0;
CGPKey* nextkey = 0;
for( frameno = 0; frameno <= m_maxframe; frameno++ ) {
CGPKey* dstkey = m_framedata + frameno;
dstkey->m_frameno = frameno;
int findkey = 0;
CGPKey* tmpkey = 0;
ExistGPKey( frameno, &tmpkey );
if( tmpkey ) {
findkey = 1;
prevkey = tmpkey;
}
if( prevkey ) {
nextkey = prevkey->next;
}
dstkey->m_keyflag = findkey;
if( findkey ) {
dstkey->m_gpe = prevkey->m_gpe;
dstkey->m_interp = prevkey->m_interp;
} else if( !prevkey ) {
dstkey->m_gpe = *m_defgpeptr;
dstkey->m_interp = *m_definterptr;
} else if( !nextkey ) {
dstkey->m_gpe = prevkey->m_gpe;
dstkey->m_interp = prevkey->m_interp;
} else {
dstkey->m_interp = prevkey->m_interp;
int framenum;
framenum = nextkey->m_frameno - prevkey->m_frameno;
int framecnt;
framecnt = frameno - prevkey->m_frameno;
//DbgOut( "check!!! : GPAnim : CalcFrameData : frameno %d, maxframe %d, framenum %d, framecnt %d\r\n",
// frameno, m_maxframe, framenum, framecnt );
ret = FillUpGPElem( prevkey, nextkey, &dstkey->m_gpe, framenum, framecnt, prevkey->m_interp, lpsh, lpmh, matWorld );
if( ret ) {
DbgOut( "GPAnim : CalcFrameData : FillUpGPElem error !!!\n" );
_ASSERT( 0 );
return 1;
}
}
}
return 0;
}
HRESULT GdsNode::Update( float fElapsedtime )
{
if ( m_bCull )
return FALSE;
D3DXMATRIX matTrans, matScale, matRot;
D3DXMatrixIdentity( &matTrans );
D3DXMatrixIdentity( &matScale );
D3DXMatrixIdentity( &matRot );
D3DXMatrixTranslation(&matTrans, m_vTranslate.x, m_vTranslate.y, m_vTranslate.z);
D3DXMatrixScaling(&matScale, m_vScale.x, m_vScale.y, m_vScale.z);
D3DXMatrixRotationQuaternion(&matRot, &m_qRotate);
m_matLocal = matTrans * matRot * matScale;
if( GetParent() )
{
D3DXMATRIX parTM;
parTM = GetParent()->GetWorldMatrix();
//m_matWorld = m_matLocal * m_matAni * m_pParent->GetWorldMatrix();
m_matWorld = m_matLocal * parTM;
}
else
{
m_matWorld = m_matLocal;
}
m_vWorldTranslate = D3DXVECTOR3(m_matWorld._41, m_matWorld._42, m_matWorld._43 ) ;
D3DXQuaternionRotationMatrix(&m_qWorldRotate, &m_matWorld);
// 뷰 판정
if ( CAMMGR.GetCurCam()->GetFrustum().VertexIsInFrustum( m_vWorldTranslate ) == false )
{
return FALSE;
}
if ( m_bShowAxis )
{
D3DXVECTOR3 cenPos( 5.f , 5.f , 5.f );
RENDERER.DrawAxis( m_matWorld , cenPos );
}
if ( m_bShowBox )
{
D3DXVECTOR3 minPos( -10.f , -10.f , -10.f );
D3DXVECTOR3 maxPos( 10.f , 10.f , 10.f );
RENDERER.DrawBox( m_matWorld , minPos , maxPos );
}
if ( m_bUseOctree )
{
GenOctreeFaceIndex();
}
if ( !m_list_RenderObject.empty() )
{
RENDER_OBJECT_CONTAINER::iterator it = m_list_RenderObject.begin();
for ( ; it != m_list_RenderObject.end() ; ++it )
{
it->first->SetMatrix( m_matWorld );
//RENDERER.GetRenderFrame()->AttachRenderObject( it->first , it->second );
}
}
vUpdate( fElapsedtime );
if ( !m_ChildNode.empty() )
{
for( CHILDNODE_CONTAINER::iterator it = m_ChildNode.begin() ; it != m_ChildNode.end() ; ++it )
{
(*it)->Update(fElapsedtime);
}
}
return TRUE;
}