+ 龙书第10章基础代码（拷贝第九章）

Author: [email protected]

Chapter 10 Blending/Chapter 10 Blending.vcxproj

@@ -0,0 +1,128 @@
+//
+// Copyright (c) Microsoft. All rights reserved.
+// This code is licensed under the MIT License (MIT).
+// THIS CODE IS PROVIDED *AS IS* WITHOUT WARRANTY OF
+// ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING ANY
+// IMPLIED WARRANTIES OF FITNESS FOR A PARTICULAR
+// PURPOSE, MERCHANTABILITY, OR NON-INFRINGEMENT.
+//
+// Developed by Minigraph
+//
+// Author:  James Stanard 
+//
+
+#include "pch.h"
+#include "CameraController.h"
+#include "Camera.h"
+#include "GameInput.h"
+
+using namespace Math;
+using namespace GameCore;
+
+CameraController::CameraController( Camera& camera, Vector3 worldUp ) : m_TargetCamera( camera )
+{
+    m_WorldUp = Normalize(worldUp);
+    m_WorldNorth = Normalize(Cross(m_WorldUp, Vector3(kXUnitVector)));
+    m_WorldEast = Cross(m_WorldNorth, m_WorldUp);
+
+    m_HorizontalLookSensitivity = 2.0f;
+    m_VerticalLookSensitivity = 2.0f;
+    m_MoveSpeed = 1000.0f;
+    m_StrafeSpeed = 1000.0f;
+    m_MouseSensitivityX = 1.0f;
+    m_MouseSensitivityY = 1.0f;
+
+    m_CurrentPitch = Sin(Dot(camera.GetForwardVec(), m_WorldUp));
+
+    Vector3 forward = Normalize(Cross(m_WorldUp, camera.GetRightVec()));
+    m_CurrentHeading = ATan2(-Dot(forward, m_WorldEast), Dot(forward, m_WorldNorth));
+
+    m_FineMovement = false;
+    m_FineRotation = false;
+    m_Momentum = true;
+
+    m_LastYaw = 0.0f;
+    m_LastPitch = 0.0f;
+    m_LastForward = 0.0f;
+    m_LastStrafe = 0.0f;
+    m_LastAscent = 0.0f;
+}
+
+namespace Graphics
+{
+    extern EnumVar DebugZoom;
+}
+
+void CameraController::Update( float deltaTime )
+{
+    (deltaTime);
+
+    float timeScale = Graphics::DebugZoom == 0 ? 1.0f : Graphics::DebugZoom == 1 ? 0.5f : 0.25f;
+
+    if (GameInput::IsFirstPressed(GameInput::kLThumbClick) || GameInput::IsFirstPressed(GameInput::kKey_lshift))
+        m_FineMovement = !m_FineMovement;
+
+    if (GameInput::IsFirstPressed(GameInput::kRThumbClick))
+        m_FineRotation = !m_FineRotation;
+
+    float speedScale = (m_FineMovement ? 0.1f : 1.0f) * timeScale;
+    float panScale = (m_FineRotation ? 0.5f : 1.0f) * timeScale;
+
+    float yaw = GameInput::GetTimeCorrectedAnalogInput( GameInput::kAnalogRightStickX ) * m_HorizontalLookSensitivity * panScale;
+    float pitch = GameInput::GetTimeCorrectedAnalogInput( GameInput::kAnalogRightStickY ) * m_VerticalLookSensitivity * panScale;
+    float forward = m_MoveSpeed * speedScale * (
+        GameInput::GetTimeCorrectedAnalogInput( GameInput::kAnalogLeftStickY ) +
+        (GameInput::IsPressed( GameInput::kKey_w ) ? deltaTime : 0.0f) +
+        (GameInput::IsPressed( GameInput::kKey_s ) ? -deltaTime : 0.0f)
+        );
+    float strafe = m_StrafeSpeed * speedScale * (
+        GameInput::GetTimeCorrectedAnalogInput( GameInput::kAnalogLeftStickX  ) +
+        (GameInput::IsPressed( GameInput::kKey_d ) ? deltaTime : 0.0f) +
+        (GameInput::IsPressed( GameInput::kKey_a ) ? -deltaTime : 0.0f)
+        );
+    float ascent = m_StrafeSpeed * speedScale * (
+        GameInput::GetTimeCorrectedAnalogInput( GameInput::kAnalogRightTrigger ) -
+        GameInput::GetTimeCorrectedAnalogInput( GameInput::kAnalogLeftTrigger ) +
+        (GameInput::IsPressed( GameInput::kKey_e ) ? deltaTime : 0.0f) +
+        (GameInput::IsPressed( GameInput::kKey_q ) ? -deltaTime : 0.0f)
+        );
+
+    if (m_Momentum)
+    {
+        ApplyMomentum(m_LastYaw, yaw, deltaTime);
+        ApplyMomentum(m_LastPitch, pitch, deltaTime);
+        ApplyMomentum(m_LastForward, forward, deltaTime);
+        ApplyMomentum(m_LastStrafe, strafe, deltaTime);
+        ApplyMomentum(m_LastAscent, ascent, deltaTime);
+    }
+
+    // don't apply momentum to mouse inputs
+    yaw += GameInput::GetAnalogInput(GameInput::kAnalogMouseX) * m_MouseSensitivityX;
+    pitch += GameInput::GetAnalogInput(GameInput::kAnalogMouseY) * m_MouseSensitivityY;
+
+    m_CurrentPitch += pitch;
+    m_CurrentPitch = XMMin( XM_PIDIV2, m_CurrentPitch);
+    m_CurrentPitch = XMMax(-XM_PIDIV2, m_CurrentPitch);
+
+    m_CurrentHeading -= yaw;
+    if (m_CurrentHeading > XM_PI)
+        m_CurrentHeading -= XM_2PI;
+    else if (m_CurrentHeading <= -XM_PI)
+        m_CurrentHeading += XM_2PI; 
+
+    Matrix3 orientation = Matrix3(m_WorldEast, m_WorldUp, -m_WorldNorth) * Matrix3::MakeYRotation( m_CurrentHeading ) * Matrix3::MakeXRotation( m_CurrentPitch );
+    Vector3 position = orientation * Vector3( strafe, ascent, -forward ) + m_TargetCamera.GetPosition();
+    m_TargetCamera.SetTransform( AffineTransform( orientation, position ) );
+    m_TargetCamera.Update();
+}
+
+void CameraController::ApplyMomentum( float& oldValue, float& newValue, float deltaTime )
+{
+    float blendedValue;
+    if (Abs(newValue) > Abs(oldValue))
+        blendedValue = Lerp(newValue, oldValue, Pow(0.6f, deltaTime * 60.0f));
+    else
+        blendedValue = Lerp(newValue, oldValue, Pow(0.8f, deltaTime * 60.0f));
+    oldValue = blendedValue;
+    newValue = blendedValue;
+}

Chapter 10 Blending/Chapter 10 Blending.vcxproj.filters

@@ -0,0 +1,80 @@
+//
+// Copyright (c) Microsoft. All rights reserved.
+// This code is licensed under the MIT License (MIT).
+// THIS CODE IS PROVIDED *AS IS* WITHOUT WARRANTY OF
+// ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING ANY
+// IMPLIED WARRANTIES OF FITNESS FOR A PARTICULAR
+// PURPOSE, MERCHANTABILITY, OR NON-INFRINGEMENT.
+//
+// Developed by Minigraph
+//
+// Author:  James Stanard 
+//
+
+#pragma once
+
+#include "GameCore.h"
+#include "VectorMath.h"
+
+namespace Math
+{
+    class Camera;
+}
+
+namespace GameCore
+{
+    using namespace Math;
+
+    class CameraController
+    {
+    public:
+        // Assumes worldUp is not the X basis vector
+        CameraController( Camera& camera, Vector3 worldUp );
+
+        void Update( float dt );
+
+        void SlowMovement( bool enable ) { m_FineMovement = enable; }
+        void SlowRotation( bool enable ) { m_FineRotation = enable; }
+
+        void EnableMomentum( bool enable ) { m_Momentum = enable; }
+
+        Vector3 GetWorldEast() { return m_WorldEast; }
+        Vector3 GetWorldUp() { return m_WorldUp; }
+        Vector3 GetWorldNorth() { return m_WorldNorth; }
+        float GetCurrentHeading() { return m_CurrentHeading; }
+        float GetCurrentPitch() { return m_CurrentPitch; }
+
+        void SetCurrentHeading(float heading) { m_CurrentHeading = heading; }
+        void SetCurrentPitch(float pitch) { m_CurrentPitch = pitch; }
+
+
+    private:
+        CameraController& operator=( const CameraController& ) {return *this;}
+
+        void ApplyMomentum( float& oldValue, float& newValue, float deltaTime );
+
+        Vector3 m_WorldUp;
+        Vector3 m_WorldNorth;
+        Vector3 m_WorldEast;
+        Camera& m_TargetCamera;
+        float m_HorizontalLookSensitivity;
+        float m_VerticalLookSensitivity;
+        float m_MoveSpeed;
+        float m_StrafeSpeed;
+        float m_MouseSensitivityX;
+        float m_MouseSensitivityY;
+
+        float m_CurrentHeading;
+        float m_CurrentPitch;
+
+        bool m_FineMovement;
+        bool m_FineRotation;
+        bool m_Momentum;
+
+        float m_LastYaw;
+        float m_LastPitch;
+        float m_LastForward;
+        float m_LastStrafe;
+        float m_LastAscent;
+    };
+}