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;
}
}
D3DXVECTOR3* quaternionVectorRotate(D3DXVECTOR3* result, const D3DXQUATERNION* pQ, const D3DXVECTOR3* pV)
{
D3DXQUATERNION inverse, rotated;
D3DXQuaternionInverse(&inverse, pQ);
//rotated = *pQ * *pV * inverse;
result->x = rotated.x;
result->y = rotated.y;
result->z = rotated.z;
return result;
}
CQuaternion* QuaternionDelta( CQuaternion *pOut, const CQuaternion *pQ1, const CQuaternion *pQ2 )
{
CQuaternion q0i ;
D3DXQuaternionInverse( &q0i, pQ1 ) ;
CQuaternion qd = q0i * (*pQ2) ;
if ( qd.w < 0 ) {
qd.x *= -1.0f ;
qd.y *= -1.0f ;
qd.z *= -1.0f ;
qd.w *= -1.0f ;
}
pOut = &qd ;
return pOut ;
}
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 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;
}
void Tank::Update(Input* input, float time, QuadTree *m_QuadTree){
int deltaX, deltaY;
input->GetMouseDelta(deltaX, deltaY);
m_tankState->SetTime(time);
m_tankState->ApplyForce(D3DXVECTOR3(0.0f, 0.0f, forward));
forward = 0;
m_tankState->SetYaw(turn * time);
yaw -= turn * time;
turn = 0;
D3DXVECTOR3 position = *getTankState()->GetPosition(), vgarbage, normal5;
float height;
m_QuadTree->GetHeightAtPosition(position.x, position.z, height, normal5);
float netforce = -0.00098f;
float y = m_tankState->GetPosition()->y;
if (y-(height+17) < 0) {
netforce -= (y-(height+17)) * 0.000065f;
}
m_tankState->ApplyForce(D3DXVECTOR3(0,netforce,0));
//m_turretState->SetPitch(deltaY*0.01f);*/
//m_turretState->SetYaw(rotation);
D3DXQUATERNION quat = *m_tankState->GetRotation();
D3DXQUATERNION inverse;
D3DXQuaternionInverse(&inverse, &quat);
D3DXQUATERNION temp;
D3DXVECTOR3 output;
float garbage;
temp = quat * D3DXQUATERNION(FRONTRIGHT.x, FRONTRIGHT.y, FRONTRIGHT.z, 0.0f) * inverse;
D3DXQuaternionToAxisAngle(&temp, &output, &garbage);
m_frontRight = *m_tankState->GetPosition() + output;
temp = quat * D3DXQUATERNION(FRONTLEFT.x, FRONTLEFT.y, FRONTLEFT.z, 0.0f) * inverse;
D3DXQuaternionToAxisAngle(&temp, &output, &garbage);
m_frontLeft = *m_tankState->GetPosition() + output;
temp = quat * D3DXQUATERNION(REARLEFT.x, REARLEFT.y, REARLEFT.z, 0.0f) * inverse;
D3DXQuaternionToAxisAngle(&temp, &output, &garbage);
m_rearLeft = *m_tankState->GetPosition() + output;
temp = quat * D3DXQUATERNION(REARRIGHT.x, REARRIGHT.y, REARRIGHT.z, 0.0f) * inverse;
D3DXQuaternionToAxisAngle(&temp, &output, &garbage);
m_rearRight = *m_tankState->GetPosition() + output;
temp = quat * D3DXQUATERNION(CENTER.x, CENTER.y, CENTER.z, 0.0f) * inverse;
D3DXQuaternionToAxisAngle(&temp, &output, &garbage);
m_center = *m_tankState->GetPosition() + output;
// Get the height of the triangle that is directly underneath the given tank position.
//result = m_QuadTree->GetHeightAtPosition(position.x, position.z, height, vgarbage);
//if(result) {
// If there was a triangle under the tank then position the tank just above it by one unit.
// getTankState()->SetPosition(D3DXVECTOR3(position.x,m_tankState->GetPosition()->y, position.z));
//}
int count = 5;
//D3DXVECTOR3 normal1, normal2, normal3, normal4, normal5;
//result = m_QuadTree->GetHeightAtPosition(m_frontRight.x, m_frontRight.z, height, normal1);
//if(!result) {
// normal1 = D3DXVECTOR3(0.0f, 0.0f, 0.0f);
// count--;
//}
//result = m_QuadTree->GetHeightAtPosition(m_frontLeft.x, m_frontLeft.z, height, normal2);
//if(!result) {
// normal2 = D3DXVECTOR3(0.0f, 0.0f, 0.0f);
// count--;
//}
//result = m_QuadTree->GetHeightAtPosition(m_rearRight.x, m_rearRight.z, height, normal3);
//if(!result) {
// normal3 = D3DXVECTOR3(0.0f, 0.0f, 0.0f);
// count--;
//}
//result = m_QuadTree->GetHeightAtPosition(m_rearLeft.x, m_rearLeft.z, height, normal4);
//if(!result) {
// normal4 = D3DXVECTOR3(0.0f, 0.0f, 0.0f);
// count--;
//}
//result = m_QuadTree->GetHeightAtPosition(m_center.x, m_center.z, height, normal5);
//if(!result) {
// normal5 = D3DXVECTOR3(0.0f, 0.0f, 0.0f);
// count--;
//}
D3DXVECTOR3 line3;
if (count > 0)
line3 = normal5;
//line3 = (normal1+normal2+normal3+normal4+normal5)/float(count);
else
line3 = *m_tankState->GetUp();
float angle = acos(D3DXVec3Dot(&line3, m_tankState->GetUp()));// assume normalized vectors /(D3DXVec3Length(&line3)*D3DXVec3Length(m_tankState->getUp())));
angle /= 15.0f;// * time;
//if (angle > 0.015f)
//{
D3DXVECTOR3 cross;
D3DXVec3Cross(&cross, &line3, m_tankState->GetUp());
D3DXVec3Normalize(&cross, &cross);
D3DXQUATERNION quaternion;
D3DXQuaternionRotationAxis(&quaternion, &cross, -angle);
m_tankState->multiplyOrientation(&quaternion);
//}
m_tankState->Update();
D3DXQUATERNION orien;
D3DXVECTOR3 slope, forward, turretProj;
D3DXVec3Cross(&slope, m_tankState->GetUp(), &D3DXVECTOR3(0, 1, 0));
D3DXVec3Normalize(&slope, &slope);
D3DXVec3Cross(&forward, m_tankState->GetUp(), &slope);
D3DXVec3Normalize(&forward, &forward);
D3DXVec3Cross(&turretProj, m_tankState->GetUp(), m_turretState->GetForward());
D3DXVec3Normalize(&turretProj, &turretProj);
D3DXVec3Cross(&turretProj, m_tankState->GetUp(), &turretProj);
D3DXVec3Normalize(&turretProj, &turretProj);
float projangle = acos(abs(D3DXVec3Dot(&turretProj, &forward)));
if (D3DXVec3Dot(&turretProj, &forward) < 0) projangle = float(D3DX_PI - projangle);
float slopeangle = acos(abs(D3DXVec3Dot(&D3DXVECTOR3(0, 1, 0), &forward)));
slopeangle = float(D3DX_PI/2 - slopeangle);
float pitchOffset = (1 - cos(projangle)) * slopeangle;
D3DXQuaternionRotationYawPitchRoll(&orien, yaw, pitch - pitchOffset, 0);
orien = orien * *m_tankState->GetRotation();
m_turretState->SetOrientation(&orien);
m_turretState->Update();
m_Bullet->Update(time);
}
void Drawable::buildShadowVolume(D3DXVECTOR3 light)
{
// Use connectivity table to determine silhouette edges
unsigned long** connectivityTable;
switch (meshType)
{
case (RACER):
{
connectivityTable = racerConnectivityTable;
break;
}
case (FRONTWHEEL):
{
connectivityTable = frontWheelConnectivityTable;
break;
}
case (REARWHEEL):
{
connectivityTable = rearWheelConnectivityTable;
break;
}
case (GUNMOUNTMESH):
{
connectivityTable = gunMountConnectivityTable;
break;
}
default:
connectivityTable = racerConnectivityTable;
}
D3DXMATRIX invTrans;
D3DXQUATERNION rot;
D3DXVECTOR3 scale, translate;
D3DXMatrixDecompose(&scale, &rot, &scale, &transform);
D3DXQuaternionInverse(&rot, &rot);
D3DXVECTOR4 temp;
D3DXMatrixRotationQuaternion(&invTrans, &rot);
D3DXVec3Transform(&temp, &light, &invTrans);
light.x = -temp.x;
light.y = -temp.y;
light.z = -temp.z;
Vertex* vertices = mesh->vertices;
unsigned long* indices = mesh->indices;
int vertexCount = mesh->vertexCount;
int indexCount = mesh->indexCount;
int numFaces = indexCount / 3;
unsigned long index0, index1, index2, neighbourTri;
D3DXVECTOR3* points;
int numVertices = 0;
D3DXVECTOR3 newV0, newV1;
D3DXVECTOR3 v0, v1, v2;
D3DXVECTOR3 norm;
shadowVertexBuffer->Lock(0, sizeof(D3DXVECTOR3) * mesh->indexCount * 6, (void**) &points, NULL);
for (int i = 0; i < numFaces; i++)
{
index0 = indices[3*i];
index1 = indices[3*i+1];
index2 = indices[3*i+2];
norm = vertices[index0].normal + vertices[index1].normal + vertices[index2].normal;
norm /= 3.0f;
// The current face is lit. Must check neighbours now
if (D3DXVec3Dot(&norm, &light) > 0.0f)
{
v0 = vertices[index0].position;
v1 = vertices[index1].position;
v2 = vertices[index2].position;
// For each edge, check if neighbour tri is lit. If it's not, add this edge
// EDGE 0
neighbourTri = connectivityTable[i][0];
index0 = indices[3*neighbourTri];
index1 = indices[3*neighbourTri+1];
index2 = indices[3*neighbourTri+2];
norm = vertices[index0].normal + vertices[index1].normal + vertices[index2].normal;
norm /= 3.0f;
if (D3DXVec3Dot(&norm, &light) < 0.0f)
{
// Neighbour is not lit! Add this edge!
newV0 = v0 - light*200;
newV1 = v1 - light*200;
points[numVertices++] = v1;
points[numVertices++] = v0;
points[numVertices++] = newV0;
points[numVertices++] = newV0;
points[numVertices++] = newV1;
points[numVertices++] = v1;
}
// EDGE 1
neighbourTri = connectivityTable[i][1];
index0 = indices[3*neighbourTri];
index1 = indices[3*neighbourTri+1];
index2 = indices[3*neighbourTri+2];
norm = vertices[index0].normal + vertices[index1].normal + vertices[index2].normal;
norm /= 3.0f;
if (D3DXVec3Dot(&norm, &light) < 0.0f)
{
// Neighbour is not lit! Add this edge!
newV0 = v1 - light*200;
newV1 = v2 - light*200;
points[numVertices++] = v2;
points[numVertices++] = v1;
points[numVertices++] = newV0;
points[numVertices++] = newV0;
points[numVertices++] = newV1;
points[numVertices++] = v2;
}
// EDGE 2
neighbourTri = connectivityTable[i][2];
index0 = indices[3*neighbourTri];
index1 = indices[3*neighbourTri+1];
index2 = indices[3*neighbourTri+2];
norm = vertices[index0].normal + vertices[index1].normal + vertices[index2].normal;
norm /= 3.0f;
if (D3DXVec3Dot(&norm, &light) < 0.0f)
{
// Neighbour is not lit! Add this edge!
newV0 = v2 - light*200;
newV1 = v0 - light*200;
points[numVertices++] = v0;
points[numVertices++] = v2;
points[numVertices++] = newV0;
points[numVertices++] = newV0;
points[numVertices++] = newV1;
points[numVertices++] = v0;
}
}
}
shadowVertexBuffer->Unlock();
shadowVertCount = numVertices;
}
