void TestTriangleStripsDX::Update() { if (processInput) { float rotAmount = 0.0f; XMMATRIX rotMatrix = XMMatrixIdentity(); if (input.right || input.left) { if (input.right) rotAmount = rotDelta; if (input.left) rotAmount = -rotDelta; rotMatrix = XMMatrixRotationAxis(XMLoadFloat4(&up), XMConvertToRadians(rotAmount)); } else if (input.up || input.down) { if (input.up) rotAmount = rotDelta; if (input.down) rotAmount = -rotDelta; rotMatrix = XMMatrixRotationAxis(XMLoadFloat4(&right), XMConvertToRadians(rotAmount)); } XMStoreFloat4(&eye, XMVector3Transform(XMLoadFloat4(&eye), rotMatrix)); XMStoreFloat4(&right, XMVector3Normalize(XMVector3Cross(XMLoadFloat4(&up), (XMLoadFloat4(¢er) - XMLoadFloat4(&eye))))); XMMATRIX viewMatrix = XMMatrixLookAtRH(XMLoadFloat4(&eye), XMLoadFloat4(¢er), XMLoadFloat4(&up)); mDeviceContext->UpdateSubresource(viewMatrixBuffer, 0, NULL, &viewMatrix, 0, 0); } }
///////////////**************new**************//////////////////// void UpdateScene() { //Keep the cubes rotating rot += .0005f; if(rot > 6.26f) rot = 0.0f; //Reset cube1World cube1World = XMMatrixIdentity(); //Define cube1's world space matrix //Exercise 1. Orbit the first cube around a different axis. XMVECTOR rotaxis = XMVectorSet(1.0f, 0.5f, 0.0f, 0.0f); Rotation = XMMatrixRotationAxis( rotaxis, rot); Translation = XMMatrixTranslation( 4.0f, 0.0f, 0.0f ); //Set cube1's world space using the transformations cube1World = Translation* Rotation; //Reset cube2World cube2World = XMMatrixIdentity(); //Define cube2's world space matrix Rotation = XMMatrixRotationAxis( rotaxis, -rot); Scale = XMMatrixScaling( 1.3f, 1.3f, 1.3f ); //Set cube2's world space matrix cube2World = Rotation * Scale; //Exercise 2.Play with the different transformations, and try to order them differently when multiplying them together, // to see different effects. //cube2World = Scale*Rotation; }
/*------------------------------------ ------ UpdateScene() Funktion ------ Hier wird die Scene verändert ------------------------------------*/ void UpdateScene() { // Rotation der Würfel: rot += 0.00005f; if (rot > 6.28f) rot = 0.0f; // Setze die cube1World Matrix wieder auf die Identität zurück cube1World = XMMatrixIdentity(); XMVECTOR rotaxis1 = XMVectorSet(1.0f, 1.0f, 0.0f, 0.0f); Rotation = XMMatrixRotationAxis(rotaxis1, rot); Translation = XMMatrixTranslation(0.0f, 0.0f, 4.0f); // Bestimme die worldmatrix für würfel1 cube1World = Translation*Rotation; //Jetzt cube2 cube2World = XMMatrixIdentity(); XMVECTOR rotaxis2 = XMVectorSet(0.0f, 1.0f, 0.0f, 0.0f); Rotation = XMMatrixRotationAxis(rotaxis2, -rot); Scale = XMMatrixScaling(1.3f, 1.3f, 1.3f); cube2World = Scale*Rotation; }
void Game::UpdateScene() { floorWorld = XMMatrixIdentity(); scale = XMMatrixScaling(250.0f, 1.0f, 250.0f); translation = XMMatrixTranslation(0.0f, 0.0f, 0.0f); floorWorld = scale*translation; //Keep the cubes rotating rotSpeed += .0005f; if (rotSpeed > 6.26f) rotSpeed = 0.0f; //When used, these matrices will rotate objects rotateAboutX = XMMatrixRotationAxis(rotXAxis, -rotSpeed); rotateAboutY = XMMatrixRotationAxis(rotYAxis, -rotSpeed); rotateAboutZ = XMMatrixRotationAxis(rotZAxis, -rotSpeed); scale = XMMatrixScaling(2, scaleY, 2); //Reset cubes locations cube1World = XMMatrixIdentity(); cube2World = XMMatrixIdentity(); //When used, these matrices will set an objects position translation = XMMatrixTranslation(-5.0f, 2.0f, 0.0f); //Set cube1's world space using the transformations cube1World = rotateAboutX * translation * scale; //When used, these matrices will set an objects position translation = XMMatrixTranslation(5.0f, 2.0f, 0.0f); //Set cube2's world space matrix cube2World = rotateAboutY * translation * scale; meshWorld = XMMatrixIdentity(); travelSpeed += 0.0003f; //Setting meshes scale, translation and rotation scale = XMMatrixScaling(0.2f,0.2f,0.2f); translation = XMMatrixTranslation(-travelSpeed, 0.0f, 0.0f); rotation = XMMatrixRotationRollPitchYaw(0, XMConvertToRadians(180), 0); meshWorld = translation * rotation * scale; //Reset sphereWorld sphereWorld = XMMatrixIdentity(); //Define sphereWorld's world space matrix scale = XMMatrixScaling(5.0f, 5.0f, 5.0f); //Make sure the sphere is always centered around camera translation = XMMatrixTranslation(XMVectorGetX(camPosition), XMVectorGetY(camPosition), XMVectorGetZ(camPosition)); //Set sphereWorld's world space using the transformations sphereWorld = scale * translation; }
void Camera::Roll(float angle) { XMMATRIX R = XMMatrixRotationAxis(XMLoadFloat3(&mLook), angle); XMStoreFloat3(&mUp, XMVector3TransformNormal(XMLoadFloat3(&mUp), R)); XMStoreFloat3(&mRight, XMVector3TransformNormal(XMLoadFloat3(&mRight), R)); }
void Camera::RotatePitch(float deg) { XMVECTOR right = XMVector3Normalize(XMVector3Cross(mEye, mUp)); XMMATRIX rotation = XMMatrixRotationAxis(right, deg); mEye = XMVector3TransformCoord(mEye, rotation); }
void mouseMovement(POINT mouseInfoNew, XMMATRIX* ViewMatrix){ LONG x = mouseInfoNew.x; LONG y = mouseInfoNew.y; float xMovement = (float)960 - x; float yMovement = (float)540 - y; //--------------------------------------- *ViewMatrix = XMMatrixTranspose(*ViewMatrix); XMMATRIX ViewInverse = XMMatrixInverse(NULL, *ViewMatrix); XMFLOAT4X4 View4x4; XMStoreFloat4x4(&View4x4, ViewInverse); XMVECTOR CamPos = XMVectorSet(View4x4._41, View4x4._42, View4x4._43, 0); XMMATRIX RotationX = XMMatrixRotationAxis(XMVectorSet(0.0f, 1.0f, 0.0f, 0.0f), cameraSpeed*xMovement); XMVECTOR newCamLook = (XMVectorSet(View4x4._31, View4x4._32 + cameraSpeed*yMovement, View4x4._33, 0)) + CamPos; *ViewMatrix = XMMatrixLookAtLH(CamPos, newCamLook, { 0, 1, 0 }); *ViewMatrix = *ViewMatrix * RotationX; *ViewMatrix = XMMatrixTranspose(*ViewMatrix); }
void Camera::Yaw(float angle) { // Rotate right and look vector about the up vector. XMMATRIX R = XMMatrixRotationAxis(XMLoadFloat3(&mUp), angle); XMStoreFloat3(&mRight, XMVector3TransformNormal(XMLoadFloat3(&mRight), R)); XMStoreFloat3(&mLook, XMVector3TransformNormal(XMLoadFloat3(&mLook), R)); }
//------------------------------------------------------------------------------------- // Name: Update() // Desc: Updates the world for the next frame //------------------------------------------------------------------------------------- void Update() { // Set the world matrix float fAngle = fmodf( -g_Time.fAppTime, XM_2PI ); static const XMVECTOR vAxisZ = { 0, 0, 1.0f, 0 }; g_matWorld = XMMatrixRotationAxis( vAxisZ, fAngle ); }
void Direct3D::update(float dt) { static float rotDT = 0.f; rotDT = dt; XMMATRIX rot = XMMatrixRotationAxis(XMVectorSet(0.f, 0.f, 1.f, 0.f), rotDT); for(int i = 0; i < NROFLIGHTS; i++) { XMVECTOR vLightPos = XMLoadFloat4(&m_lightList[i].pos); vLightPos = XMVector4Transform(vLightPos, rot); XMStoreFloat4(&m_lightList[i].pos, vLightPos); } m_pCamera->update(); //m_fps = 1/dt; m_time += dt; static int frameCnt = 0; static float t_base = 0.f; frameCnt++; if(m_time - t_base >= 1.f) { frameCnt /= 1; m_fps = (float)frameCnt; frameCnt = 0; t_base += 1.f; } updateConstantBuffers(); }
void D3DCamera::Pitch(float angle) { XMMATRIX rot = XMMatrixRotationAxis(m_Right, angle); m_Up = XMVector3TransformNormal(m_Up, rot); m_LookAt = XMVector3TransformNormal(m_LookAt, rot); }
void Camera::pitch(float angle) { // Rotate up and look vector about the right vector. XMMATRIX R = XMMatrixRotationAxis(XMLoadFloat3(&m_right), angle); XMStoreFloat3(&m_up, XMVector3TransformNormal(XMLoadFloat3(&m_up), R)); XMStoreFloat3(&m_look, XMVector3TransformNormal(XMLoadFloat3(&m_look), R)); }
void Camera::RotatePitch(float angleRad) { XMVECTOR right = XMVector3Normalize(XMVector3Cross(mAt - mEye, mUp)); XMMATRIX rotation = XMMatrixRotationAxis(right, angleRad); mEye = mAt + XMVector3TransformCoord(mEye - mAt, rotation); mUp = XMVector3TransformCoord(mUp, rotation); }
void Camera::Roll(float angle) { // Rotate up and Right vector about the Look vector. XMMATRIX R = XMMatrixRotationAxis(XMVector3Cross(XMLoadFloat3(&mUp), XMLoadFloat3(&mRight)), angle); XMStoreFloat3(&mUp, XMVector3TransformNormal(XMLoadFloat3(&mUp), R)); XMStoreFloat3(&mRight, XMVector3TransformNormal(XMLoadFloat3(&mLook), R)); }
void Camera::Pitch(float p_Angle) { //Rotate up and look vector about the right vector. XMMATRIX t_Right = XMMatrixRotationAxis(XMLoadFloat3(&m_Right), p_Angle); XMStoreFloat3(&m_Up, XMVector3TransformNormal(XMLoadFloat3(&m_Up), t_Right)); XMStoreFloat3(&m_Look, XMVector3TransformNormal(XMLoadFloat3(&m_Look), t_Right)); m_HasMoved = true; }
void CubeModel::Update(float time) { mAngle += 90.0f * time; XMVECTOR rotationAxis = XMVectorSet(1, 0, 1, 0); mWorldPos.world = XMMatrixRotationAxis(rotationAxis, XMConvertToRadians(mAngle)); mVertexShader->UpdateWorldMatrix(mWorldPos); }
// @brief 俯视和仰视 // // @param angle 为正: 俯视; 为负: 仰视 void Camera::Pitch(float angle) { // 相当于坐标系绕着mRight旋转 XMMATRIX R = XMMatrixRotationAxis(XMLoadFloat3(&mRight), angle); XMStoreFloat3(&mUp, XMVector3TransformNormal(XMLoadFloat3(&mUp), R)); XMStoreFloat3(&mLook, XMVector3TransformNormal(XMLoadFloat3(&mLook), R)); }
void FirstPersonCamera::Update(const GameTime& gameTime) { XMFLOAT2 movementAmount = Vector2Helper::Zero; if (mKeyboard != nullptr) { if (mKeyboard->IsKeyDown(DIK_W)) { movementAmount.y = 1.0f; } if (mKeyboard->IsKeyDown(DIK_S)) { movementAmount.y = -1.0f; } if (mKeyboard->IsKeyDown(DIK_A)) { movementAmount.x = -1.0f; } if (mKeyboard->IsKeyDown(DIK_D)) { movementAmount.x = 1.0f; } } XMFLOAT2 rotationAmount = Vector2Helper::Zero; if ((mMouse != nullptr) && (mMouse->IsButtonHeldDown(MouseButtons::Left))) { LPDIMOUSESTATE mouseState = mMouse->CurrentState(); rotationAmount.x = -mouseState->lX * mMouseSensitivity; rotationAmount.y = -mouseState->lY * mMouseSensitivity; } float elapsedTime = (float)gameTime.ElapsedGameTime(); XMVECTOR rotationVector = XMLoadFloat2(&rotationAmount) * mRotationRate * elapsedTime; XMVECTOR right = XMLoadFloat3(&mRight); XMMATRIX pitchMatrix = XMMatrixRotationAxis(right, XMVectorGetY(rotationVector)); XMMATRIX yawMatrix = XMMatrixRotationY(XMVectorGetX(rotationVector)); ApplyRotation(XMMatrixMultiply(pitchMatrix, yawMatrix)); XMVECTOR position = XMLoadFloat3(&mPosition); XMVECTOR movement = XMLoadFloat2(&movementAmount) * mMovementRate * elapsedTime; XMVECTOR strafe = right * XMVectorGetX(movement); position += strafe; XMVECTOR forward = XMLoadFloat3(&mDirection) * XMVectorGetY(movement); position += forward; XMStoreFloat3(&mPosition, position); Camera::Update(gameTime); }
void Entity::Pitch(float angle) { prevPitch = angle; // Rotate up and look vector about the right vector. XMMATRIX R = XMMatrixRotationAxis(XMLoadFloat3(&mRight), angle); XMStoreFloat3(&mUp, XMVector3TransformNormal(XMLoadFloat3(&mUp), R)); XMStoreFloat3(&mLook, XMVector3TransformNormal(XMLoadFloat3(&mLook), R)); }
void Entity::Roll(float angle) { //Rotate Up and Right on Look Vector prevRoll = angle; XMMATRIX R = XMMatrixRotationAxis(XMLoadFloat3(&mLook), angle); XMStoreFloat3(&mUp, XMVector3TransformNormal(XMLoadFloat3(&mUp), R)); XMStoreFloat3(&mRight, XMVector3TransformNormal(XMLoadFloat3(&mRight), R)); }
Player::Player(SoundManager* SoundManager, int MapWidth, int MapLength,XMFLOAT3 Position, XMFLOAT3 Scale, int Health, Input* input) : Entity(SoundManager, MapWidth, MapLength, Position, Scale, Health) { m_input = input; //Loading death sounds FIX LATER :) //m_soundManager->LoadSound("DickbuttSound.mp3", "PlayerDeathSound", "PlayerSound", LOAD_MEMORY); XMVECTOR _rotzAxis{ 0,1,0,0 }; m_rotation = XMMatrixRotationAxis(_rotzAxis, XM_PI); m_entityBox.Extents = XMFLOAT3(2.5f, 0.0f, 2.5f); }
void GCamera::Rotate(XMFLOAT3 axis, float degrees) { if (XMVector3Equal(GMathFV(axis), XMVectorZero()) || degrees == 0.0f) return; // rotate vectors XMFLOAT3 look_at_target = GMathVF(GMathFV(mTarget) - GMathFV(mPosition)); XMFLOAT3 look_at_up = GMathVF(GMathFV(mUp) - GMathFV(mPosition)); look_at_target = GMathVF(XMVector3Transform(GMathFV(look_at_target), XMMatrixRotationAxis(GMathFV(axis), XMConvertToRadians(degrees)))); look_at_up = GMathVF(XMVector3Transform(GMathFV(look_at_up), XMMatrixRotationAxis(GMathFV(axis), XMConvertToRadians(degrees)))); // restore vectors's end points mTarget and mUp from new rotated vectors mTarget = GMathVF(GMathFV(mPosition) + GMathFV(look_at_target)); mUp = GMathVF(GMathFV(mPosition) + GMathFV(look_at_up)); this->lookatViewMatrix(); }
void Camera::rotateX(float amount) { XMMATRIX mRotate = XMMatrixRotationAxis(XMLoadFloat4(&v_Right), amount); XMVECTOR new_y = XMVector4Transform(XMLoadFloat4(&v_Up), mRotate); XMVECTOR new_z = XMVector4Transform(XMLoadFloat4(&v_Look), mRotate); XMStoreFloat4(&v_Up, new_y); XMStoreFloat4(&v_Look, new_z); update(); }
void Bullet_e::Update(double time) { m_position.x += m_travelVec.x * m_speed * time; m_position.y += m_travelVec.y * m_speed * time; m_position.z += m_travelVec.z * m_speed * time; XMVECTOR _rotzAxis{ m_travelVec.x, m_travelVec.y, m_travelVec.z,0 }; m_rotationValue += time; m_rotation = XMMatrixRotationAxis(_rotzAxis, XM_PI * m_rotationValue); m_light->SetPos(XMFLOAT4(m_position.x, m_position.y, m_position.z, 1.0f)); m_entityBox.Center = m_position; }
void Camera::Rotate(XMFLOAT3 axis, float degrees) { if (XMVector3Equal(to(axis), XMVectorZero()) || degrees == 0.0f) return; // rotate vectors XMFLOAT3 look_at_target = to(to(mTarget) - to(mPosition)); XMFLOAT3 look_at_up = to(to(mUp) - to(mPosition)); look_at_target = to(XMVector3Transform(to(look_at_target), XMMatrixRotationAxis(to(axis), XMConvertToRadians(degrees)))); look_at_up = to(XMVector3Transform(to(look_at_up), XMMatrixRotationAxis(to(axis), XMConvertToRadians(degrees)))); // restore vectors's end points mTarget and mUp from new rotated vectors mTarget = to(to(mPosition) + to(look_at_target)); mUp = to(to(mPosition) + to(look_at_up)); this->initViewMatrix(); XMVECTOR w = XMVectorZero(); }
Bullet_e::Bullet_e(SoundManager * SoundManager, int MapWidth, int MapLength, XMFLOAT3 Position, XMFLOAT3 Scale, int Health, XMFLOAT3 Color, XMFLOAT3 TravelVec) { XMVECTOR _rotzAxis{ TravelVec.x, TravelVec.y, TravelVec.z, 0 }; m_rotation = XMMatrixRotationAxis(_rotzAxis, 0.0f); m_rotationValue = 0.0f; m_scale = Scale; m_position = Position; m_entityBox.Extents = XMFLOAT3(1, 0, 1); m_health = Health; m_speed = 28; m_travelVec = TravelVec; m_light = new Light(XMFLOAT4(Position.x, Position.y, Position.z, 1.0f), XMFLOAT4(Color.x, Color.y, Color.z, 1.0f), XMFLOAT4(2, 1, 0, 0)); }
// // Update the program's state // void DirectXClass::Update(float deltaTime) { XMVECTOR eyePosition = XMVectorSet(0, 30, -50, 1); XMVECTOR focusPoint = XMVectorSet(0, 0, 0, 1); XMVECTOR upDirection = XMVectorSet(0, 1, 0, 0); m_ViewMatrix = XMMatrixLookAtLH(eyePosition, focusPoint, upDirection); m_3dDeviceContext->UpdateSubresource(g_d3dConstantBuffers[CB_Frame], 0, nullptr, &m_ViewMatrix, 0, 0); static float angle = 0.0f; angle += 90.0f * deltaTime/5; XMVECTOR rotationAxis = XMVectorSet(0, 1, 0, 0); m_WorldMatrix = XMMatrixRotationAxis(rotationAxis, XMConvertToRadians(angle)); m_3dDeviceContext->UpdateSubresource(g_d3dConstantBuffers[CB_Object], 0, nullptr, &m_WorldMatrix, 0, 0); }
void glRotatef (GLfloat angle, GLfloat x, GLfloat y, GLfloat z) { // replicates the OpenGL glRotatef with 3 components and angle in degrees XMVECTOR vec; XMMATRIX mat; vec.x = x; vec.y = y; vec.z = z; mat = XMMatrixRotationAxis(vec, D3DXToRadian(angle)); current_matrix->stack[current_matrix->stackdepth] = mat * current_matrix->stack[current_matrix->stackdepth]; // dirty the matrix current_matrix->dirty = 1; }
void FPSCamera::Roll(float angle) { XMVECTOR right = XMLoadFloat3(&mRight); XMVECTOR look = XMLoadFloat3(&mLook); XMVECTOR up = XMLoadFloat3(&mUp); XMMATRIX rotate = XMMatrixRotationAxis(look, angle); up = XMVector3TransformNormal(up, rotate); right = XMVector3Cross(up, look); right = XMVector3Normalize(right); XMStoreFloat3(&mUp, up); XMStoreFloat3(&mRight, right); mViewUpdated = true; }
/** * Creates a rotation matrix about the described axis. * * @param fX Describes the x component of the axis. * @param fY Describes the y component of the axis. * @param fZ Describes the z component of the axis. * @param fRadians Angle of rotation, measured clockwise when looking along the rotation axis. * @return The resulting matrix. */ CFMat4x4 CFMat4x4::CreateRotationAxis( FLOAT32 fX, FLOAT32 fY, FLOAT32 fZ, FLOAT32 fRadians ) { CFMat4x4 matReturn; CFVec3 v3Axis; v3Axis.X( fX ); v3Axis.Y( fY ); v3Axis.Z( fZ ); XMMATRIX& matResult = *reinterpret_cast<XMMATRIX*>( &matReturn ); XMVECTOR& vAxis = *reinterpret_cast<XMVECTOR*>( &v3Axis ); vAxis = XMVectorSetW( vAxis, 0.0f ); matResult = XMMatrixRotationAxis( vAxis, fRadians ); return matReturn; }