Fixed merge

glm/core/func_geometric.inl

@@ -132,6 +132,7 @@ namespace glm
 	(
 		genType const & x, 
 		genType const & y
+        
 	)
 	{
 		GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'dot' only accept floating-point inputs");

glm/core/type_vec2.hpp

@@ -114,6 +114,12 @@ namespace detail
 
 		tvec2(tref2<T> const & r);
 
+        template <int E0, int E1>
+        GLM_FUNC_DECL tvec2(const glm::detail::swizzle<2,T,tvec2<T>,E0,E1,-1,-2>& that)
+        {
+            *this = that();
+        }
+
 		//////////////////////////////////////
 		// Convertion constructors
 

glm/core/type_vec3.hpp

@@ -64,7 +64,7 @@ namespace detail
 
 #	if(GLM_COMPONENT == GLM_COMPONENT_ONLY_XYZW)
 		value_type x, y, z;
-#	elif(GLM_COMPONENT == GLM_COMPONENT_MS_EXT)
+#	elif(GLM_COMPONENT == GLM_COMPONENT_MS_EXT || GLM_LANG == GLM_LANG_CXX0X)
 		union 
 		{
             _GLM_SWIZZLE3_2_MEMBERS(value_type,glm::detail::tvec2<value_type>,x,y,z)
@@ -116,6 +116,12 @@ namespace detail
 
 		GLM_FUNC_DECL tvec3(tref3<T> const & r);
 
+        template <int E0, int E1, int E2>
+        GLM_FUNC_DECL tvec3(const glm::detail::swizzle<3,T,tvec3<T>,E0,E1,E2,-1>& that)
+        {
+            *this = that();
+        }
+
 		//////////////////////////////////////
 		// Convertion scalar constructors
 

glm/core/type_vec4.hpp

@@ -118,6 +118,12 @@ namespace detail
 
 		GLM_FUNC_DECL tvec4(tref4<T> const & r);
 
+        template <int E0, int E1, int E2, int E3>
+        GLM_FUNC_DECL tvec4(const glm::detail::swizzle<4,T,tvec4<T>,E0,E1,E2,E3>& that)
+        {
+            *this = that();
+        }
+
 		//////////////////////////////////////
 		// Convertion scalar constructors
 

test/core/core_type_vec3.cpp

@@ -196,139 +196,49 @@ int test_vec3_swizzle_operators()
     return Error;
 }
 
-#if 0
+int test_vec3_swizzle_functions()
-using namespace glm;
-
-//
-// Description : Array and textureless GLSL 2D/3D/4D simplex 
-//               noise functions.
-//      Author : Ian McEwan, Ashima Arts.
-//  Maintainer : ijm
-//     Lastmod : 20110822 (ijm)
-//     License : Copyright (C) 2011 Ashima Arts. All rights reserved.
-//               Distributed under the MIT License. See LICENSE file.
-//               https://github.com/ashima/webgl-noise
-// 
-
-vec4 mod289(vec4 x) {
-  return x - floor(x * (1.0 / 289.0)) * 289.0; }
-
-float mod289(float x) {
-  return x - floor(x * (1.0 / 289.0)) * 289.0; }
-
-vec4 permute(vec4 x) {
-     return mod289(((x*34.0)+1.0)*x);
-}
-
-float permute(float x) {
-     return mod289(((x*34.0)+1.0)*x);
-}
-
-vec4 taylorInvSqrt(vec4 r)
 {
-  return 1.79284291400159 - 0.85373472095314 * r;
+    int Error = 0;
+
+    //
+    // NOTE: template functions cannot pick up the implicit conversion from
+    // a swizzle to the unswizzled type, therefore the operator() must be 
+    // used.  E.g.:
+    //
+    // glm::dot(u.xy, v.xy);        <--- Compile error
+    // glm::dot(u.xy(), v.xy());    <--- Compiles correctly
+    //
+
+    float r;
+
+    // vec2
+    glm::vec2 a(1, 2);
+    glm::vec2 b(10, 20);
+    r = glm::dot(a, b);                 Error += (int(r) == 50) ? 0 : 1;
+    r = glm::dot(a.xy(), b.xy());       Error += (int(r) == 50) ? 0 : 1;
+    r = glm::dot(a.xy(), b.yy());       Error += (int(r) == 60) ? 0 : 1;
+
+    // vec3
+    glm::vec3 q, u, v;
+    u = glm::vec3(1, 2, 3);
+    v = glm::vec3(10, 20, 30);
+    r = glm::dot(u, v);                 Error += (int(r) == 140) ? 0 : 1;
+    r = glm::dot(u.xyz(), v.zyz());     Error += (int(r) == 160) ? 0 : 1;
+    r = glm::dot(u, v.zyx());           Error += (int(r) == 100) ? 0 : 1;
+    r = glm::dot(u.xyz(), v);           Error += (int(r) == 140) ? 0 : 1;
+    r = glm::dot(u.xy(), v.xy());       Error += (int(r) == 50) ? 0 : 1;
+
+    // vec4
+    glm::vec4 s, t;
+    s = glm::vec4(1, 2, 3, 4);
+    t = glm::vec4(10, 20, 30, 40);
+    r = glm::dot(s, t);                 Error += (int(r) == 300) ? 0 : 1;
+    r = glm::dot(s.xyzw(), t.xyzw());   Error += (int(r) == 300) ? 0 : 1;
+    r = glm::dot(s.xyz(), t.xyz());     Error += (int(r) == 140) ? 0 : 1;
+
+    return Error;
 }
 
-float taylorInvSqrt(float r)
-{
-  return 1.79284291400159 - 0.85373472095314 * r;
-}
-
-vec4 grad4(float j, vec4 ip)
-  {
-  const vec4 ones = vec4(1.0, 1.0, 1.0, -1.0);
-  vec4 p,s;
-
-  p.xyz = floor( fract (vec3(j) * ip.xyz) * 7.0) * ip.z - 1.0;
-  p.w = 1.5 - dot(abs(p.xyz), ones.xyz);
-  s = vec4(lessThan(p, vec4(0.0)));
-  p.xyz = p.xyz + (s.xyz*2.0 - 1.0) * s.www; 
-
-  return p;
-  }
-
-float snoise(vec4 v)
-  {
-  const vec4  C = vec4( 0.138196601125011,  // (5 - sqrt(5))/20  G4
-                        0.276393202250021,  // 2 * G4
-                        0.414589803375032,  // 3 * G4
-                       -0.447213595499958); // -1 + 4 * G4
-
-// (sqrt(5) - 1)/4 = F4, used once below
-#define F4 0.309016994374947451
-
-// First corner
-  vec4 i  = floor(v + dot(v, vec4(F4)) );
-  vec4 x0 = v -   i + dot(i, C.xxxx);
-
-// Other corners
-
-// Rank sorting originally contributed by Bill Licea-Kane, AMD (formerly ATI)
-  vec4 i0;
-  vec3 isX = step( x0.yzw, x0.xxx );
-  vec3 isYZ = step( x0.zww, x0.yyz );
-//  i0.x = dot( isX, vec3( 1.0 ) );
-  i0.x = isX.x + isX.y + isX.z;
-  i0.yzw = 1.0 - isX;
-//  i0.y += dot( isYZ.xy, vec2( 1.0 ) );
-  i0.y += isYZ.x + isYZ.y;
-  i0.zw += 1.0 - isYZ.xy;
-  i0.z += isYZ.z;
-  i0.w += 1.0 - isYZ.z;
-
-  // i0 now contains the unique values 0,1,2,3 in each channel
-  vec4 i3 = clamp( i0, 0.0, 1.0 );
-  vec4 i2 = clamp( i0-1.0, 0.0, 1.0 );
-  vec4 i1 = clamp( i0-2.0, 0.0, 1.0 );
-
-  //  x0 = x0 - 0.0 + 0.0 * C.xxxx
-  //  x1 = x0 - i1  + 1.0 * C.xxxx
-  //  x2 = x0 - i2  + 2.0 * C.xxxx
-  //  x3 = x0 - i3  + 3.0 * C.xxxx
-  //  x4 = x0 - 1.0 + 4.0 * C.xxxx
-  vec4 x1 = x0 - i1 + C.xxxx;
-  vec4 x2 = x0 - i2 + C.yyyy;
-  vec4 x3 = x0 - i3 + C.zzzz;
-  vec4 x4 = x0 + C.wwww;
-
-// Permutations
-  i = mod289(i); 
-  float j0 = permute( permute( permute( permute(i.w) + i.z) + i.y) + i.x);
-  vec4 j1 = permute( permute( permute( permute (
-             i.w + vec4(i1.w, i2.w, i3.w, 1.0 ))
-           + i.z + vec4(i1.z, i2.z, i3.z, 1.0 ))
-           + i.y + vec4(i1.y, i2.y, i3.y, 1.0 ))
-           + i.x + vec4(i1.x, i2.x, i3.x, 1.0 ));
-
-// Gradients: 7x7x6 points over a cube, mapped onto a 4-cross polytope
-// 7*7*6 = 294, which is close to the ring size 17*17 = 289.
-  vec4 ip = vec4(1.0/294.0, 1.0/49.0, 1.0/7.0, 0.0) ;
-
-  vec4 p0 = grad4(j0,   ip);
-  vec4 p1 = grad4(j1.x, ip);
-  vec4 p2 = grad4(j1.y, ip);
-  vec4 p3 = grad4(j1.z, ip);
-  vec4 p4 = grad4(j1.w, ip);
-
-// Normalise gradients
-  vec4 norm = taylorInvSqrt(vec4(dot(p0,p0), dot(p1,p1), dot(p2, p2), dot(p3,p3)));
-  p0 *= norm.x;
-  p1 *= norm.y;
-  p2 *= norm.z;
-  p3 *= norm.w;
-  p4 *= taylorInvSqrt(dot(p4,p4));
-
-// Mix contributions from the five corners
-  vec3 m0 = max(0.6 - vec3(dot(x0,x0), dot(x1,x1), dot(x2,x2)), 0.0);
-  vec2 m1 = max(0.6 - vec2(dot(x3,x3), dot(x4,x4)            ), 0.0);
-  m0 = m0 * m0;
-  m1 = m1 * m1;
-  return 49.0 * ( dot(m0*m0, vec3( dot( p0, x0 ), dot( p1, x1 ), dot( p2, x2 )))
-               + dot(m1*m1, vec2( dot( p3, x3 ), dot( p4, x4 ) ) ) ) ;
-
-  }
-#endif
-
 int main()
 {
 	int Error = 0;
@@ -339,6 +249,7 @@ int main()
     Error += test_vec3_swizzle3_3();
     Error += test_vec3_swizzle_half();
     Error += test_vec3_swizzle_operators();
+    Error += test_vec3_swizzle_functions();
 	
 	return Error;
 }