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; }