Code cleanup. Removed Camera functions to return forward, right, up vectors as they are now also in Node. Added Lua property accessors for Node up/right vectors. Exposed SmoothStep() to script. Modified Node::LookAt() to use the new Quaternion function. Updated credits.

Docs/Urho3D.dox

@@ -71,6 +71,7 @@ Urho3D development, contributions and bugfixes by:
 - Paul Noome
 - Alex Parlett
 - Vladimir Pobedinsky
+- Nick Royer
 - Miika Santala
 - Joshua Tippetts
 - Steven Zhang

Readme.txt

@@ -30,6 +30,7 @@ Urho3D development, contributions and bugfixes by:
 - Paul Noome
 - Alex Parlett
 - Vladimir Pobedinsky
+- Nick Royer
 - Miika Santala
 - Joshua Tippetts
 - Steven Zhang

Source/Engine/Graphics/Camera.cpp

@@ -314,7 +314,7 @@ Ray Camera::GetScreenRay(float x, float y) const
     if (!IsProjectionValid())
     {
         ret.origin_ = node_ ? node_->GetWorldPosition() : Vector3::ZERO;
-        ret.direction_ = GetForwardVector();
+        ret.direction_ = node_ ? node_->GetWorldDirection() : Vector3::FORWARD;
         return ret;
     }
 
@@ -492,21 +492,6 @@ float Camera::GetHalfViewSize() const
         return orthoSize_ * 0.5f / zoom_;
 }
 
-Vector3 Camera::GetForwardVector() const
-{
-    return node_ ? node_->GetWorldDirection() : Vector3::FORWARD;
-}
-
-Vector3 Camera::GetRightVector() const
-{
-    return node_ ? node_->GetWorldRotation() * Vector3::RIGHT : Vector3::RIGHT;
-}
-
-Vector3 Camera::GetUpVector() const
-{
-    return node_ ? node_->GetWorldRotation() * Vector3::UP : Vector3::UP;
-}
-
 float Camera::GetDistance(const Vector3& worldPos) const
 {
     if (!orthographic_)

Source/Engine/Graphics/Camera.h

@@ -135,12 +135,6 @@ public:
     Vector2 WorldToScreenPoint(const Vector3& worldPos) const;
     // Convert normalized screen coordinates (0.0 - 1.0) and depth to a world space point.
     Vector3 ScreenToWorldPoint(const Vector3& screenPos) const;
-    /// Return forward vector.
-    Vector3 GetForwardVector() const;
-    /// Return right vector.
-    Vector3 GetRightVector() const;
-    /// Return up vector.
-    Vector3 GetUpVector() const;
     /// Return projection offset.
     const Vector2& GetProjectionOffset() const { return projectionOffset_; }
     /// Return whether is using reflection.

Source/Engine/LuaScript/pkgs/Graphics/Camera.pkg

@@ -51,9 +51,6 @@ class Camera : public Component
     Ray GetScreenRay(float x, float y) const;
     Vector2 WorldToScreenPoint(const Vector3& worldPos) const;
     Vector3 ScreenToWorldPoint(const Vector3& screenPos) const;
-    Vector3 GetForwardVector() const;
-    Vector3 GetRightVector() const;
-    Vector3 GetUpVector() const;
     const Vector2& GetProjectionOffset() const;
     bool GetUseReflection() const;
     const Plane& GetReflectionPlane() const;
@@ -83,9 +80,6 @@ class Camera : public Component
     tolua_readonly tolua_property__get_set Matrix3x4& view;
     tolua_readonly tolua_property__get_set float halfViewSize;
     tolua_readonly tolua_property__get_set Frustum viewSpaceFrustum;
-    tolua_readonly tolua_property__get_set Vector3 forwardVector;
-    tolua_readonly tolua_property__get_set Vector3 rightVector;
-    tolua_readonly tolua_property__get_set Vector3 upVector;
     tolua_property__get_set Vector2& projectionOffset;
     tolua_property__get_set bool useReflection;
     tolua_property__get_set Plane& reflectionPlane;

Source/Engine/LuaScript/pkgs/Math/MathDefs.pkg

@@ -28,6 +28,7 @@ float Max(float lhs, float rhs);
 float Abs(float value);
 float Sign(float value);
 float Clamp(float value, float min, float max);
+float SmoothStep(float lhs, float rhs, float t);
 bool Equals(float lhs, float rhs);
 
 float Random();

Source/Engine/LuaScript/pkgs/Scene/Node.pkg

@@ -144,15 +144,15 @@ class Node : public Serializable
     Vector3 GetWorldDirection() const;
     tolua_outside void NodeGetWorldDirectionXYZ @ GetWorldDirectionXYZ(float* *x = 0.0f, float* *y = 0.0f, float* *z = 0.0f) const;
 
-    Vector3 GetWorldUp() const;    
+    Vector3 GetWorldUp() const;
     tolua_outside void NodeGetWorldUpXYZ @ GetWorldUpXYZ(float* *x = 0.0f, float* *y = 0.0f, float* *z = 0.0f) const;
-    
+
     Vector3 GetWorldRight() const;
     tolua_outside void NodeGetWorldRightXYZ @ GetWorldRightXYZ(float* *x = 0.0f, float* *y = 0.0f, float* *z = 0.0f) const;
 
     Vector3 GetWorldScale() const;
     tolua_outside void NodeGetWorldScaleXYZ @ GetWorldScaleXYZ(float* *x = 0.0f, float* *y = 0.0f, float* *z = 0.0f) const;
-    
+
     const Matrix3x4& GetWorldTransform() const;
     Vector3 LocalToWorld(const Vector3& position) const;
     Vector3 LocalToWorld(const Vector4& vector) const;
@@ -197,11 +197,15 @@ class Node : public Serializable
     tolua_property__get_set Vector3& position;
     tolua_property__get_set Quaternion& rotation;
     tolua_property__get_set Vector3 direction;
+    tolua_readonly tolua_property__get_set Vector3 up;
+    tolua_readonly tolua_property__get_set Vector3 right;
     tolua_property__get_set Vector3& scale;
     tolua_readonly tolua_property__get_set Matrix3x4 transform;
     tolua_property__get_set Vector3 worldPosition;
     tolua_property__get_set Quaternion worldRotation;
     tolua_property__get_set Vector3 worldDirection;
+    tolua_readonly tolua_property__get_set Vector3 worldUp;
+    tolua_readonly tolua_property__get_set Vector3 worldRight;
     tolua_property__get_set Vector3 worldScale;
     tolua_readonly tolua_property__get_set Matrix3x4& worldTransform;
     tolua_readonly tolua_property__is_set bool dirty;

Source/Engine/Math/MathDefs.h

@@ -83,11 +83,10 @@ inline float Clamp(float value, float min, float max)
 /// Smoothly damp between values
 inline float SmoothStep(float lhs, float rhs, float t)
 {
-    t = Clamp((t - lhs)/(rhs-lhs), 0, 1); //Saturate t
-    return t*t*(3-2*t);
+    t = Clamp((t - lhs) / (rhs - lhs), 0.0f, 1.0f); // Saturate t
+    return t * t * (3.0f - 2.0f * t);
 }
 
-
 /// Return sine of an angle in degrees.
 inline float Sin(float angle) { return sinf(angle * M_DEGTORAD); }
 /// Return cosine of an angle in degrees.

Source/Engine/Math/Quaternion.cpp

@@ -154,10 +154,10 @@ void Quaternion::FromLookRotation(const Vector3& direction, const Vector3& upDir
 
     Quaternion ret;
     ret.w_ = sqrtf(1.0f + right.x_ + up.y_ + forward.z_) * 0.5f;
-    float w4_recip = 1.0f / (4.0f * ret.w_);
-    ret.x_ = (up.z_ - forward.y_) * w4_recip;
-    ret.y_ = (forward.x_ - right.z_) * w4_recip;
-    ret.z_ = (right.y_ - up.x_) * w4_recip;
+    float w4Recip = 1.0f / (4.0f * ret.w_);
+    ret.x_ = (up.z_ - forward.y_) * w4Recip;
+    ret.y_ = (forward.x_ - right.z_) * w4Recip;
+    ret.z_ = (right.y_ - up.x_) * w4Recip;
 
     (*this) = ret;
 }

Source/Engine/Math/Quaternion.h

@@ -234,7 +234,7 @@ public:
     Matrix3 RotationMatrix() const;
     /// Spherical interpolation with another quaternion.
     Quaternion Slerp(Quaternion rhs, float t) const;
-    /// Normalized inear interpolation with another quaternion.   
+    /// Normalized linear interpolation with another quaternion.
     Quaternion Nlerp(Quaternion rhs, float t, bool shortestPath = false) const;
     /// Return float data.
     const float* Data() const { return &w_; }

Source/Engine/Scene/Node.cpp

@@ -399,11 +399,9 @@ void Node::Roll(float angle, bool fixedAxis)
 
 void Node::LookAt(const Vector3& target, const Vector3& upAxis)
 {
-    Vector3 targetZ = (target - GetWorldPosition()).Normalized();
-    Vector3 targetX = upAxis.CrossProduct(targetZ).Normalized();
-    Vector3 targetY = targetZ.CrossProduct(targetX).Normalized();
-    
-    Quaternion rotation(targetX, targetY, targetZ);
+    Vector3 lookDir = (target - GetWorldPosition()).Normalized();
+    Quaternion rotation;
+    rotation.FromLookRotation(lookDir, upAxis);
     SetRotation((parent_ == scene_ || !parent_) ? rotation : parent_->GetWorldRotation().Inverse() * rotation);
 }
 

Source/Engine/Script/GraphicsAPI.cpp

@@ -116,9 +116,6 @@ static void RegisterCamera(asIScriptEngine* engine)
     engine->RegisterObjectMethod("Camera", "const Matrix3x4& get_view() const", asMETHOD(Camera, GetView), asCALL_THISCALL);
     engine->RegisterObjectMethod("Camera", "Frustum get_viewSpaceFrustum() const", asMETHOD(Camera, GetViewSpaceFrustum), asCALL_THISCALL);
     engine->RegisterObjectMethod("Camera", "float get_halfViewSize() const", asMETHOD(Camera, GetHalfViewSize), asCALL_THISCALL);
-    engine->RegisterObjectMethod("Camera", "Vector3 get_forwardVector() const", asMETHOD(Camera, GetForwardVector), asCALL_THISCALL);
-    engine->RegisterObjectMethod("Camera", "Vector3 get_rightVector() const", asMETHOD(Camera, GetRightVector), asCALL_THISCALL);
-    engine->RegisterObjectMethod("Camera", "Vector3 get_upVector() const", asMETHOD(Camera, GetUpVector), asCALL_THISCALL);
     engine->RegisterObjectMethod("Camera", "Matrix3x4 get_effectiveWorldTransform() const", asMETHOD(Camera, GetEffectiveWorldTransform), asCALL_THISCALL);
 
     // Register Variant GetPtr() for Camera

Source/Engine/Script/MathAPI.cpp

@@ -70,6 +70,7 @@ static void RegisterMathFunctions(asIScriptEngine* engine)
     engine->RegisterGlobalFunction("float Max(float, float)", asFUNCTIONPR(Max, (float, float), float), asCALL_CDECL);
     engine->RegisterGlobalFunction("int Max(int, int)", asFUNCTIONPR(Max, (int, int), int), asCALL_CDECL);
     engine->RegisterGlobalFunction("float Clamp(float, float, float)", asFUNCTIONPR(Clamp, (float, float, float), float), asCALL_CDECL);
+    engine->RegisterGlobalFunction("float SmoothStep(float, float, float)", asFUNCTION(SmoothStep), asCALL_CDECL);
     engine->RegisterGlobalFunction("int Clamp(int, int, int)", asFUNCTIONPR(Clamp, (int, int, int), int), asCALL_CDECL);
     engine->RegisterGlobalFunction("float Lerp(float, float, float)", asFUNCTIONPR(Lerp, (float, float, float), float), asCALL_CDECL);
     engine->RegisterGlobalFunction("float Mod(float, float)", asFUNCTION(fmodf), asCALL_CDECL);