int KRLLocalCharacter::GetSlopeRotation(D3DXQUATERNION& qRotationLH, RL_TERRAIN_SLOPE nTerrainSlope) { static float const PITCH_STEP = D3DX_PI / 600.0f; static float const ROLL_STEP = D3DX_PI / 600.0f; int nRetCode = false; int nResult = false; float fTerrainYawLH = m_fFootYaw; float fTerrainRollLH = 0.0f; float fTerrainPitchLH = 0.0f; IKG3DScene* p3DScene = NULL; D3DXVECTOR3 vPosition; KG_PROCESS_ERROR(m_RLCharacter.m_FrameData.m_Current.nMoveState != cmsOnJump); KG_PROCESS_ERROR(m_RLCharacter.m_FrameData.m_Current.nMoveState != cmsOnSwimJump); p3DScene = m_RLCharacter.m_RenderData.GetRLScene()->m_p3DScene; KGLOG_PROCESS_ERROR(p3DScene); m_RLCharacter.GetPosition(vPosition); nRetCode = GetTerrainSlopeLean(p3DScene, vPosition, fTerrainYawLH, nTerrainSlope, fTerrainPitchLH, fTerrainRollLH); KG_PROCESS_ERROR(nRetCode); if (abs(m_fFootExpectPitch - fTerrainPitchLH) > D3DX_PI / 1800.0f) m_fFootExpectPitch = fTerrainPitchLH; m_fFootPitch = CloseToPitch(m_fFootExpectPitch, m_fFootPitch, PITCH_STEP); if (abs(m_fFootExpectRoll - fTerrainRollLH) > D3DX_PI / 1800.0f) m_fFootExpectRoll = fTerrainRollLH; m_fFootRoll = CloseToRoll(m_fFootExpectRoll, m_fFootRoll, ROLL_STEP); switch (nTerrainSlope) { case RL_TERRAIN_SLOPE_NONE: YawToQuatLH(qRotationLH, YawLHToModelLH(fTerrainYawLH)); break; case RL_TERRAIN_SLOPE_LENGTHWAYS: D3DXQuaternionRotationYawPitchRoll(&qRotationLH, YawLHToModelLH(fTerrainYawLH), m_fFootPitch, 0.0f); break; case RL_TERRAIN_SLOPE_TRANSVERSE: D3DXQuaternionRotationYawPitchRoll(&qRotationLH, YawLHToModelLH(fTerrainYawLH), 0.0f, m_fFootRoll); break; case RL_TERRAIN_SLOPE_ALL: D3DXQuaternionRotationYawPitchRoll(&qRotationLH, YawLHToModelLH(fTerrainYawLH), m_fFootPitch, m_fFootRoll); break; } nResult = true; Exit0: return nResult; }
//Gets the camera matrix (at given distance from target). //Note that distance is ignored when in first person mode. Matrix Camera::GetLookAtMatrix( Real Distance ) { if( Pos == NULL ) return Matrix::MakeIdentity(); Matrix Result; D3DXMATRIX matR, matPosition, matView, matT, matMoveBack; D3DXQUATERNION qR; D3DXMatrixIdentity(&matView); D3DXMatrixIdentity(&matPosition); if(CS == CS_FIRST_PERSON) Distance=0; D3DXMatrixTranslation(&matMoveBack, 0, 0, -Distance); if( CS == CS_FOLLOW_MATRIX ) { D3DXMATRIX tempMat; D3DXQuaternionRotationYawPitchRoll(&qR, Yaw, Pitch, Roll); D3DXMatrixRotationQuaternion(&matR, &qR); D3DXMatrixMultiply(&matR, &matMoveBack, &matR); D3DXMatrixMultiply (&tempMat, &matR,&FollowMat->Mat ); D3DXMatrixInverse(&matView, NULL, &tempMat ); Result.Mat = matView; return Result; } if(CS == CS_FIRST_PERSON) D3DXMatrixTranslation(&matT, Pos->x + OffsetX, Pos->y + OffsetY + HeightDisplacement, Pos->z + OffsetZ); else D3DXMatrixTranslation(&matT, Pos->x + OffsetX, Pos->y + OffsetY, Pos->z + OffsetZ); D3DXMatrixMultiply(&matPosition, &matT, &matPosition); D3DXQuaternionRotationYawPitchRoll(&qR, Yaw, Pitch, Roll); D3DXMatrixRotationQuaternion(&matR, &qR); D3DXMatrixMultiply(&matR, &matMoveBack, &matR); D3DXMatrixMultiply(&matPosition, &matR, &matPosition); D3DXMatrixInverse(&matView, NULL, &matPosition); Result.Mat = matView; return Result; }
//-------------------------------------------------------- void TSprite::RenderEx( const RECT *pSrc, const D3DXVECTOR3 &inPos, const D3DXVECTOR3 &inScale, const D3DXVECTOR3 &inRotation, D3DXVECTOR3 *pCenter , const FLOAT inAlpha, const D3DCOLOR inColor) { // set color const D3DCOLOR COLOR = ((DWORD)(inAlpha*255.f) << 24) | 0x00FFFFFF; //const D3DCOLOR COLOR = ((DWORD)(inAlpha * 255.f) << 24 )| (inColor & 0x00FFFFFF); // rotation vector change to quaternion D3DXQUATERNION qt; D3DXQuaternionRotationYawPitchRoll( &qt, D3DXToRadian(inRotation.y), D3DXToRadian(inRotation.x), D3DXToRadian(inRotation.z)); // set matrix D3DXMATRIX mat; D3DXMatrixTransformation(&mat, NULL, NULL, &inScale, NULL, &qt, &inPos); FpD3DXSprite->SetTransform(&mat); // draw FpD3DXSprite->Draw( FpTexture9, pSrc, pCenter, NULL, COLOR); }
Matrix Camera::GetRotationMatrix() { D3DXQUATERNION qR; D3DXMATRIX matView, matR, matR2; D3DXMatrixIdentity(&matView); D3DXMatrixIdentity(&matR); D3DXQuaternionRotationYawPitchRoll(&qR, Yaw, Pitch, Roll); D3DXMatrixRotationQuaternion(&matR, &qR); if(CS == CS_FOLLOW_MATRIX ) { D3DXMatrixRotationQuaternion(&matR2, &qR); D3DXMatrixMultiply ( &matR, &matR2, &FollowMatSky->Mat ); } else { D3DXMatrixRotationQuaternion(&matR, &qR); } D3DXMatrixInverse(&matView, NULL, &matR); Matrix M; M.Mat = matView; return M; }
void Enemy::Move(D3DXVECTOR3 dir, float dT) { PxRaycastHit* hit = physics->RaycastMultiple(actor->getGlobalPose().p,PxVec3(0,-1,0).getNormalized(),colCapsuleHeight+0.1f,NULL,PxQueryFlag::eSTATIC); if(hit[0].actor == NULL) { dir.y = -9.8f*dT*2.5f; if(obj->position.y-colCapsuleHeight < -13.6f) { obj->position.y = -13.6f+colCapsuleHeight; } } else if(hit[1].actor == NULL && hit[0].actor == actor) { dir.y = -9.8f*dT*2.5f; if(obj->position.y-colCapsuleHeight < -13.6f) { obj->position.y = -13.6f+colCapsuleHeight; } } obj->position += dir*dT; D3DXQUATERNION rotQuat; D3DXQuaternionRotationYawPitchRoll(&rotQuat,0,0,90*ToRadian); if(actor->isRigidDynamic() != NULL) actor->isRigidDynamic()->setKinematicTarget(PxTransform(PxVec3(obj->position.x,obj->position.y,obj->position.z),PxQuat(rotQuat.x,rotQuat.y,rotQuat.z,rotQuat.w))); }
void Mesh::Rotate(D3DXVECTOR3 radians) { D3DXQUATERNION quaternion; D3DXQuaternionRotationYawPitchRoll(&quaternion, radians.y, radians.x, radians.z); D3DXQuaternionMultiply(&this->rotQuat, &this->rotQuat, &quaternion); this->RecreateWorldMatrix(); }
/** * * Calls the ProcessControls function to update the camera's position etc. * Rotates the camera by the current yaw, pitch and roll values, and then * re-calculates the view matrix by calling the SetView3D function. * * @author Rebeccah Cox * @param float32 _fDeltaTick * @return void */ void CDebugCamera::Process(float32 _fDeltaTick) { ProcessControls(_fDeltaTick); D3DXQUATERNION quatRotation; D3DXQuaternionRotationYawPitchRoll(&quatRotation, m_fYaw, m_fPitch, m_fRoll); SetViewQuaternion(m_vec3Position, quatRotation); }
int KRLLocalCharacter::SetFaceFootDirection(float fFaceYaw, float fFacePitch, float fFootYaw) { int nRetCode = false; int nResult = false; KRLRides* pRides = NULL; D3DXQUATERNION qRotationLH; float fDelta = 0.0f; if (m_RLCharacter.m_pRLHorse) pRides = m_RLCharacter.m_pRLHorse; else if (m_RLCharacter.m_pRLVehicle) pRides = m_RLCharacter.m_pRLVehicle; if (pRides) { m_RLCharacter.KRLSceneObject::SetDirectionLH(D3DX_PI); if (GetSlopeRotation(qRotationLH, (RL_TERRAIN_SLOPE)pRides->m_dwSlopeType)) { pRides->SetDirectionLH(qRotationLH); } } else { if (m_RLCharacter.m_FrameData.m_Current.nMoveState == cmsOnSwim) { if (!m_RLCharacter.m_FrameData.m_Current.bUnderWater) fFacePitch = 0.0f; D3DXQuaternionRotationYawPitchRoll(&qRotationLH, YawLHToModelLH(fFaceYaw), fFacePitch, 0.0f); m_RLCharacter.m_RenderData.SetRotation(qRotationLH); } else { if (m_RLCharacter.m_EquipResource.bSplitModel) { m_RLCharacter.KRLSceneObject::SetDirectionLH(fFootYaw); } else { if (GetSlopeRotation(qRotationLH, m_RLCharacter.m_EquipResource.nTerrainSlope)) { m_RLCharacter.SetDirectionLH(qRotationLH); } } } } fDelta = NormalizeDirectionNegativeHalfToPositiveHalf(fFaceYaw - fFootYaw); m_RLCharacter.TurnFace(fDelta); nResult = true; return nResult; }
void CArea::__LoadAttribute(TObjectInstance * pObjectInstance, const char * c_szAttributeFileName) { // OBB를 사용한 충돌 정보 자동 생성. const bool bFileExist = CResourceManager::Instance().IsFileExist(c_szAttributeFileName); CAttributeData * pAttributeData = (CAttributeData *) CResourceManager::Instance().GetResourcePointer(c_szAttributeFileName); CAttributeInstance * pAttrInstance = ms_AttributeInstancePool.Alloc(); pAttrInstance->Clear(); pAttrInstance->SetObjectPointer(pAttributeData); if (false == bFileExist) { std::string attrFileName(c_szAttributeFileName); boost::algorithm::to_lower(attrFileName); const bool bIsDungeonObject = (std::string::npos != attrFileName.find("/dungeon/")) || (std::string::npos != attrFileName.find("\\dungeon\\")); // NOTE: dungeon 오브젝트는 Dummy Collision을 자동으로 생성하지 않도록 함 (던전의 경우 더미 컬리전때문에 문제가 된 경우가 수차례 있었음. 이렇게 하기로 그래픽 팀과 협의 완료) if (pAttributeData->IsEmpty() && false == bIsDungeonObject) { if (NULL != pObjectInstance && NULL != pObjectInstance->pThingInstance) { CGraphicThingInstance* object = pObjectInstance->pThingInstance; D3DXVECTOR3 v3Min, v3Max; object->GetBoundingAABB(v3Min, v3Max); CStaticCollisionData collision; collision.dwType = COLLISION_TYPE_OBB; D3DXQuaternionRotationYawPitchRoll(&collision.quatRotation, object->GetYaw(), object->GetPitch(), object->GetRoll()); strcpy(collision.szName, "DummyCollisionOBB"); collision.v3Position = (v3Min + v3Max) * 0.5f; D3DXVECTOR3 vDelta = (v3Max - v3Min); collision.fDimensions[0] = vDelta.x * 0.5f; collision.fDimensions[1] = vDelta.y * 0.5f; collision.fDimensions[2] = vDelta.z * 0.5f; pAttributeData->AddCollisionData(collision); } } } if (!pAttributeData->IsEmpty()) { pObjectInstance->pAttributeInstance = pAttrInstance; } else { pAttrInstance->Clear(); ms_AttributeInstancePool.Free(pAttrInstance); } }
int GetTerrainSlopeRotation(IKG3DScene* p3DScene, D3DXVECTOR3 vPosition, float fYawLH, RL_TERRAIN_SLOPE nTerrainSlope, D3DXQUATERNION& qRotationLH) { int nRetCode = false; int nResult = false; float fTerrainYawLH = fYawLH; float fTerrainRollLH = 0.0f; float fTerrainPitchLH = 0.0f; switch (nTerrainSlope) { case RL_TERRAIN_SLOPE_NONE: YawToQuatLH(qRotationLH, YawLHToModelLH(fYawLH)); break; case RL_TERRAIN_SLOPE_LENGTHWAYS: nRetCode = GetTerrainSlopeLean(p3DScene, vPosition, fTerrainYawLH, nTerrainSlope, fTerrainPitchLH, fTerrainRollLH); KG_PROCESS_ERROR(nRetCode); D3DXQuaternionRotationYawPitchRoll(&qRotationLH, YawLHToModelLH(fTerrainYawLH), fTerrainPitchLH, 0.0f); break; case RL_TERRAIN_SLOPE_TRANSVERSE: nRetCode = GetTerrainSlopeLean(p3DScene, vPosition, fTerrainYawLH, nTerrainSlope, fTerrainPitchLH, fTerrainRollLH); KG_PROCESS_ERROR(nRetCode); D3DXQuaternionRotationYawPitchRoll(&qRotationLH, YawLHToModelLH(fTerrainYawLH), 0.0f, fTerrainRollLH); break; case RL_TERRAIN_SLOPE_ALL: nRetCode = GetTerrainSlopeLean(p3DScene, vPosition, fTerrainYawLH, nTerrainSlope, fTerrainPitchLH, fTerrainRollLH); KG_PROCESS_ERROR(nRetCode); D3DXQuaternionRotationYawPitchRoll(&qRotationLH, YawLHToModelLH(fTerrainYawLH), fTerrainPitchLH, fTerrainRollLH); break; default: ASSERT(0); break; } nResult = true; Exit0: return nResult; }
void cObjBase::Translation() { D3DXMATRIXA16 matScale, matRot, matTrans; D3DXMatrixScaling(&matScale, m_vScale.x, m_vScale.y, m_vScale.z); { D3DXQUATERNION q; D3DXQuaternionRotationYawPitchRoll(&q, m_vRotation.y, m_vRotation.x, m_vRotation.z); D3DXMatrixRotationQuaternion(&matRot, &q); } D3DXMatrixTranslation(&matTrans, m_vPosition.x, m_vPosition.y, m_vPosition.z); m_matWorld = matScale * matRot * matTrans; }
//----------------------------------------------------------------------------// void Direct3D8GeometryBuffer::updateMatrix() const { const D3DXVECTOR3 p(d_pivot.d_x, d_pivot.d_y, d_pivot.d_z); const D3DXVECTOR3 t(d_translation.d_x, d_translation.d_y, d_translation.d_z); D3DXQUATERNION r; D3DXQuaternionRotationYawPitchRoll(&r, D3DXToRadian(d_rotation.d_y), D3DXToRadian(d_rotation.d_x), D3DXToRadian(d_rotation.d_z)); D3DXMatrixTransformation(&d_matrix, 0, 0, 0, &p, &r, &t); d_matrixValid = true; }
D3DXMATRIXA16 Transform::MatrixTransform() { D3DXQUATERNION qRotation; D3DXMATRIXA16 tempMatrix; D3DXMatrixIdentity( &tempMatrix ); // rotation에서 쿼터니언 생성, yaw ptich roll 은 y, x, z 순서임 D3DXQuaternionRotationYawPitchRoll( &qRotation, D3DXToRadian( m_Rotation.y ), D3DXToRadian( m_Rotation.x ), D3DXToRadian( m_Rotation.z ) ); // matrix를 affine변환이 적용된 형태로 변환 D3DXMatrixTransformation( &tempMatrix, NULL, NULL, &m_Scale, NULL, &qRotation, &m_Position ); return tempMatrix; }
void CToolCamera::Transform( LPDIRECT3DDEVICE9 pd3dDevice, CWorld* pWorld ) { D3DXQUATERNION qR; D3DXQuaternionRotationYawPitchRoll( &qR, m_fYaw, m_fPitch, 0.0f ); //D3DXMatrixAffineTransformation( &m_matOrientation, 1.25f, NULL, &qR, &m_vPos ); D3DXMatrixAffineTransformation( &m_matOrientation, 1.0f, NULL, &qR, &m_vPos ); D3DXMatrixInverse( &m_matView, NULL, &m_matOrientation ); pd3dDevice->SetTransform( D3DTS_VIEW, &m_matView ); pWorld->UpdateCullInfo( &m_matView, &pWorld->m_matProj ); D3DXMatrixInverse( &m_matInvView, NULL, &m_matView ); m_matInvView._41 = 0.0f; m_matInvView._42 = 0.0f; m_matInvView._43 = 0.0f; g_matInvView = m_matInvView; g_matView = m_matView; }
D3DXVECTOR3 PlayerCharacter::GetViewDirection() { D3DXQUATERNION qRotation; D3DXMATRIXA16 tempMatrix; D3DXMatrixIdentity( &tempMatrix ); // rotation에서 쿼터니언 생성, yaw ptich roll 은 y, x, z 순서임 D3DXQuaternionRotationYawPitchRoll( &qRotation, D3DXToRadian( m_Rotation.y ), D3DXToRadian( m_Rotation.x ), D3DXToRadian( m_Rotation.z ) ); // matrix를 affine변환이 적용된 형태로 변환 - 생략 가능? D3DXMatrixTransformation( &tempMatrix, NULL, NULL, &m_Scale, NULL, &qRotation, &m_Position ); return D3DXVECTOR3( tempMatrix._31, tempMatrix._32, tempMatrix._33 ); }
void vrObject::Rotate( ) { /* if ( v_rot.x > v_maxrot.x ) v_rot.x = v_maxrot.x; if ( v_rot.y > v_maxrot.y ) v_rot.y = v_maxrot.y; if ( v_rot.z > v_maxrot.z ) v_rot.z = v_maxrot.z; */ vrQuaternion temp_quat; //D3DXQuaternionRotationYawPitchRoll( &temp_quat, v_rot.x*pi/2, v_rot.y*pi/2, v_rot.z*pi/2 ); D3DXQuaternionRotationYawPitchRoll( &temp_quat, f_yaw*pi/2, f_pitch*pi/2, f_yaw*pi/2 ); D3DXQuaternionMultiply( &q_orient, &q_orient, &temp_quat ); }
void vrObject::MoveX() { vrQuaternion TempQuat; vrQuaternion TempQuat2; D3DXQuaternionRotationYawPitchRoll( &TempQuat2, 0.0, -90.0*(pi/180), 0.0 ); D3DXQuaternionMultiply( &TempQuat, &q_orient, &TempQuat2 ); vrVector3 dir; TempQuat.GetDirectionVector( &dir ); v_pos.x += dir.x * v_speed.x; v_pos.y += dir.y * v_speed.x; v_pos.z += dir.z * v_speed.x; }
//****************************************************************** // 更新・描画 //****************************************************************** bool sceneMain::Update() { PlayerCtrl(); PlayerUpdate(); SoundManager::Update(); if (KeyBoard(KB_F))cameraPos.z += 1; if (KeyBoard(KB_G))cameraPos.z -= 1; tdnView::Set(cameraPos, VECTOR_ZERO); // メッシュテスト shader3D->SetValue( "viewPosition", cameraPos ); static float meshAngle = 0; meshAngle += 0.01f; TestMesh->Rot( *D3DXQuaternionRotationYawPitchRoll( &Quaternion(), meshAngle, meshAngle * 0.9f, meshAngle * 0.7f ) ); TestMesh->Pos( Vector3( 0.0f, 0.0f, 0.0f ) ); TestMesh->UpdateWorldMatrix(); return true; }
Scene * D3D::BuildScene(IDirect3DDevice9 *d3dDevice) { // Setup some materials - we'll use these for // making the same mesh appear in multiple // colors D3DMATERIAL9 colors[8]; D3DUtil_InitMaterial( colors[0], 1.0f, 1.0f, 1.0f, 1.0f ); // white D3DUtil_InitMaterial( colors[1], 0.0f, 1.0f, 1.0f, 1.0f ); // cyan D3DUtil_InitMaterial( colors[2], 1.0f, 0.0f, 0.0f, 1.0f ); // red D3DUtil_InitMaterial( colors[3], 0.0f, 1.0f, 0.0f, 1.0f ); // green D3DUtil_InitMaterial( colors[4], 0.0f, 0.0f, 1.0f, 1.0f ); // blue D3DUtil_InitMaterial( colors[5], 0.4f, 0.4f, 0.4f, 0.4f ); // 40% grey D3DUtil_InitMaterial( colors[6], 0.25f, 0.25f, 0.25f, 0.25f ); // 25% grey D3DUtil_InitMaterial( colors[7], 0.65f, 0.65f, 0.65f, 0.65f ); // 65% grey // The identity matrix is always useful D3DXMATRIX ident; D3DXMatrixIdentity(&ident); // We'll use these rotations for some teapots and grid objects D3DXMATRIX rotateX, rotateY, rotateZ; // Create the root, and the camera. // Remeber how to use smart pointers?? I hope so! boost::shared_ptr<TransformNode> root(new TransformNode(&ident)); boost::shared_ptr<CameraNode> camera(new CameraNode(&ident)); root->m_children.push_back(camera); // We'll put the camera in the scene at (20,20,20) looking back at the Origin D3DXMATRIX rotOnly, result, inverse; float cameraYaw = - (3.0f * D3DX_PI) / 4.0f; float cameraPitch = D3DX_PI / 4.0f; D3DXQUATERNION q; D3DXQuaternionIdentity(&q); D3DXQuaternionRotationYawPitchRoll(&q, cameraYaw, cameraPitch, 0.0); D3DXMatrixRotationQuaternion(&rotOnly, &q); D3DXMATRIX trans; D3DXMatrixTranslation(&trans, 15.0f, 15.0f, 15.0f); D3DXMatrixMultiply(&result, &rotOnly, &trans); D3DXMatrixInverse(&inverse, NULL, &result); camera->VSetTransform(&result, &inverse); D3DXMatrixRotationZ(&rotateZ, D3DX_PI / 2.0f); D3DXMatrixRotationX(&rotateX, -D3DX_PI / 2.0f); D3DXVECTOR3 target(30, 2, 15); // ID3DXMesh *teapot; if( SUCCEEDED( D3DXCreateTeapot( d3dDevice, &teapot, NULL ) ) ) { // Teapot #1 - a white one at (x=6,y=2,z=4) D3DXMatrixTranslation(&trans,6,2,4); boost::shared_ptr<SceneNode> mesh1(new MeshNode(teapot, &trans, colors[2])); root->m_children.push_back(mesh1); // Teapot #2 - a cyan one at (x=3,y=2,z=1) // with a D3DXMatrixTranslation(&trans, 3,2,1); D3DXMATRIX result; D3DXMatrixMultiply(&result, &rotateZ, &trans); boost::shared_ptr<SceneNode> mesh2(new MeshNode(teapot, &result, colors[1])); root->m_children.push_back(mesh2); // Teapot #3 - another white one at (x=30, y=2, z=15) D3DXMATRIX rotateY90; D3DXMatrixRotationY(&rotateY90, D3DX_PI / 2.0f); D3DXMatrixTranslation(&trans, target.x, target.y, target.z); D3DXMatrixMultiply(&result, &rotateY90, &trans); boost::shared_ptr<SceneNode> mesh3(new MeshNode(teapot, &result, colors[0])); root->m_children.push_back(mesh3); // We can release the teapot now, mesh1 and mesh2 AddRef'd it. SAFE_RELEASE(teapot); } ID3DXMesh *sphere; if ( SUCCEEDED( D3DXCreateSphere( d3dDevice, .25, 16, 16, &sphere, NULL) ) ) { // We're going to create a spiral of spheres... // starting at (x=3, y=0, z=3), and spiraling // upward about a local Y axis. D3DXMatrixTranslation(&trans, 3,0,3); boost::shared_ptr<SceneNode> sphere1(new MeshNode(sphere, &trans, colors[4]) ); root->m_children.push_back(sphere1); // Here's the local rotation and translation. // We'll rotate about Y, and then translate // up (along Y) and forward (along Z). D3DXMatrixRotationY(&rotateY, D3DX_PI / 8.0f); D3DXMATRIX trans2; D3DXMatrixTranslation(&trans2, 0, 0.5, 0.5); D3DXMatrixMultiply(&result, &trans2, &rotateY); for (int i=0; i<25; i++) { // If you didn't think smart pointers were cool - // watch this! No leaked memory.... // Notice this is a heirarchy.... boost::shared_ptr<SceneNode> sphere2(new MeshNode(sphere, &result, colors[i%5]) ); sphere1->m_children.push_back(sphere2); sphere1 = sphere2; } // We can release the sphere now, all the cylinders AddRef'd it. SAFE_RELEASE(sphere); } // D3DXMatrixTranslation(&trans,-25,20,20); //D3DXMatrixScaling(&trans, -10, -10, -10); ScaleMtrl scale; scale.x = -50.0f; scale.y = -50.0f; scale.z = -50.0f; boost::shared_ptr<SceneNode> xmesh1(new XMeshNode(L"gf3.x", d3dDevice, &trans, &scale)); root->m_children.push_back(xmesh1); root->m_children.push_back(xmesh1); /*D3DXMatrixTranslation(&trans,-45,20,20); boost::shared_ptr<SceneNode> xmesh11(new XMeshNode(L"gf3.x", d3dDevice, &trans, &scale)); root->m_children.push_back(xmesh11);*/ XMeshNode *mm = new XMeshNode(L"gow_m1.x", d3dDevice, &trans, &scale); D3DXMatrixTranslation(&trans,10,10,10); //D3DXMatrixScaling(&trans, -10, -10, -10); //ScaleMtrl scale; scale.x = 100.0f; scale.y = 100.0f; scale.z = 100.0f; boost::shared_ptr<SceneNode> xmesh2( new XMeshNode(L"gow_m1.x", d3dDevice, &trans, &scale)); root->m_children.push_back(xmesh2); /*D3DXMatrixTranslation(&trans,20,20,20); boost::shared_ptr<SceneNode> xmesh3(new XMeshNode(mm->m_mesh, mm->Mtrls, mm->Textures, &trans, 0)); root->m_children.push_back(xmesh3);*/ int col = 10; int row= 10; int zoom = 10; const int COUNT = 13; for(int i = 0; i < COUNT; i++) { for (int j = 0; j< COUNT; j++) { for(int z = 0; z< COUNT; z++) { D3DXMatrixTranslation(&trans, col + i, row + j , zoom + z); boost::shared_ptr<SceneNode> xmeshNew(new XMeshNode(mm->m_mesh, mm->Mtrls, mm->Textures, &trans, 0)); root->m_children.push_back(xmeshNew); } } } //D3DXMatrixScaling(&trans, 10, 10, 10); // Here are the grids...they make it easy for us to // see where the coordinates are in 3D space. boost::shared_ptr<SceneNode> grid1(new Grid(40, 0x00404040, L"Textures\\grid.dds", &ident)); root->m_children.push_back(grid1); boost::shared_ptr<SceneNode> grid2(new Grid(40, 0x00004000, L"Textures\\grid.dds", &rotateX)); root->m_children.push_back(grid2); boost::shared_ptr<SceneNode> grid3(new Grid(40, 0x00000040, L"Textures\\grid.dds", &rotateZ)); root->m_children.push_back(grid3); // Here's the sky node that never worked!!!! boost::shared_ptr<SkyNode> sky(new SkyNode(_T("Sky2"), camera)); root->m_children.push_back(sky); D3DXMatrixTranslation(&trans,15,2,15); D3DXMatrixRotationY(&rotateY, D3DX_PI / 4.0f); D3DXMatrixMultiply(&result, &rotateY, &trans); boost::shared_ptr<SceneNode> arrow1(new ArrowNode(2, &result, colors[0], d3dDevice)); root->m_children.push_back(arrow1); D3DXMatrixRotationY(&rotateY, D3DX_PI / 2.0f); D3DXMatrixMultiply(&result, &rotateY, &trans); boost::shared_ptr<SceneNode> arrow2(new ArrowNode(2, &result, colors[5], d3dDevice)); root->m_children.push_back(arrow2); D3DXMatrixMultiply(&result, &rotateX, &trans); boost::shared_ptr<SceneNode> arrow3(new ArrowNode(2, &result, colors[0], d3dDevice)); root->m_children.push_back(arrow3); // Everything has been attached to the root. Now // we attach the root to the scene. Scene *scene = new Scene(d3dDevice, root); scene->Restore(); // A movement controller is going to control the camera, // but it could be constructed with any of the objects you see in this // function. You can have your very own remote controlled sphere. What fun... boost::shared_ptr<MovementController> m_pMovementController(new MovementController(camera, cameraYaw, cameraPitch)); scene->m_pMovementController = m_pMovementController; return scene; }
//-------------------------------------------------------------------------------------- // This callback function will be called immediately after the Direct3D device has been // created, which will happen during application initialization and windowed/full screen // toggles. This is the best location to create D3DPOOL_MANAGED resources since these // resources need to be reloaded whenever the device is destroyed. Resources created // here should be released in the OnDestroyDevice callback. //-------------------------------------------------------------------------------------- HRESULT CALLBACK OnCreateDevice( IDirect3DDevice9* pd3dDevice, const D3DSURFACE_DESC* pBackBufferSurfaceDesc, void* pUserContext ) { HRESULT hr; V_RETURN( g_DialogResourceManager.OnD3D9CreateDevice( pd3dDevice ) ); V_RETURN( g_SettingsDlg.OnD3D9CreateDevice( pd3dDevice ) ); // Initialize the font V_RETURN( D3DXCreateFont( pd3dDevice, 15, 0, FW_BOLD, 1, FALSE, DEFAULT_CHARSET, OUT_DEFAULT_PRECIS, DEFAULT_QUALITY, DEFAULT_PITCH | FF_DONTCARE, L"Arial", &g_pFont ) ); // Define DEBUG_VS and/or DEBUG_PS to debug vertex and/or pixel shaders with the // shader debugger. Debugging vertex shaders requires either REF or software vertex // processing, and debugging pixel shaders requires REF. The // D3DXSHADER_FORCE_*_SOFTWARE_NOOPT flag improves the debug experience in the // shader debugger. It enables source level debugging, prevents instruction // reordering, prevents dead code elimination, and forces the compiler to compile // against the next higher available software target, which ensures that the // unoptimized shaders do not exceed the shader model limitations. Setting these // flags will cause slower rendering since the shaders will be unoptimized and // forced into software. See the DirectX documentation for more information about // using the shader debugger. DWORD dwShaderFlags = D3DXFX_NOT_CLONEABLE; #if defined( DEBUG ) || defined( _DEBUG ) // Set the D3DXSHADER_DEBUG flag to embed debug information in the shaders. // Setting this flag improves the shader debugging experience, but still allows // the shaders to be optimized and to run exactly the way they will run in // the release configuration of this program. dwShaderFlags |= D3DXSHADER_DEBUG; #endif #ifdef DEBUG_VS dwShaderFlags |= D3DXSHADER_FORCE_VS_SOFTWARE_NOOPT; #endif #ifdef DEBUG_PS dwShaderFlags |= D3DXSHADER_FORCE_PS_SOFTWARE_NOOPT; #endif // Determine which LDPRT texture and SH coefficient cubemap formats are supported IDirect3D9* pD3D = DXUTGetD3D9Object(); D3DCAPS9 Caps; pd3dDevice->GetDeviceCaps( &Caps ); D3DDISPLAYMODE DisplayMode; pd3dDevice->GetDisplayMode( 0, &DisplayMode ); GetSupportedTextureFormat( pD3D, &Caps, DisplayMode.Format, &g_fmtTexture, &g_fmtCubeMap ); if( D3DFMT_UNKNOWN == g_fmtTexture || D3DFMT_UNKNOWN == g_fmtCubeMap ) return E_FAIL; // Create the skybox g_Skybox.OnCreateDevice( pd3dDevice, 50, L"Light Probes\\rnl_cross.dds", L"SkyBox.fx" ); V( D3DXSHProjectCubeMap( 6, g_Skybox.GetEnvironmentMap(), g_fSkyBoxLightSH[0], g_fSkyBoxLightSH[1], g_fSkyBoxLightSH[2] ) ); // Now compute the SH projection of the skybox... LPDIRECT3DCUBETEXTURE9 pSHCubeTex = NULL; V( D3DXCreateCubeTexture( pd3dDevice, 256, 1, 0, D3DFMT_A16B16G16R16F, D3DPOOL_MANAGED, &pSHCubeTex ) ); SHCubeProj projData; projData.Init( g_fSkyBoxLightSH[0], g_fSkyBoxLightSH[1], g_fSkyBoxLightSH[2] ); V( D3DXFillCubeTexture( pSHCubeTex, SHCubeFill, &projData ) ); g_Skybox.InitSH( pSHCubeTex ); // Read the D3DX effect file WCHAR str[MAX_PATH]; V_RETURN( DXUTFindDXSDKMediaFileCch( str, MAX_PATH, TEXT( "LocalDeformablePRT.fx" ) ) ); // If this fails, there should be debug output as to they the .fx file failed to compile V_RETURN( D3DXCreateEffectFromFile( pd3dDevice, str, NULL, NULL, dwShaderFlags, NULL, &g_pEffect, NULL ) ); V_RETURN( LoadTechniqueObjects( "bat" ) ); V_RETURN( g_LightControl.StaticOnD3D9CreateDevice( pd3dDevice ) ); g_LightControl.SetRadius( 2.0f ); // Setup the camera's view parameters D3DXVECTOR3 vecEye( 0.0f, 0.0f, -5.0f ); D3DXVECTOR3 vecAt ( 0.0f, 0.0f, 0.0f ); g_Camera.SetViewParams( &vecEye, &vecAt ); // Set the model's initial orientation D3DXQUATERNION quatRotation; D3DXQuaternionRotationYawPitchRoll( &quatRotation, -0.5f, 0.7f, 0.0f ); g_Camera.SetWorldQuat( quatRotation ); return hr; }
void Quaternion::BuildRotYawPitchRoll(const float yawRadians, const float pitchRadians, const float rollRadians) { D3DXQuaternionRotationYawPitchRoll(this, yawRadians, pitchRadians, rollRadians); }
int KRLRemoteCharacter::GetSlopeRotation(D3DXQUATERNION& qRotationLH, RL_TERRAIN_SLOPE nTerrainSlope, BOOL bForceUpdate) { int nRetCode = false; int nResult = false; float fTerrainYawLH = m_fFootYaw; float fTerrainRollLH = 0.0f; float fTerrainPitchLH = 0.0f; float fPitchStepSpeed = 0.0f; float fRollStepSpeed = 0.0f; IKG3DScene* p3DScene = NULL; D3DXVECTOR3 vPosition; BOOL bVisible = FALSE; bVisible = m_RLCharacter.m_RenderData.IsVisible(); if (bVisible && !bForceUpdate) { KG_PROCESS_ERROR(abs(m_fFootYaw - m_fPreviousFootYaw) > FLT_EPSILON || m_bVisible != bVisible); m_bVisible = bVisible; } if (m_FrameData.m_Current.nMoveState == cmsOnJump || m_FrameData.m_Current.nMoveState == cmsOnSwimJump) { nTerrainSlope = RL_TERRAIN_SLOPE_NONE; } p3DScene = m_RLCharacter.m_RenderData.GetRLScene()->m_p3DScene; KGLOG_PROCESS_ERROR(p3DScene); m_RLCharacter.GetPosition(vPosition); nRetCode = GetTerrainSlopeLean(p3DScene, vPosition, fTerrainYawLH, nTerrainSlope, fTerrainPitchLH, fTerrainRollLH); KG_PROCESS_ERROR(nRetCode); fPitchStepSpeed = GetPitchStepSpeed(m_FrameData.m_Current.nMoveState); fRollStepSpeed = GetRollStepSpeed(m_FrameData.m_Current.nMoveState); if (abs(m_fFootExpectPitch - fTerrainPitchLH) > D3DX_PI / 1800.0f) m_fFootExpectPitch = fTerrainPitchLH; m_fFootPitch = CloseToPitch(m_fFootExpectPitch, m_fFootPitch, fPitchStepSpeed); if (abs(m_fFootExpectRoll - fTerrainRollLH) > D3DX_PI / 1800.0f) m_fFootExpectRoll = fTerrainRollLH; m_fFootRoll = CloseToRoll(m_fFootExpectRoll, m_fFootRoll, fRollStepSpeed); switch (nTerrainSlope) { case RL_TERRAIN_SLOPE_NONE: YawToQuatLH(qRotationLH, YawLHToModelLH(fTerrainYawLH)); break; case RL_TERRAIN_SLOPE_LENGTHWAYS: D3DXQuaternionRotationYawPitchRoll(&qRotationLH, YawLHToModelLH(fTerrainYawLH), m_fFootPitch, 0.0f); break; case RL_TERRAIN_SLOPE_TRANSVERSE: D3DXQuaternionRotationYawPitchRoll(&qRotationLH, YawLHToModelLH(fTerrainYawLH), 0.0f, m_fFootRoll); break; case RL_TERRAIN_SLOPE_ALL: D3DXQuaternionRotationYawPitchRoll(&qRotationLH, YawLHToModelLH(fTerrainYawLH), m_fFootPitch, m_fFootRoll); break; } nResult = true; Exit0: return nResult; }
void GERenderingObject::setRotation(float X, float Y, float Z) { D3DXQuaternionRotationYawPitchRoll(&qRotation, Y, X, Z); }
void GERenderingObject::setRotation(const GEVector& Rotation) { D3DXQuaternionRotationYawPitchRoll(&qRotation, Rotation.Y, Rotation.X, Rotation.Z); }
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 GERenderingObject::rotate(float RX, float RY, float RZ) { D3DXQUATERNION qAux; D3DXQuaternionRotationYawPitchRoll(&qAux, RY, RX, RZ); qRotation = qAux * qRotation; }
void GERenderingObject::rotate(const GEVector& Rotate) { D3DXQUATERNION qAux; D3DXQuaternionRotationYawPitchRoll(&qAux, Rotate.Y, Rotate.X, Rotate.Z); qRotation = qAux * qRotation; }
void State::Update() { // TODO: Add decay speed m_acceleration -= m_posvel * m_friction; // Apply positional velocity if(!m_follow) { m_pos += (m_right * m_posvel.x) * m_time + (1/2) * (m_right * m_acceleration.x) * pow(m_time, 2); m_pos += (m_up * m_posvel.y) * m_time + (1/2) * (m_up * m_acceleration.y) * pow(m_time, 2); m_pos += (m_front * m_posvel.z) * m_time + (1/2) * (m_front * m_acceleration.z) * pow(m_time, 2); } else { m_pos = *m_follow->GetPosition(); m_pos += (*m_follow->GetRight() * m_offset.x); m_pos += (*m_follow->GetUp() * m_offset.y); m_pos += (*m_follow->GetForward() * m_offset.z); } m_posvel += m_acceleration * m_time; D3DXQUATERNION rot; D3DXQuaternionRotationYawPitchRoll( &rot, m_rotvel.x, m_rotvel.y, m_rotvel.z ); if (m_follow) { /*D3DXQUATERNION xrot,yrot,zrot; D3DXQuaternionRotationAxis(&xrot,&m_right,m_rotvel.y); D3DXQuaternionRotationAxis(&yrot,m_follow->GetUp(),m_rotvel.x); rot = yrot * xrot; static D3DXQUATERNION totalRot = rot; totalRot *= rot; D3DXQUATERNION temp; temp = *m_follow->GetRotation();*/ //m_rot = temp * totalRot; } else { m_rot *= rot; } /* if(m_rotvel_on) { // Apply rotational velocity D3DXQUATERNION rot; D3DXQuaternionRotationYawPitchRoll( &rot, m_rotvel.x, m_rotvel.y, m_rotvel.z ); m_rot *= rot; } else { D3DXQUATERNION rot, temp; D3DXQuaternionRotationYawPitchRoll( &rot, m_rotvel.x, m_rotvel.y, m_rotvel.z ); temp = *m_follow->GetRotation(); //temp.y = 0; m_rot = temp; D3DXQuaternionNormalize(&m_rot, &m_rot); m_rot = rot * m_rot; }*/ D3DXQuaternionNormalize(&m_rot, &m_rot); // Calculate up, front, left m_up = D3DXVECTOR3( 2 * (m_rot.x * m_rot.y - m_rot.w * m_rot.z), 1 - 2 * (m_rot.x * m_rot.x + m_rot.z * m_rot.z), 2 * (m_rot.y * m_rot.z + m_rot.w * m_rot.x) ); m_front = D3DXVECTOR3( 2 * (m_rot.x * m_rot.z + m_rot.w * m_rot.y), 2 * (m_rot.y * m_rot.z - m_rot.w * m_rot.x), 1 - 2 * (m_rot.x * m_rot.x + m_rot.y * m_rot.y) ); m_right = D3DXVECTOR3( 1 - 2 * (m_rot.y * m_rot.y + m_rot.z * m_rot.z), 2 * (m_rot.x * m_rot.y + m_rot.w * m_rot.z), 2 * (m_rot.x * m_rot.z - m_rot.w * m_rot.y) );; m_rotvel = D3DXVECTOR3(0.0f, 0.0f, 0.0f); m_acceleration = D3DXVECTOR3(0.0f, 0.0f, 0.0f); m_prevRot = m_rot; }
HRESULT InitScene() { HRESULT hr; SetWindowText(hwnd, TITLE); MYVALID(D3DXLoadMeshFromX("../media/meshes/sky.X", D3DXMESH_MANAGED, device, NULL, NULL, NULL, NULL, &skymesh)); MYVALID(D3DXLoadMeshFromX("../media/meshes/box.X", D3DXMESH_MANAGED, device, NULL, NULL, NULL, NULL, &mesh)); MYVALID(D3DXCreateTextureFromFileA(device, "../media/textures/fire.png", &texture1)); MYVALID(D3DXCreateTextureFromFileA(device, "../media/textures/stones.jpg", &texture2)); MYVALID(D3DXCreateCubeTextureFromFileA(device, "../media/textures/sky4.dds", &skytex)); MYVALID(device->CreateTexture(512, 512, 1, 0, D3DFMT_A8R8G8B8, D3DPOOL_MANAGED, &text, NULL)); MYVALID(DXCreateEffect("../media/shaders/skinning.fx", device, &effect)); MYVALID(DXCreateEffect("../media/shaders/sky.fx", device, &skyeffect)); system1.Initialize(device, 500); system1.ParticleTexture = texture1; // load dwarfs dwarfs[0].Effect = effect; dwarfs[0].Method = SM_Shader; dwarfs[0].Path = "../media/meshes/dwarf/"; MYVALID(dwarfs[0].Load(device, "../media/meshes/dwarf/dwarf.X")); dwarfs[0].Clone(dwarfs[1]); dwarfs[0].Clone(dwarfs[2]); dwarfs[0].Clone(dwarfs[3]); dwarfs[0].Clone(dwarfs[4]); dwarfs[0].Clone(dwarfs[5]); D3DXVECTOR3 scale(0.1f, 0.1f, 0.1f); D3DXVECTOR3 trans; D3DXQUATERNION rot; // dwarf 0 trans = D3DXVECTOR3(-1, 0, 1); D3DXQuaternionRotationYawPitchRoll(&rot, -0.785f, 0, 0); D3DXMatrixTransformation(&dwarfmatrices[0], NULL, NULL, &scale, NULL, &rot, &trans); // dwarf 1 trans = D3DXVECTOR3(-1, 0, -1); D3DXQuaternionRotationYawPitchRoll(&rot, -2.356f, 0, 0); D3DXMatrixTransformation(&dwarfmatrices[1], NULL, NULL, &scale, NULL, &rot, &trans); // dwarf 2 trans = D3DXVECTOR3(1, 0, -1); D3DXQuaternionRotationYawPitchRoll(&rot, 2.356f, 0, 0); D3DXMatrixTransformation(&dwarfmatrices[2], NULL, NULL, &scale, NULL, &rot, &trans); // dwarf 3 trans = D3DXVECTOR3(1, 0, 1); D3DXQuaternionRotationYawPitchRoll(&rot, 0.785f, 0, 0); D3DXMatrixTransformation(&dwarfmatrices[3], NULL, NULL, &scale, NULL, &rot, &trans); // dwarf 4 trans = D3DXVECTOR3(-0.2f, 0, -0.2f); D3DXQuaternionRotationYawPitchRoll(&rot, -1.57f, 0, 0); D3DXMatrixTransformation(&dwarfmatrices[4], NULL, NULL, &scale, NULL, &rot, &trans); // dwarf 5 trans = D3DXVECTOR3(0.2f, 0, 0); D3DXQuaternionRotationYawPitchRoll(&rot, -1.57f, 0, 0); D3DXMatrixTransformation(&dwarfmatrices[5], NULL, NULL, &scale, NULL, &rot, &trans); // skins DwarfSkin(0, 1, 1, 3, 1, 1, 3, 0); DwarfSkin(1, 2, 0, 1, 3, 3, 1, 1); DwarfSkin(2, 3, 2, 2, 2, 1, 2, 3); DwarfSkin(3, 1, 3, 2, 1, 3, 0, 2); DwarfSkin(4, 1, 1, 3, 3, 2, 2, 1); DwarfSkin(5, 0, 0, 1, 2, 3, 0, 1); // 0, 1, 2 - dead // 3, 5 - stand // 4 - jump // 6 - cheer with weapon // 7 - cheer with one hand // 8 - cheer with both hands dwarfs[0].SetAnimation(6); dwarfs[1].SetAnimation(8); dwarfs[2].SetAnimation(7); dwarfs[3].SetAnimation(4); dwarfs[4].SetAnimation(2); dwarfs[5].SetAnimation(1); // other device->SetRenderState(D3DRS_LIGHTING, false); device->SetSamplerState(0, D3DSAMP_MINFILTER, D3DTEXF_LINEAR); device->SetSamplerState(0, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR); DXRenderText(HELP_TEXT, text, 512, 512); cameraangle = D3DXVECTOR2(0.785f, 0.785f); // sound if( SUCCEEDED(InitXAudio2()) ) { firesound = streamer.LoadSound(xaudio2, "../media/sound/fire.ogg"); // create streaming thread and load music worker.Attach<AudioStreamer>(&streamer, &AudioStreamer::Update); worker.Start(); music = streamer.LoadSoundStream(xaudio2, "../media/sound/painkiller.ogg"); } if( music ) { music->GetVoice()->SetVolume(4); music->Play(); } if( firesound ) { firesound->GetVoice()->SetVolume(0.7f); firesound->Play(); } return S_OK; }
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(); } }