More lint

Author: walbourn

Inc/DirectXMathMatrix.inl

@@ -15,11 +15,11 @@
  *
  ****************************************************************************/
 
- //------------------------------------------------------------------------------
- // Comparison operations
- //------------------------------------------------------------------------------
+//------------------------------------------------------------------------------
+// Comparison operations
+//------------------------------------------------------------------------------
 
- //------------------------------------------------------------------------------
+//------------------------------------------------------------------------------
 
 #if !defined(_XM_NO_INTRINSICS_) && defined(_MSC_VER) && !defined(__INTEL_COMPILER)
 #pragma float_control(push)
@@ -3213,7 +3213,7 @@ inline XMMATRIX XM_CALLCONV XMMatrixOrthographicOffCenterRH
  *
  ****************************************************************************/
 
- //------------------------------------------------------------------------------
+//------------------------------------------------------------------------------
 
 inline XMMATRIX::XMMATRIX
 (
@@ -3448,7 +3448,7 @@ inline XMMATRIX XM_CALLCONV operator*
  *
  ****************************************************************************/
 
- //------------------------------------------------------------------------------
+//------------------------------------------------------------------------------
 _Use_decl_annotations_
 inline XMFLOAT3X3::XMFLOAT3X3(const float* pArray) noexcept
 {
@@ -3468,7 +3468,7 @@ inline XMFLOAT3X3::XMFLOAT3X3(const float* pArray) noexcept
  *
  ****************************************************************************/
 
- //------------------------------------------------------------------------------
+//------------------------------------------------------------------------------
 _Use_decl_annotations_
 inline XMFLOAT4X3::XMFLOAT4X3(const float* pArray) noexcept
 {
@@ -3525,7 +3525,7 @@ inline XMFLOAT3X4::XMFLOAT3X4(const float* pArray) noexcept
  *
  ****************************************************************************/
 
- //------------------------------------------------------------------------------
+//------------------------------------------------------------------------------
 _Use_decl_annotations_
 inline XMFLOAT4X4::XMFLOAT4X4(const float* pArray) noexcept
 {

Inc/DirectXMathMisc.inl

@@ -15,11 +15,11 @@
  *
  ****************************************************************************/
 
- //------------------------------------------------------------------------------
- // Comparison operations
- //------------------------------------------------------------------------------
+//------------------------------------------------------------------------------
+// Comparison operations
+//------------------------------------------------------------------------------
 
- //------------------------------------------------------------------------------
+//------------------------------------------------------------------------------
 
 inline bool XM_CALLCONV XMQuaternionEqual
 (
@@ -966,11 +966,11 @@ inline void XM_CALLCONV XMQuaternionToAxisAngle
  *
  ****************************************************************************/
 
- //------------------------------------------------------------------------------
- // Comparison operations
- //------------------------------------------------------------------------------
+//------------------------------------------------------------------------------
+// Comparison operations
+//------------------------------------------------------------------------------
 
- //------------------------------------------------------------------------------
+//------------------------------------------------------------------------------
 
 inline bool XM_CALLCONV XMPlaneEqual
 (
@@ -1298,11 +1298,11 @@ inline XMVECTOR XM_CALLCONV XMPlaneFromPoints
  *
  ****************************************************************************/
 
- //------------------------------------------------------------------------------
- // Comparison operations
- //------------------------------------------------------------------------------
+//------------------------------------------------------------------------------
+// Comparison operations
+//------------------------------------------------------------------------------
 
- //------------------------------------------------------------------------------
+//------------------------------------------------------------------------------
 
 inline bool XM_CALLCONV XMColorEqual
 (
@@ -1967,7 +1967,7 @@ inline XMVECTOR XM_CALLCONV XMColorSRGBToRGB(FXMVECTOR srgb) noexcept
  *
  ****************************************************************************/
 
- //------------------------------------------------------------------------------
+//------------------------------------------------------------------------------
 
 inline bool XMVerifyCPUSupport() noexcept
 {

Inc/DirectXMathVector.inl

@@ -37,12 +37,12 @@
  *
  ****************************************************************************/
 
- //------------------------------------------------------------------------------
- // Assignment operations
- //------------------------------------------------------------------------------
+//------------------------------------------------------------------------------
+// Assignment operations
+//------------------------------------------------------------------------------
 
- //------------------------------------------------------------------------------
- // Return a vector with all elements equaling zero
+//------------------------------------------------------------------------------
+// Return a vector with all elements equaling zero
 inline XMVECTOR XM_CALLCONV XMVectorZero() noexcept
 {
 #if defined(_XM_NO_INTRINSICS_)
@@ -6183,11 +6183,11 @@ inline XMVECTOR XM_CALLCONV XMVectorBaryCentricV
  *
  ****************************************************************************/
 
- //------------------------------------------------------------------------------
- // Comparison operations
- //------------------------------------------------------------------------------
+//------------------------------------------------------------------------------
+// Comparison operations
+//------------------------------------------------------------------------------
 
- //------------------------------------------------------------------------------
+//------------------------------------------------------------------------------
 
 inline bool XM_CALLCONV XMVector2Equal
 (
@@ -8911,11 +8911,11 @@ inline XMFLOAT2* XM_CALLCONV XMVector2TransformNormalStream
  *
  ****************************************************************************/
 
- //------------------------------------------------------------------------------
- // Comparison operations
- //------------------------------------------------------------------------------
+//------------------------------------------------------------------------------
+// Comparison operations
+//------------------------------------------------------------------------------
 
- //------------------------------------------------------------------------------
+//------------------------------------------------------------------------------
 
 inline bool XM_CALLCONV XMVector3Equal
 (
@@ -12776,11 +12776,11 @@ inline XMFLOAT3* XM_CALLCONV XMVector3UnprojectStream
  *
  ****************************************************************************/
 
- //------------------------------------------------------------------------------
- // Comparison operations
- //------------------------------------------------------------------------------
+//------------------------------------------------------------------------------
+// Comparison operations
+//------------------------------------------------------------------------------
 
- //------------------------------------------------------------------------------
+//------------------------------------------------------------------------------
 
 inline bool XM_CALLCONV XMVector4Equal
 (
@@ -13512,7 +13512,7 @@ inline XMVECTOR XM_CALLCONV XMVector4Cross
     XMVECTOR vTemp2 = XM_PERMUTE_PS(V2, _MM_SHUFFLE(1, 3, 2, 3));
     vTemp3 = XM_PERMUTE_PS(vTemp3, _MM_SHUFFLE(1, 3, 0, 1));
     vResult = XM_FNMADD_PS(vTemp2, vTemp3, vResult);
-     // term1 * V1yxxx
+    // term1 * V1yxxx
     XMVECTOR vTemp1 = XM_PERMUTE_PS(V1, _MM_SHUFFLE(0, 0, 0, 1));
     vResult = _mm_mul_ps(vResult, vTemp1);
 
@@ -14690,7 +14690,7 @@ inline XMFLOAT4* XM_CALLCONV XMVector4TransformStream
 
 #ifndef _XM_NO_XMVECTOR_OVERLOADS_
 
- //------------------------------------------------------------------------------
+//------------------------------------------------------------------------------
 
 inline XMVECTOR XM_CALLCONV operator+ (FXMVECTOR V) noexcept
 {

Inc/DirectXPackedVector.inl

@@ -3720,7 +3720,7 @@ inline void XM_CALLCONV XMStoreU555
  *
  ****************************************************************************/
 
- //------------------------------------------------------------------------------
+//------------------------------------------------------------------------------
 
 inline XMCOLOR::XMCOLOR
 (
@@ -3917,7 +3917,7 @@ inline XMBYTE2::XMBYTE2(const float* pArray) noexcept
  *
  ****************************************************************************/
 
- //------------------------------------------------------------------------------
+//------------------------------------------------------------------------------
 
 inline XMUBYTEN2::XMUBYTEN2
 (
@@ -4193,7 +4193,7 @@ inline XMXDECN4::XMXDECN4(const float* pArray) noexcept
 #ifdef _MSC_VER
 #pragma warning(push)
 #pragma warning(disable : 4996)
- // C4996: ignore deprecation warning
+// C4996: ignore deprecation warning
 #endif
 
 #ifdef __clang__
@@ -4258,7 +4258,7 @@ inline XMDECN4::XMDECN4(const float* pArray) noexcept
  *
  ****************************************************************************/
 
- //------------------------------------------------------------------------------
+//------------------------------------------------------------------------------
 
 inline XMDEC4::XMDEC4
 (

SHMath/DirectXSH.cpp

@@ -1426,10 +1426,10 @@ float DirectX::XMSHDot(
 // Computes the product of two functions represented using SH (f and g), where:
 // result[i] = int(y_i(s) * f(s) * g(s)), where y_i(s) is the ith SH basis
 // function, f(s) and g(s) are SH functions (sum_i(y_i(s)*c_i)).  The order O
-// determines the lengths of the arrays, where there should always be O^2 
+// determines the lengths of the arrays, where there should always be O^2
 // coefficients.  In general the product of two SH functions of order O generates
 // and SH function of order 2*O - 1, but we truncate the result.  This means
-// that the product commutes (f*g == g*f) but doesn't associate 
+// that the product commutes (f*g == g*f) but doesn't associate
 // (f*(g*h) != (f*g)*h.
 //-------------------------------------------------------------------------------------
 _Use_decl_annotations_
@@ -4470,7 +4470,7 @@ float* DirectX::XMSHMultiply6(
 
 
 //-------------------------------------------------------------------------------------
-// Evaluates a directional light and returns spectral SH data.  The output 
+// Evaluates a directional light and returns spectral SH data.  The output
 // vector is computed so that if the intensity of R/G/B is unit the resulting
 // exit radiance of a point directly under the light on a diffuse object with
 // an albedo of 1 would be 1.0.  This will compute 3 spectral samples, resultR
@@ -4537,10 +4537,10 @@ bool XM_CALLCONV DirectX::XMSHEvalDirectionalLight(
 
 
 //------------------------------------------------------------------------------------
-// Evaluates a spherical light and returns spectral SH data.  There is no 
+// Evaluates a spherical light and returns spectral SH data.  There is no
 // normalization of the intensity of the light like there is for directional
-// lights, care has to be taken when specifiying the intensities.  This will 
-// compute 3 spectral samples, resultR has to be specified, while resultG and 
+// lights, care has to be taken when specifiying the intensities.  This will
+// compute 3 spectral samples, resultR has to be specified, while resultG and
 // resultB are optional.
 //
 // http://msdn.microsoft.com/en-us/library/windows/desktop/bb205451.aspx
@@ -4575,7 +4575,7 @@ bool XM_CALLCONV DirectX::XMSHEvalSphericalLight(
 
     //
     // Sphere at distance fDist, the cone angle is determined by looking at the
-    // right triangle with one side (the hypotenuse) beind the vector from the 
+    // right triangle with one side (the hypotenuse) beind the vector from the
     // origin to the center of the sphere, another side is from the origin to
     // a point on the sphere whose normal is perpendicular to the given side (this
     // is one of the points on the cone that is defined by the projection of the sphere
@@ -4590,7 +4590,7 @@ bool XM_CALLCONV DirectX::XMSHEvalSphericalLight(
     // no default normalization is done for this case, have to be careful how
     // you represent the coefficients...
 
-    const float fNewNorm = 1.0f;///(fSinConeAngle*fSinConeAngle); 
+    const float fNewNorm = 1.0f;///(fSinConeAngle*fSinConeAngle);
 
     ComputeCapInt(order, fConeAngle, fTmpL0);
 
@@ -4791,7 +4791,7 @@ bool XM_CALLCONV DirectX::XMSHEvalConeLight(
 // is normalized so that a point on a perfectly diffuse surface with no
 // shadowing and a normal pointed in the direction pDir would result in exit
 // radiance with a value of 1 if the top color was white and the bottom color
-// was black.  This is a very simple model where topColor represents the intensity 
+// was black.  This is a very simple model where topColor represents the intensity
 // of the "sky" and bottomColor represents the intensity of the "ground".
 //
 // http://msdn.microsoft.com/en-us/library/windows/desktop/bb204989.aspx

SHMath/DirectXSHD3D11.cpp

@@ -261,7 +261,7 @@ HRESULT DirectX::SHProjectCubeMap(
 
     // index from [0,W-1], f(0) maps to -1 + 1/W, f(W-1) maps to 1 - 1/w
     // linear function x*S +B, 1st constraint means B is (-1+1/W), plug into
-    // second and solve for S: S = 2*(1-1/W)/(W-1). The old code that did 
+    // second and solve for S: S = 2*(1-1/W)/(W-1). The old code that did
     // this was incorrect - but only for computing the differential solid
     // angle, where the final value was 1.0 instead of 1-1/w...
 

Stereo3D/Stereo3DMatrixHelper.cpp

@@ -23,12 +23,12 @@ namespace
     )
     {
         // note that most people have difficulty fusing images into 3D
-        // if the separation equals even just the human average. by 
+        // if the separation equals even just the human average. by
         // reducing the separation (interocular distance) by 1/2, we
         // guarantee a larger subset of people will see full 3D
 
         // the conservative setting should always be used. the only problem
-        // with the conservative setting is that the 3D effect will be less 
+        // with the conservative setting is that the 3D effect will be less
         // impressive on smaller screens (which makes sense, since your eye
         // cannot be tricked as easily based on the smaller fov). to simulate
         // the effect of a larger screen, use the liberal settings (debug only)
@@ -37,10 +37,10 @@ namespace
 
         // Liberal Settings: * max acuity angle: 1.6f degrees * interoc distance: 2.5f inches
 
-        // maximum visual accuity angle allowed is 3.2 degrees for 
-        // a physical scene, and 1.6 degrees for a virtual one. 
+        // maximum visual accuity angle allowed is 3.2 degrees for
+        // a physical scene, and 1.6 degrees for a virtual one.
         // thus we cannot allow an object to appear any closer to
-        // the viewer than 1.6 degrees (divided by two for most 
+        // the viewer than 1.6 degrees (divided by two for most
         // half-angle calculations)
 
         static const float fMaxStereoDistance = 780; // inches (should be between 10 and 20m)
@@ -135,7 +135,7 @@ XMMATRIX DirectX::StereoProjectionFovLH
     fVirtualProjection *= pStereoParameters->fStereoSeparationFactor; // incorporate developer defined bias
 
     //
-    // By applying a translation, we are forcing our cameras to be parallel 
+    // By applying a translation, we are forcing our cameras to be parallel
     //
 
     float fInvertedAngle = atanf(fVirtualProjection / (2.0f * NearZ));
@@ -212,15 +212,15 @@ XMMATRIX DirectX::StereoProjectionFovRH
     fVirtualProjection *= pStereoParameters->fStereoSeparationFactor; // incorporate developer defined bias
 
     //
-    // By applying a translation, we are forcing our cameras to be parallel 
+    // By applying a translation, we are forcing our cameras to be parallel
     //
 
     float fInvertedAngle = atanf(fVirtualProjection / (2.0f * NearZ));
 
     XMMATRIX proj = XMMatrixPerspectiveFovRH(FovAngleY, AspectRatio, NearZ, FarZ);
 
     //
-    // By applying a translation, we are forcing our cameras to be parallel 
+    // By applying a translation, we are forcing our cameras to be parallel
     //
 
     XMMATRIX patchedProjection;

Stereo3D/Stereo3DMatrixHelper.h

@@ -41,7 +41,7 @@ namespace DirectX
     // be 1.0, but during development, on small screens, this value can be raised to up to 2.0 in
     // order to exaggerate the 3D effect.  Values over 1.0 may cause discomfort on normal sized
     // displays. It defaults to 1.0.
-    // 
+    //
     struct STEREO_PARAMETERS
     {
         float fViewerDistanceInches;