D3DXVECTOR3 rotateVec3ByQuat(const D3DXVECTOR3 *vec, const D3DXQUATERNION *quat)
{
D3DXQUATERNION conj, res;
D3DXQuaternionConjugate(&conj,quat);
res = conj*D3DXQUATERNION(vec->x, vec->y, vec->z,1.f)*(*quat);
return D3DXVECTOR3(res.x,res.y,res.z);
}
// used for finding the location of a part of the body in real coordinates
// to find the location of a real point in body coordinates, set inverse to true
D3DXVECTOR3 CBody::RotateVector(const D3DXVECTOR3& vec, bool inverse) const
{
D3DXVECTOR3 returnVec;
D3DXQUATERNION qPoint(vec.x, vec.y, vec.z, 0.0f);
D3DXQUATERNION orientationConjugate;
D3DXQuaternionConjugate(&orientationConjugate, &m_orientation);
D3DXQUATERNION qFinalPoint;
if (inverse)
{
qFinalPoint = orientationConjugate * qPoint * m_orientation;
}
else
{
qFinalPoint = m_orientation * qPoint * orientationConjugate;
}
// debugf("qFinalPoint x: %f\ty:%f\tz:%f\tw:%f\n", qFinalPoint.x, qFinalPoint.y, qFinalPoint.z, qFinalPoint.w);
assert(qFinalPoint.w < 0.0001 && qFinalPoint.w > -0.0001);
returnVec.x = qFinalPoint.x;
returnVec.y = qFinalPoint.y;
returnVec.z = qFinalPoint.z;
return returnVec;
}
// Putting this here until I find a better place for it!
D3DXVECTOR3 *D3DXVec3Rotate( D3DXVECTOR3 *pOut, const D3DXVECTOR3 *pV, const D3DXQUATERNION *pQ )
{
D3DXQUATERNION q1, q2;
D3DXQuaternionConjugate( &q1, pQ );
q2 = q1 * D3DXQUATERNION( pV->x, pV->y, pV->z, 1.0f ) * (*pQ);
*pOut = D3DXVECTOR3( q2.x, q2.y, q2.z );
return pOut;
}
D3DXVECTOR3* D3DXVec3Rotation(D3DXVECTOR3* pvtOut, const D3DXVECTOR3* c_pvtSrc, const D3DXQUATERNION* c_pqtRot)
{
D3DXQUATERNION qtSrc(c_pvtSrc->x, c_pvtSrc->y, c_pvtSrc->z, 0);
D3DXQUATERNION qtRet;
D3DXQuaternionConjugate(&qtRet, c_pqtRot);
D3DXQuaternionMultiply(&qtRet, &qtSrc, &qtRet);
D3DXQuaternionMultiply(&qtRet, c_pqtRot, &qtRet);
pvtOut->x=qtRet.x;
pvtOut->y=qtRet.y;
pvtOut->z=qtRet.z;
return pvtOut;
}
void Camera::moveCameraViewRelative(FLOAT x, FLOAT y, FLOAT z)
{
D3DXVECTOR3 dir(0,0,1);
D3DXVECTOR3 up = m_up;
D3DXVECTOR3 right;
D3DXQUATERNION conj;
D3DXQuaternionConjugate(&conj, &m_orientation);
dir = MathUtil::rotateVec3ByQuat(&dir,&conj);
up = MathUtil::rotateVec3ByQuat(&up,&conj);
D3DXVec3Cross(&right, &up, &dir);
m_translation -= x*right + y*up + z*dir;
m_viewCacheValid = false;
}
bool CPythonItem::TGroundItemInstance::Update()
{
if (bAnimEnded)
return false;
if (dwEndTime < CTimer::Instance().GetCurrentMillisecond())
{
ThingInstance.SetRotationQuaternion(qEnd);
/*D3DXVECTOR3 v3Adjust = -v3Center;
D3DXMATRIX mat;
D3DXMatrixRotationYawPitchRoll(&mat,
D3DXToRadian(rEnd.y),
D3DXToRadian(rEnd.x),
D3DXToRadian(rEnd.z));
D3DXVec3TransformCoord(&v3Adjust,&v3Adjust,&mat);*/
D3DXQUATERNION qAdjust(-v3Center.x, -v3Center.y, -v3Center.z, 0.0f);
D3DXQUATERNION qc;
D3DXQuaternionConjugate(&qc, &qEnd);
D3DXQuaternionMultiply(&qAdjust,&qAdjust,&qEnd);
D3DXQuaternionMultiply(&qAdjust,&qc,&qAdjust);
ThingInstance.SetPosition(v3EndPosition.x+qAdjust.x,
v3EndPosition.y+qAdjust.y,
v3EndPosition.z+qAdjust.z);
//ThingInstance.Update();
bAnimEnded = true;
__PlayDropSound(eDropSoundType, v3EndPosition);
}
else
{
DWORD time = CTimer::Instance().GetCurrentMillisecond() - dwStartTime;
DWORD etime = dwEndTime - CTimer::Instance().GetCurrentMillisecond();
float rate = time * 1.0f / (dwEndTime - dwStartTime);
D3DXVECTOR3 v3NewPosition=v3EndPosition;// = rate*(v3EndPosition - v3StartPosition) + v3StartPosition;
v3NewPosition.z += 100-100*rate*(3*rate-2);//-100*(rate-1)*(3*rate+2);
D3DXQUATERNION q;
D3DXQuaternionRotationAxis(&q, &v3RotationAxis, etime * 0.03f *(-1+rate*(3*rate-2)));
//ThingInstance.SetRotation(rEnd.y + etime*rStart.y, rEnd.x + etime*rStart.x, rEnd.z + etime*rStart.z);
D3DXQuaternionMultiply(&q,&qEnd,&q);
ThingInstance.SetRotationQuaternion(q);
D3DXQUATERNION qAdjust(-v3Center.x, -v3Center.y, -v3Center.z, 0.0f);
D3DXQUATERNION qc;
D3DXQuaternionConjugate(&qc, &q);
D3DXQuaternionMultiply(&qAdjust,&qAdjust,&q);
D3DXQuaternionMultiply(&qAdjust,&qc,&qAdjust);
ThingInstance.SetPosition(v3NewPosition.x+qAdjust.x,
v3NewPosition.y+qAdjust.y,
v3NewPosition.z+qAdjust.z);
/*D3DXVECTOR3 v3Adjust = -v3Center;
D3DXMATRIX mat;
D3DXMatrixRotationYawPitchRoll(&mat,
D3DXToRadian(rEnd.y + etime*rStart.y),
D3DXToRadian(rEnd.x + etime*rStart.x),
D3DXToRadian(rEnd.z + etime*rStart.z));
D3DXVec3TransformCoord(&v3Adjust,&v3Adjust,&mat);
//Tracef("%f %f %f\n",v3Adjust.x,v3Adjust.y,v3Adjust.z);
v3NewPosition += v3Adjust;
ThingInstance.SetPosition(v3NewPosition.x, v3NewPosition.y, v3NewPosition.z);*/
}
ThingInstance.Transform();
ThingInstance.Deform();
return !bAnimEnded;
}
bool FX_CSkinRenderer::TransformMesh ( Fx_CHARACTER_t *in_char,
const FX_CMesh *pMesh,
const KEYFRAME *pKeyFrames,
const int in_sysVBNum,
const int in_skinPartID )
{
int index;
UINT subindex;
int globalBoneID;
TEXTUREVERTEX *sysVB;
float numToMultiply;
sysVB = m_vertexBuffer;
for ( index = 0; \
index < in_sysVBNum; \
++index, ++sysVB )
{
sysVB ->vecPos [0] = sysVB ->vecPos [1] = sysVB ->vecPos [2] = 0.0f;
sysVB ->vecNormal [0] = sysVB ->vecNormal [1] = sysVB ->vecNormal [2] = 0.0f;
m_pVertexMap = &pMesh->m_meshes[ in_char->stat_LODLevel ].meshchunk->vertexMaps[ index ];
m_pInfluence = &pMesh->m_meshes[ in_char->stat_LODLevel ].influences[ m_pVertexMap->iVertexID ];
if ( 1 == m_pInfluence->iNumBoneInfluences )
{
m_pBoneInfluence = &m_pInfluence->boneInfluences [0];
globalBoneID = m_pSkelManager->m_iBoneLookUp[ in_char->attr_skelID ][ m_pBoneInfluence->iBoneID ];
D3DXQuaternionConjugate ( (D3DXQUATERNION *)g_quatConjugate, (D3DXQUATERNION *)pKeyFrames [globalBoneID].quatCoordinate );
Fx_Quat3Multiply( g_quatAfterTransform, g_quatBuffer, pKeyFrames [globalBoneID].quatCoordinate, m_pBoneInfluence ->quatPos, g_quatConjugate );
sysVB ->vecPos [0] = g_quatAfterTransform [0] + pKeyFrames [globalBoneID].vecOffset [0];
sysVB ->vecPos [1] = g_quatAfterTransform [1] + pKeyFrames [globalBoneID].vecOffset [1];
sysVB ->vecPos [2] = g_quatAfterTransform [2] + pKeyFrames [globalBoneID].vecOffset [2];
Fx_Quat3Multiply( g_quatAfterTransform, g_quatBuffer, pKeyFrames [globalBoneID].quatCoordinate, m_pBoneInfluence ->quatNormal, g_quatConjugate );
VectorCopy ( sysVB ->vecNormal, g_quatAfterTransform );
}
else
{
for ( subindex = 0; \
subindex < m_pInfluence ->iNumBoneInfluences; \
++subindex )
{
m_pBoneInfluence = &m_pInfluence ->boneInfluences [subindex];
globalBoneID = m_pSkelManager->m_iBoneLookUp[ in_char->attr_skelID ][ m_pBoneInfluence->iBoneID ];
D3DXQuaternionConjugate ( (D3DXQUATERNION *)g_quatConjugate, (D3DXQUATERNION *)pKeyFrames [globalBoneID].quatCoordinate );
Fx_Quat3Multiply( g_quatAfterTransform, g_quatBuffer, pKeyFrames [globalBoneID].quatCoordinate, m_pBoneInfluence ->quatPos, g_quatConjugate );
sysVB ->vecPos [0] += m_pBoneInfluence ->fWeight * ( g_quatAfterTransform [0] + pKeyFrames [globalBoneID].vecOffset [0] );
sysVB ->vecPos [1] += m_pBoneInfluence ->fWeight * ( g_quatAfterTransform [1] + pKeyFrames [globalBoneID].vecOffset [1] );
sysVB ->vecPos [2] += m_pBoneInfluence ->fWeight * ( g_quatAfterTransform [2] + pKeyFrames [globalBoneID].vecOffset [2] );
Fx_Quat3Multiply( g_quatAfterTransform, g_quatBuffer, pKeyFrames [globalBoneID].quatCoordinate, m_pBoneInfluence ->quatNormal, g_quatConjugate );
sysVB ->vecNormal [0] += m_pBoneInfluence->fWeight * g_quatAfterTransform [0];
sysVB ->vecNormal [1] += m_pBoneInfluence->fWeight * g_quatAfterTransform [1];
sysVB ->vecNormal [2] += m_pBoneInfluence->fWeight * g_quatAfterTransform [2];
}
switch ( m_pInfluence ->iNumBoneInfluences )
{
case 2:
numToMultiply = 0.2f;
break;
case 3:
numToMultiply = 0.333333f;
break;
case 4:
numToMultiply = 0.25f;
break;
case 5:
numToMultiply = 0.2f;
break;
default:
ShowError ( "Bone Influence 개수가 6개 이상입니다!", __FILE__, __LINE__ );
exit (0);
}
sysVB ->vecNormal [0] *= numToMultiply;
sysVB ->vecNormal [1] *= numToMultiply;
sysVB ->vecNormal [2] *= numToMultiply;
}
sysVB ->tu = m_pVertexMap ->VertexTC [0].tu;
sysVB ->tv = 1.0f - m_pVertexMap ->VertexTC [0].tv;
}
CopyVertex( in_char, m_vertexBuffer, in_sysVBNum, in_skinPartID );
return true;
}
