Home Explore Help
Sign In
cpp
/
glm
mirror of https://github.com/g-truc/glm.git
2
0
Fork 0
Files Issues 0 Wiki
Browse Source

Fixed merge

Christophe Riccio 14 years ago
parent
283f7882da 84a54474c2
commit
fe41daa938
47 changed files with 3777 additions and 1032 deletions
Unified View Show Diff Stats
  1. 2 2
      doc/about.html
  2. 0 1
      doc/code.html
  3. 11 5
      doc/download.html
  4. 0 1
      doc/goodies.html
  5. 12 4
      doc/index.html
  6. 1 1
      doc/pages.doxy
  7. 15 0
      doc/src/data.xml
  8. 85 1
      glm/core/_detail.hpp
  9. 1 0
      glm/core/func_common.inl
  10. 25 3
      glm/core/func_exponential.inl
  11. 32 0
      glm/core/func_integer.inl
  12. 334 2
      glm/core/func_noise.inl
  13. 1 1
      glm/core/func_packing.inl
  14. 17 10
      glm/core/intrinsic_common.inl
  15. 5 5
      glm/core/type_half.inl
  16. 4 2
      glm/core/type_vec2.hpp
  17. 6 0
      glm/core/type_vec2.inl
  18. 32 11
      glm/core/type_vec3.hpp
  19. 42 0
      glm/core/type_vec3.inl
  20. 76 11
      glm/core/type_vec4.hpp
  21. 139 0
      glm/core/type_vec4.inl
  22. 0 1
      glm/ext.hpp
  23. 1 0
      glm/glm.hpp
  24. 81 0
      glm/gtc/noise.hpp
  25. 852 0
      glm/gtc/noise.inl
  26. 177 0
      glm/gtx/constants.hpp
  27. 792 0
      glm/gtx/constants.inl
  28. 6 6
      glm/gtx/gradient_paint.hpp
  29. 19 15
      glm/gtx/gradient_paint.inl
  30. 30 1
      glm/gtx/integer.hpp
  31. 115 1
      glm/gtx/integer.inl
  32. 1 19
      glm/gtx/noise.hpp
  33. 0 832
      glm/gtx/noise.inl
  34. 7 2
      glm/gtx/ulp.inl
  35. 2 52
      glm/gtx/unsigned_int.hpp
  36. 0 28
      glm/gtx/unsigned_int.inl
  37. 16 0
      readme.txt
  38. 112 0
      test/core/core_type_vec2.cpp
  39. 148 1
      test/core/core_type_vec3.cpp
  40. 190 5
      test/core/core_type_vec4.cpp
  41. 1 0
      test/gtc/CMakeLists.txt
  42. 199 0
      test/gtc/gtc_noise.cpp
  43. 70 0
      test/gtc/gtc_swizzle.cpp
  44. 2 0
      test/gtx/CMakeLists.txt
  45. 41 0
      test/gtx/gtx_gradient_paint.cpp
  46. 66 0
      test/gtx/gtx_integer.cpp
  47. 9 9
      test/gtx/gtx_noise.cpp

+ 2 - 2
doc/about.html
View File 

@@ -11,8 +11,8 @@
 
           ga.src = ('https:' == document.location.protocol ? 'https://ssl' : 'http://www') + '.google-analytics.com/ga.js';
 
           ga.src = ('https:' == document.location.protocol ? 'https://ssl' : 'http://www') + '.google-analytics.com/ga.js';
 
           var s = document.getElementsByTagName('script')[0]; s.parentNode.insertBefore(ga, s);
 
           var s = document.getElementsByTagName('script')[0]; s.parentNode.insertBefore(ga, s);
 
           })();
 
           })();
 
-        </script></head><body><table><tr><td class="menu"><div class="menu1"><br /><div><a href="./goodies/logo1920x1200.png"><img class="menu-img" src="./common/logo.png" alt="GLM Logo" /></a></div><br /><div><a class="menu" href="https://sourceforge.net/projects/ogl-math/files/glm-0.9.2.3/glm-0.9.2.3.zip/download">
 
-			Download GLM 0.9.2.3</a></div></div><br /><div class="menu2"><a href="./index.html">Front page</a></div><div class="menu2"><a href="./download.html">Downloads</a></div><div class="menu2"><a href="http://www.opengl.org/sdk/libs/GLM/">OpenGL SDK page</a></div><br /><div class="menu2"><a href="./glm-0.9.2.pdf">GLM Manual</a></div><div class="menu2"><a href="./api-0.9.2/index.html">GLM API</a></div><div class="menu2"><a href="./code.html">Code samples</a></div><div class="menu2"><a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.10.6.clean.pdf">GLSL Specification</a></div><div class="menu2"><a href="http://www.opengl.org/discussion_boards/ubbthreads.php?ubb=postlist&amp;Board=10&amp;page=1">OpenGL.org Toolkits forum</a></div><br /><div class="menu2"><a href="https://sourceforge.net/apps/trac/ogl-math/newticket">Report a bug</a></div><div class="menu2"><a href="https://sourceforge.net/projects/ogl-math/">SourceForge page</a></div><div class="menu2"><a href="http://www.g-truc.net/project-0016.html#menu">G-Truc Creation page</a></div><div class="menu2"><a href="http://ogl-math.git.sourceforge.net/git/gitweb.cgi?p=ogl-math/ogl-math;a=summary">Browse Git repository</a></div><div class="menu2"><a href="http://ogl-math.git.sourceforge.net/git/gitweb.cgi?p=ogl-math/ogl-math;a=snapshot;h=HEAD;sf=tgz">Source snapshot</a></div><br /><br /><div class="menu2"><a href="http://www.g-truc.net"><img class="menu-img" src="./common/g-truc.png" alt="G-Truc" /></a></div><br /></td><td class="page"><div class="title1"><img src="./common/title.png" alt="OpenGL Mathematics" /></div><div class="title3">GLSL + Optional features = OpenGL Mathematics (GLM)<br />A C++ mathematics library for graphics programming<br /></div><br /><br /><div><div class="title-date"> </div><div class="title4"> </div><div><p>
 
+        </script></head><body><table><tr><td class="menu"><div class="menu1"><br /><div><a href="./goodies/logo1920x1200.png"><img class="menu-img" src="./common/logo.png" alt="GLM Logo" /></a></div><br /><div><a class="menu" href="https://sourceforge.net/projects/ogl-math/files/glm-0.9.2.6/glm-0.9.2.6.zip/download">
 
+			Download GLM 0.9.2.6</a></div></div><br /><div class="menu2"><a href="./index.html">Front page</a></div><div class="menu2"><a href="./download.html">Downloads</a></div><div class="menu2"><a href="http://www.opengl.org/sdk/libs/GLM/">OpenGL SDK page</a></div><br /><div class="menu2"><a href="./glm-0.9.2.pdf">GLM Manual</a></div><div class="menu2"><a href="./api-0.9.2/index.html">GLM API</a></div><div class="menu2"><a href="./code.html">Code samples</a></div><div class="menu2"><a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.10.6.clean.pdf">GLSL Specification</a></div><div class="menu2"><a href="http://www.opengl.org/discussion_boards/ubbthreads.php?ubb=postlist&amp;Board=10&amp;page=1">OpenGL.org Toolkits forum</a></div><br /><div class="menu2"><a href="https://sourceforge.net/apps/trac/ogl-math/newticket">Report a bug</a></div><div class="menu2"><a href="https://sourceforge.net/projects/ogl-math/">SourceForge page</a></div><div class="menu2"><a href="http://www.g-truc.net/project-0016.html#menu">G-Truc Creation page</a></div><div class="menu2"><a href="http://ogl-math.git.sourceforge.net/git/gitweb.cgi?p=ogl-math/ogl-math;a=summary">Browse Git repository</a></div><div class="menu2"><a href="http://ogl-math.git.sourceforge.net/git/gitweb.cgi?p=ogl-math/ogl-math;a=snapshot;h=HEAD;sf=tgz">Source snapshot</a></div><br /><br /><div class="menu2"><a href="http://www.g-truc.net"><img class="menu-img" src="./common/g-truc.png" alt="G-Truc" /></a></div><br /></td><td class="page"><div class="title1"><img src="./common/title.png" alt="OpenGL Mathematics" /></div><div class="title3">GLSL + Optional features = OpenGL Mathematics (GLM)<br />A C++ mathematics library for graphics programming<br /></div><br /><br /><div><div class="title-date"> </div><div class="title4"> </div><div><p>
 
 			OpenGL Mathematics (GLM) is a header only C++ mathematics library for graphics software 
 			OpenGL Mathematics (GLM) is a header only C++ mathematics library for graphics software 
 			based on the <a href="http://www.opengl.org/documentation/glsl/">OpenGL Shading Language (GLSL)</a> specification.
 
 			based on the <a href="http://www.opengl.org/documentation/glsl/">OpenGL Shading Language (GLSL)</a> specification.
 
 		</p><p>
 
 		</p><p>

File diff suppressed because it is too large
+ 0 - 1
doc/code.html


+ 11 - 5
doc/download.html
View File 

@@ -11,11 +11,14 @@
 
           ga.src = ('https:' == document.location.protocol ? 'https://ssl' : 'http://www') + '.google-analytics.com/ga.js';
 
           ga.src = ('https:' == document.location.protocol ? 'https://ssl' : 'http://www') + '.google-analytics.com/ga.js';
 
           var s = document.getElementsByTagName('script')[0]; s.parentNode.insertBefore(ga, s);
 
           var s = document.getElementsByTagName('script')[0]; s.parentNode.insertBefore(ga, s);
 
           })();
 
           })();
 
-        </script></head><body><table><tr><td class="menu"><div class="menu1"><br /><div><a href="./goodies/logo1920x1200.png"><img class="menu-img" src="./common/logo.png" alt="GLM Logo" /></a></div><br /><div><a class="menu" href="https://sourceforge.net/projects/ogl-math/files/glm-0.9.2.3/glm-0.9.2.3.zip/download">
 
-			Download GLM 0.9.2.3</a></div></div><br /><div class="menu2"><a href="./index.html">Front page</a></div><div class="menu2"><a href="./download.html">Downloads</a></div><div class="menu2"><a href="http://www.opengl.org/sdk/libs/GLM/">OpenGL SDK page</a></div><br /><div class="menu2"><a href="./glm-0.9.2.pdf">GLM Manual</a></div><div class="menu2"><a href="./api-0.9.2/index.html">GLM API</a></div><div class="menu2"><a href="./code.html">Code samples</a></div><div class="menu2"><a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.10.6.clean.pdf">GLSL Specification</a></div><div class="menu2"><a href="http://www.opengl.org/discussion_boards/ubbthreads.php?ubb=postlist&amp;Board=10&amp;page=1">OpenGL.org Toolkits forum</a></div><br /><div class="menu2"><a href="https://sourceforge.net/apps/trac/ogl-math/newticket">Report a bug</a></div><div class="menu2"><a href="https://sourceforge.net/projects/ogl-math/">SourceForge page</a></div><div class="menu2"><a href="http://www.g-truc.net/project-0016.html#menu">G-Truc Creation page</a></div><div class="menu2"><a href="http://ogl-math.git.sourceforge.net/git/gitweb.cgi?p=ogl-math/ogl-math;a=summary">Browse Git repository</a></div><div class="menu2"><a href="http://ogl-math.git.sourceforge.net/git/gitweb.cgi?p=ogl-math/ogl-math;a=snapshot;h=HEAD;sf=tgz">Source snapshot</a></div><br /><br /><div class="menu2"><a href="http://www.g-truc.net"><img class="menu-img" src="./common/g-truc.png" alt="G-Truc" /></a></div><br /></td><td class="page"><div class="title1"><img src="./common/title.png" alt="OpenGL Mathematics" /></div><div class="title3">GLSL + Optional features = OpenGL Mathematics (GLM)<br />A C++ mathematics library for graphics programming<br /></div><br /><br /><div><div class="title4">Current release</div></div><div class="issue-content">08/06/2011:
 
-                <a href="https://sourceforge.net/projects/ogl-math/files/glm-0.9.2.3/glm-0.9.2.3.zip/download">GLM 0.9.2.3</a>
 
+        </script></head><body><table><tr><td class="menu"><div class="menu1"><br /><div><a href="./goodies/logo1920x1200.png"><img class="menu-img" src="./common/logo.png" alt="GLM Logo" /></a></div><br /><div><a class="menu" href="https://sourceforge.net/projects/ogl-math/files/glm-0.9.2.6/glm-0.9.2.6.zip/download">
 
+			Download GLM 0.9.2.6</a></div></div><br /><div class="menu2"><a href="./index.html">Front page</a></div><div class="menu2"><a href="./download.html">Downloads</a></div><div class="menu2"><a href="http://www.opengl.org/sdk/libs/GLM/">OpenGL SDK page</a></div><br /><div class="menu2"><a href="./glm-0.9.2.pdf">GLM Manual</a></div><div class="menu2"><a href="./api-0.9.2/index.html">GLM API</a></div><div class="menu2"><a href="./code.html">Code samples</a></div><div class="menu2"><a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.10.6.clean.pdf">GLSL Specification</a></div><div class="menu2"><a href="http://www.opengl.org/discussion_boards/ubbthreads.php?ubb=postlist&amp;Board=10&amp;page=1">OpenGL.org Toolkits forum</a></div><br /><div class="menu2"><a href="https://sourceforge.net/apps/trac/ogl-math/newticket">Report a bug</a></div><div class="menu2"><a href="https://sourceforge.net/projects/ogl-math/">SourceForge page</a></div><div class="menu2"><a href="http://www.g-truc.net/project-0016.html#menu">G-Truc Creation page</a></div><div class="menu2"><a href="http://ogl-math.git.sourceforge.net/git/gitweb.cgi?p=ogl-math/ogl-math;a=summary">Browse Git repository</a></div><div class="menu2"><a href="http://ogl-math.git.sourceforge.net/git/gitweb.cgi?p=ogl-math/ogl-math;a=snapshot;h=HEAD;sf=tgz">Source snapshot</a></div><br /><br /><div class="menu2"><a href="http://www.g-truc.net"><img class="menu-img" src="./common/g-truc.png" alt="G-Truc" /></a></div><br /></td><td class="page"><div class="title1"><img src="./common/title.png" alt="OpenGL Mathematics" /></div><div class="title3">GLSL + Optional features = OpenGL Mathematics (GLM)<br />A C++ mathematics library for graphics programming<br /></div><br /><br /><div><div class="title4">Current release</div></div><div class="issue-content">01/10/2011:
 
+                <a href="https://sourceforge.net/projects/ogl-math/files/glm-0.9.2.6/glm-0.9.2.6.zip/download">GLM 0.9.2.6</a>
 
                 (3.4 MB)
 
                 (3.4 MB)
 
-              </div><div class="news-separator">_________________</div><br /><div><div class="title4">GLM - zip files</div><div class="issue-content">08/06/2011: <a href="https://sourceforge.net/projects/ogl-math/files/glm-0.9.2.3/glm-0.9.2.3.zip/download">GLM 0.9.2.3</a> (3.4 MB)
 
+              </div><div class="news-separator">_________________</div><br /><div><div class="title4">GLM - zip files</div><div class="issue-content">01/10/2011: <a href="https://sourceforge.net/projects/ogl-math/files/glm-0.9.2.6/glm-0.9.2.6.zip/download">GLM 0.9.2.6</a> (3.4 MB)
 
+    </div><div class="issue-content">20/09/2011: <a href="https://sourceforge.net/projects/ogl-math/files/glm-0.9.2.5/glm-0.9.2.5.zip/download">GLM 0.9.2.5</a> (3.4 MB)
 
+    </div><div class="issue-content">03/09/2011: <a href="https://sourceforge.net/projects/ogl-math/files/glm-0.9.2.4/glm-0.9.2.4.zip/download">GLM 0.9.2.4</a> (3.4 MB)
 
+    </div><div class="issue-content">08/06/2011: <a href="https://sourceforge.net/projects/ogl-math/files/glm-0.9.2.3/glm-0.9.2.3.zip/download">GLM 0.9.2.3</a> (3.4 MB)
 
     </div><div class="issue-content">02/06/2011: <a href="https://sourceforge.net/projects/ogl-math/files/glm-0.9.2.2/glm-0.9.2.2.zip/download">GLM 0.9.2.2</a> (3.4 MB)
 
     </div><div class="issue-content">02/06/2011: <a href="https://sourceforge.net/projects/ogl-math/files/glm-0.9.2.2/glm-0.9.2.2.zip/download">GLM 0.9.2.2</a> (3.4 MB)
 
     </div><div class="issue-content">24/05/2011: <a href="https://sourceforge.net/projects/ogl-math/files/glm-0.9.2.1/glm-0.9.2.1.zip/download">GLM 0.9.2.1</a> (3.4 MB)
 
     </div><div class="issue-content">24/05/2011: <a href="https://sourceforge.net/projects/ogl-math/files/glm-0.9.2.1/glm-0.9.2.1.zip/download">GLM 0.9.2.1</a> (3.4 MB)
 
     </div><div class="issue-content">08/05/2011: <a href="https://sourceforge.net/projects/ogl-math/files/glm-0.9.2.0/glm-0.9.2.0.zip/download">GLM 0.9.2.0</a> (3.4 MB)
 
     </div><div class="issue-content">08/05/2011: <a href="https://sourceforge.net/projects/ogl-math/files/glm-0.9.2.0/glm-0.9.2.0.zip/download">GLM 0.9.2.0</a> (3.4 MB)
 
@@ -76,7 +79,10 @@
 
     </div><div class="issue-content">02/19/2006: <a href="http://prdownloads.sourceforge.net/glf/glm-0.3.zip?download">GLM 0.3.0.0</a> (945 KB)
 
     </div><div class="issue-content">02/19/2006: <a href="http://prdownloads.sourceforge.net/glf/glm-0.3.zip?download">GLM 0.3.0.0</a> (945 KB)
 
     </div><div class="issue-content">05/05/2005: <a href="http://prdownloads.sourceforge.net/glf/glm-0.2.zip?download">GLM 0.2.0.0</a> (194 KB)
 
     </div><div class="issue-content">05/05/2005: <a href="http://prdownloads.sourceforge.net/glf/glm-0.2.zip?download">GLM 0.2.0.0</a> (194 KB)
 
     </div><div class="issue-content">02/21/2005: <a href="http://prdownloads.sourceforge.net/glf/glm-0.1-ur.zip?download">GLM 0.1.0.0</a> (29.2 KB)
 
     </div><div class="issue-content">02/21/2005: <a href="http://prdownloads.sourceforge.net/glf/glm-0.1-ur.zip?download">GLM 0.1.0.0</a> (29.2 KB)
 
-    </div></div><div class="news-separator">_________________</div><br /><div><div class="title4">GLM - 7z files</div><div class="issue-content">08/06/2011: <a href="https://sourceforge.net/projects/ogl-math/files/glm-0.9.2.3/glm-0.9.2.3.7z/download">GLM 0.9.2.3</a> (2.1 MB)
 
+    </div></div><div class="news-separator">_________________</div><br /><div><div class="title4">GLM - 7z files</div><div class="issue-content">01/10/2011: <a href="https://sourceforge.net/projects/ogl-math/files/glm-0.9.2.6/glm-0.9.2.6.7z/download">GLM 0.9.2.6</a> (2.1 MB)
 
+    </div><div class="issue-content">20/09/2011: <a href="https://sourceforge.net/projects/ogl-math/files/glm-0.9.2.5/glm-0.9.2.5.7z/download">GLM 0.9.2.5</a> (2.1 MB)
 
+    </div><div class="issue-content">03/09/2011: <a href="https://sourceforge.net/projects/ogl-math/files/glm-0.9.2.4/glm-0.9.2.4.7z/download">GLM 0.9.2.4</a> (2.1 MB)
 
+    </div><div class="issue-content">08/06/2011: <a href="https://sourceforge.net/projects/ogl-math/files/glm-0.9.2.3/glm-0.9.2.3.7z/download">GLM 0.9.2.3</a> (2.1 MB)
 
     </div><div class="issue-content">02/06/2011: <a href="https://sourceforge.net/projects/ogl-math/files/glm-0.9.2.2/glm-0.9.2.2.7z/download">GLM 0.9.2.2</a> (2.1 MB)
 
     </div><div class="issue-content">02/06/2011: <a href="https://sourceforge.net/projects/ogl-math/files/glm-0.9.2.2/glm-0.9.2.2.7z/download">GLM 0.9.2.2</a> (2.1 MB)
 
     </div><div class="issue-content">24/05/2011: <a href="https://sourceforge.net/projects/ogl-math/files/glm-0.9.2.1/glm-0.9.2.1.7z/download">GLM 0.9.2.1</a> (2.1 MB)
 
     </div><div class="issue-content">24/05/2011: <a href="https://sourceforge.net/projects/ogl-math/files/glm-0.9.2.1/glm-0.9.2.1.7z/download">GLM 0.9.2.1</a> (2.1 MB)
 
     </div><div class="issue-content">08/05/2011: <a href="https://sourceforge.net/projects/ogl-math/files/glm-0.9.2.0/glm-0.9.2.0.7z/download">GLM 0.9.2.0</a> (2.1 MB)
 
     </div><div class="issue-content">08/05/2011: <a href="https://sourceforge.net/projects/ogl-math/files/glm-0.9.2.0/glm-0.9.2.0.7z/download">GLM 0.9.2.0</a> (2.1 MB)

File diff suppressed because it is too large
+ 0 - 1
doc/goodies.html


+ 12 - 4
doc/index.html
View File 

@@ -11,8 +11,8 @@
 
           ga.src = ('https:' == document.location.protocol ? 'https://ssl' : 'http://www') + '.google-analytics.com/ga.js';
 
           ga.src = ('https:' == document.location.protocol ? 'https://ssl' : 'http://www') + '.google-analytics.com/ga.js';
 
           var s = document.getElementsByTagName('script')[0]; s.parentNode.insertBefore(ga, s);
 
           var s = document.getElementsByTagName('script')[0]; s.parentNode.insertBefore(ga, s);
 
           })();
 
           })();
 
-        </script></head><body><table><tr><td class="menu"><div class="menu1"><br /><div><a href="./goodies/logo1920x1200.png"><img class="menu-img" src="./common/logo.png" alt="GLM Logo" /></a></div><br /><div><a class="menu" href="https://sourceforge.net/projects/ogl-math/files/glm-0.9.2.3/glm-0.9.2.3.zip/download">
 
-			Download GLM 0.9.2.3</a></div></div><br /><div class="menu2"><a href="./index.html">Front page</a></div><div class="menu2"><a href="./download.html">Downloads</a></div><div class="menu2"><a href="http://www.opengl.org/sdk/libs/GLM/">OpenGL SDK page</a></div><br /><div class="menu2"><a href="./glm-0.9.2.pdf">GLM Manual</a></div><div class="menu2"><a href="./api-0.9.2/index.html">GLM API</a></div><div class="menu2"><a href="./code.html">Code samples</a></div><div class="menu2"><a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.10.6.clean.pdf">GLSL Specification</a></div><div class="menu2"><a href="http://www.opengl.org/discussion_boards/ubbthreads.php?ubb=postlist&amp;Board=10&amp;page=1">OpenGL.org Toolkits forum</a></div><br /><div class="menu2"><a href="https://sourceforge.net/apps/trac/ogl-math/newticket">Report a bug</a></div><div class="menu2"><a href="https://sourceforge.net/projects/ogl-math/">SourceForge page</a></div><div class="menu2"><a href="http://www.g-truc.net/project-0016.html#menu">G-Truc Creation page</a></div><div class="menu2"><a href="http://ogl-math.git.sourceforge.net/git/gitweb.cgi?p=ogl-math/ogl-math;a=summary">Browse Git repository</a></div><div class="menu2"><a href="http://ogl-math.git.sourceforge.net/git/gitweb.cgi?p=ogl-math/ogl-math;a=snapshot;h=HEAD;sf=tgz">Source snapshot</a></div><br /><br /><div class="menu2"><a href="http://www.g-truc.net"><img class="menu-img" src="./common/g-truc.png" alt="G-Truc" /></a></div><br /></td><td class="page"><div class="title1"><img src="./common/title.png" alt="OpenGL Mathematics" /></div><div class="title3">GLSL + Optional features = OpenGL Mathematics (GLM)<br />A C++ mathematics library for graphics programming<br /></div><br /><br /><p>
 
+        </script></head><body><table><tr><td class="menu"><div class="menu1"><br /><div><a href="./goodies/logo1920x1200.png"><img class="menu-img" src="./common/logo.png" alt="GLM Logo" /></a></div><br /><div><a class="menu" href="https://sourceforge.net/projects/ogl-math/files/glm-0.9.2.6/glm-0.9.2.6.zip/download">
 
+			Download GLM 0.9.2.6</a></div></div><br /><div class="menu2"><a href="./index.html">Front page</a></div><div class="menu2"><a href="./download.html">Downloads</a></div><div class="menu2"><a href="http://www.opengl.org/sdk/libs/GLM/">OpenGL SDK page</a></div><br /><div class="menu2"><a href="./glm-0.9.2.pdf">GLM Manual</a></div><div class="menu2"><a href="./api-0.9.2/index.html">GLM API</a></div><div class="menu2"><a href="./code.html">Code samples</a></div><div class="menu2"><a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.10.6.clean.pdf">GLSL Specification</a></div><div class="menu2"><a href="http://www.opengl.org/discussion_boards/ubbthreads.php?ubb=postlist&amp;Board=10&amp;page=1">OpenGL.org Toolkits forum</a></div><br /><div class="menu2"><a href="https://sourceforge.net/apps/trac/ogl-math/newticket">Report a bug</a></div><div class="menu2"><a href="https://sourceforge.net/projects/ogl-math/">SourceForge page</a></div><div class="menu2"><a href="http://www.g-truc.net/project-0016.html#menu">G-Truc Creation page</a></div><div class="menu2"><a href="http://ogl-math.git.sourceforge.net/git/gitweb.cgi?p=ogl-math/ogl-math;a=summary">Browse Git repository</a></div><div class="menu2"><a href="http://ogl-math.git.sourceforge.net/git/gitweb.cgi?p=ogl-math/ogl-math;a=snapshot;h=HEAD;sf=tgz">Source snapshot</a></div><br /><br /><div class="menu2"><a href="http://www.g-truc.net"><img class="menu-img" src="./common/g-truc.png" alt="G-Truc" /></a></div><br /></td><td class="page"><div class="title1"><img src="./common/title.png" alt="OpenGL Mathematics" /></div><div class="title3">GLSL + Optional features = OpenGL Mathematics (GLM)<br />A C++ mathematics library for graphics programming<br /></div><br /><br /><p>
 
 			OpenGL Mathematics (GLM) is a header only C++ mathematics library for graphics software 
 			OpenGL Mathematics (GLM) is a header only C++ mathematics library for graphics software 
 			based on the <a href="http://www.opengl.org/documentation/glsl/">OpenGL Shading Language (GLSL)</a> specification.
 
 			based on the <a href="http://www.opengl.org/documentation/glsl/">OpenGL Shading Language (GLSL)</a> specification.
 
 		</p><p>
 
 		</p><p>
 
@@ -33,8 +33,16 @@
 
 		</p><p>
 
 		</p><p>
 
 			Thanks for contributing to the project by <a href="https://sourceforge.net/apps/trac/ogl-math/newticket">submitting tickets</a> for bug reports and feature requests. (SF.net account required).
 
 			Thanks for contributing to the project by <a href="https://sourceforge.net/apps/trac/ogl-math/newticket">submitting tickets</a> for bug reports and feature requests. (SF.net account required).
 
 			Any feedback is welcome at [email protected].
 
 			Any feedback is welcome at [email protected].
 
-		</p><br /><div><h3>08/06/2011 - GLM 0.9.2.3 released</h3><div><p>
 
-			  This version only fixes a couple a major bugs introduced in GLM 0.9.2.2. 
+		</p><br /><div><h3>01/10/2011 - GLM 0.9.2.6 released</h3><div><p>
 
+        Half based vector types have been fixed on GCC 4.4 and below, missing l-value swizzle operations added and a couple of other bugs squeezed down.
 
+      </p><p>
 
+        Finally, all the Visual C++ /W4 warnings should have been removed. However, for this to happen, it is required to build with the Visual C++ language extension disabled (/Za).
 
+      </p>Download: <a href="https://sourceforge.net/projects/ogl-math/files/glm-0.9.2.6/glm-0.9.2.6.zip/download">GLM 0.9.2.6 (zip)</a><br />Download: <a href="https://sourceforge.net/projects/ogl-math/files/glm-0.9.2.6/glm-0.9.2.6.7z/download">GLM 0.9.2.6 (7z)</a><br />Link: <a href="https://sourceforge.net/apps/trac/ogl-math/newticket">Submit a bug report</a><br /></div><br /></div><div><h3>20/09/2011 - GLM 0.9.2.5 released</h3><div><p>
 
+        This update fixes some major core issues including the implementation of round, floatBitToXint, pack and unpack functions.
 
+      </p>Download: <a href="https://sourceforge.net/projects/ogl-math/files/glm-0.9.2.5/glm-0.9.2.5.zip/download">GLM 0.9.2.5 (zip)</a><br />Download: <a href="https://sourceforge.net/projects/ogl-math/files/glm-0.9.2.5/glm-0.9.2.5.7z/download">GLM 0.9.2.5 (7z)</a><br />Link: <a href="https://sourceforge.net/apps/trac/ogl-math/newticket">Submit a bug report</a><br /></div><br /></div><div><h3>03/09/2011 - GLM 0.9.2.4 released</h3><div><p>
 
+			  Fixed bugs and warnings reported by GLM users. Thanks!
 
+		  </p>Download: <a href="https://sourceforge.net/projects/ogl-math/files/glm-0.9.2.4/glm-0.9.2.4.zip/download">GLM 0.9.2.4 (zip)</a><br />Download: <a href="https://sourceforge.net/projects/ogl-math/files/glm-0.9.2.4/glm-0.9.2.4.7z/download">GLM 0.9.2.4 (7z)</a><br />Link: <a href="https://sourceforge.net/apps/trac/ogl-math/newticket">Submit a bug report</a><br /></div><br /></div><div><h3>08/06/2011 - GLM 0.9.2.3 released</h3><div><p>
 
+			  This version only fixes a couple of major bugs introduced in GLM 0.9.2.2. 
 		  </p>Download: <a href="https://sourceforge.net/projects/ogl-math/files/glm-0.9.2.3/glm-0.9.2.3.zip/download">GLM 0.9.2.3 (zip)</a><br />Download: <a href="https://sourceforge.net/projects/ogl-math/files/glm-0.9.2.3/glm-0.9.2.3.7z/download">GLM 0.9.2.3 (7z)</a><br />Link: <a href="https://sourceforge.net/apps/trac/ogl-math/newticket">Submit a bug report</a><br /></div><br /></div><div><h3>02/06/2011 - GLM 0.9.2.2 released</h3><div><p>
 
 		  </p>Download: <a href="https://sourceforge.net/projects/ogl-math/files/glm-0.9.2.3/glm-0.9.2.3.zip/download">GLM 0.9.2.3 (zip)</a><br />Download: <a href="https://sourceforge.net/projects/ogl-math/files/glm-0.9.2.3/glm-0.9.2.3.7z/download">GLM 0.9.2.3 (7z)</a><br />Link: <a href="https://sourceforge.net/apps/trac/ogl-math/newticket">Submit a bug report</a><br /></div><br /></div><div><h3>02/06/2011 - GLM 0.9.2.2 released</h3><div><p>
 
 			The main improvement of this version comes from the extended number of matrix constructors so that a programmer can used different scalar types for each parameter.
 
 			The main improvement of this version comes from the extended number of matrix constructors so that a programmer can used different scalar types for each parameter.
 
 		  </p><ul xmlns="http://www.w3.org/1999/xhtml" class="code-list"><li class="code-line"><span class="code-line-content"><span class="keyword">#include </span><span class="string">&lt;glm/glm.hpp&gt;</span></span></li><li class="code-line"><span class="code-line-content" /></li><li class="code-line"><span class="code-line-content"><span class="comment">// Create an identity matrix</span></span></li><li class="code-line"><span class="code-line-content">
 
 		  </p><ul xmlns="http://www.w3.org/1999/xhtml" class="code-list"><li class="code-line"><span class="code-line-content"><span class="keyword">#include </span><span class="string">&lt;glm/glm.hpp&gt;</span></span></li><li class="code-line"><span class="code-line-content" /></li><li class="code-line"><span class="code-line-content"><span class="comment">// Create an identity matrix</span></span></li><li class="code-line"><span class="code-line-content">

+ 1 - 1
doc/pages.doxy
View File 

@@ -265,7 +265,7 @@ void foo()
 
 	
 	
 	\section advanced_inline Force Inline
 
 	\section advanced_inline Force Inline
 
 	
 	
-	GLM's functions are defined in headers, so they are defined with C++'s "inline" delcaration. 
+	GLM's functions are defined in headers, so they are defined with C++'s "inline" declaration. 
 	This does not require the compiler to inline them, however. 
 	This does not require the compiler to inline them, however. 
 	To force the compiler to inline the function, using whatever capabilities that the compiler provides to do so, 
 	To force the compiler to inline the function, using whatever capabilities that the compiler provides to do so, 
 	GLM_FORCE_INLINE can be defined before any inclusion of <glm/glm.hpp>.
 
 	GLM_FORCE_INLINE can be defined before any inclusion of <glm/glm.hpp>.

+ 15 - 0
doc/src/data.xml
View File 

@@ -3,6 +3,7 @@
 
 <glm copyright="Copyright © 2005 - 2011">
 
 <glm copyright="Copyright © 2005 - 2011">
 
   <downloads>
 
   <downloads>
 
     <section name="GLM - zip files">
 
     <section name="GLM - zip files">
 
+      <download name="GLM 0.9.2.6" date="01/10/2011" size="3.4 MB" link="https://sourceforge.net/projects/ogl-math/files/glm-0.9.2.6/glm-0.9.2.6.zip/download"/>
 
       <download name="GLM 0.9.2.5" date="20/09/2011" size="3.4 MB" link="https://sourceforge.net/projects/ogl-math/files/glm-0.9.2.5/glm-0.9.2.5.zip/download"/>
 
       <download name="GLM 0.9.2.5" date="20/09/2011" size="3.4 MB" link="https://sourceforge.net/projects/ogl-math/files/glm-0.9.2.5/glm-0.9.2.5.zip/download"/>
 
 		<download name="GLM 0.9.2.4" date="03/09/2011" size="3.4 MB" link="https://sourceforge.net/projects/ogl-math/files/glm-0.9.2.4/glm-0.9.2.4.zip/download"/>
 
 		<download name="GLM 0.9.2.4" date="03/09/2011" size="3.4 MB" link="https://sourceforge.net/projects/ogl-math/files/glm-0.9.2.4/glm-0.9.2.4.zip/download"/>
 
 		<download name="GLM 0.9.2.3" date="08/06/2011" size="3.4 MB" link="https://sourceforge.net/projects/ogl-math/files/glm-0.9.2.3/glm-0.9.2.3.zip/download"/>
 
 		<download name="GLM 0.9.2.3" date="08/06/2011" size="3.4 MB" link="https://sourceforge.net/projects/ogl-math/files/glm-0.9.2.3/glm-0.9.2.3.zip/download"/>
 
@@ -68,6 +69,7 @@
 
       <download name="GLM 0.1.0.0" date="02/21/2005" size="29.2 KB" link="http://prdownloads.sourceforge.net/glf/glm-0.1-ur.zip?download"/>
 
       <download name="GLM 0.1.0.0" date="02/21/2005" size="29.2 KB" link="http://prdownloads.sourceforge.net/glf/glm-0.1-ur.zip?download"/>
 
     </section>
 
     </section>
 
     <section name="GLM - 7z files">
 
     <section name="GLM - 7z files">
 
+      <download name="GLM 0.9.2.6" date="01/10/2011" size="2.1 MB" link="https://sourceforge.net/projects/ogl-math/files/glm-0.9.2.6/glm-0.9.2.6.7z/download"/>
 
       <download name="GLM 0.9.2.5" date="20/09/2011" size="2.1 MB" link="https://sourceforge.net/projects/ogl-math/files/glm-0.9.2.5/glm-0.9.2.5.7z/download"/>
 
       <download name="GLM 0.9.2.5" date="20/09/2011" size="2.1 MB" link="https://sourceforge.net/projects/ogl-math/files/glm-0.9.2.5/glm-0.9.2.5.7z/download"/>
 
 		<download name="GLM 0.9.2.4" date="03/09/2011" size="2.1 MB" link="https://sourceforge.net/projects/ogl-math/files/glm-0.9.2.4/glm-0.9.2.4.7z/download"/>
 
 		<download name="GLM 0.9.2.4" date="03/09/2011" size="2.1 MB" link="https://sourceforge.net/projects/ogl-math/files/glm-0.9.2.4/glm-0.9.2.4.7z/download"/>
 
 		<download name="GLM 0.9.2.3" date="08/06/2011" size="2.1 MB" link="https://sourceforge.net/projects/ogl-math/files/glm-0.9.2.3/glm-0.9.2.3.7z/download"/>
 
 		<download name="GLM 0.9.2.3" date="08/06/2011" size="2.1 MB" link="https://sourceforge.net/projects/ogl-math/files/glm-0.9.2.3/glm-0.9.2.3.7z/download"/>
 
@@ -160,6 +162,19 @@
 
   </todo>
 
   </todo>
 
 
 
   <page_news>
 
   <page_news>
 
+    <news index="0071" date="01/10/2011" title="GLM 0.9.2.6 released" image="goodies/logo.png" image-mini="image/logo-mini.png">
 
+      <paragraph>
 
+        Half based vector types have been fixed on GCC 4.4 and below, missing l-value swizzle operations added and a couple of other bugs squeezed down.
 
+      </paragraph>
 
+      <paragraph>
 
+        Finally, all the Visual C++ /W4 warnings should have been removed. However, for this to happen, it is required to build with the Visual C++ language extension disabled (/Za).
 
+      </paragraph>
 
+
 
+      <source type="Download" href="https://sourceforge.net/projects/ogl-math/files/glm-0.9.2.6/glm-0.9.2.6.zip/download">GLM 0.9.2.6 (zip)</source>
 
+      <source type="Download" href="https://sourceforge.net/projects/ogl-math/files/glm-0.9.2.6/glm-0.9.2.6.7z/download">GLM 0.9.2.6 (7z)</source>
 
+      <source type="Link" href="https://sourceforge.net/apps/trac/ogl-math/newticket">Submit a bug report</source>
 
+    </news>
 
+    
     <news index="0070" date="20/09/2011" title="GLM 0.9.2.5 released" image="goodies/logo.png" image-mini="image/logo-mini.png">
 
     <news index="0070" date="20/09/2011" title="GLM 0.9.2.5 released" image="goodies/logo.png" image-mini="image/logo-mini.png">
 
       <paragraph>
 
       <paragraph>
 
         This update fixes some major core issues including the implementation of round, floatBitToXint, pack and unpack functions.
 
         This update fixes some major core issues including the implementation of round, floatBitToXint, pack and unpack functions.

+ 85 - 1
glm/core/_detail.hpp
View File 

@@ -345,8 +345,92 @@ namespace detail
 
 	typedef float								float32;
 
 	typedef float								float32;
 
 	typedef double								float64;
 
 	typedef double								float64;
 
 	
 	
-}//namespace detail
 
+	//////////////////
 
+	// float_or_int_trait 
+
 
+	struct float_or_int_value
 
+	{
 
+		enum
 
+		{
 
+			ERROR,
 
+			FLOAT,
 
+			INT
 
+		};
 
+	};
 
+
 
+	template <typename T>
 
+	struct float_or_int_trait
 
+	{
 
+		enum{ID = float_or_int_value::ERROR};
 
+	};
 
+
 
+	template <>
 
+	struct float_or_int_trait<int8>
 
+	{
 
+		enum{ID = float_or_int_value::INT};
 
+	};
 
+
 
+	template <>
 
+	struct float_or_int_trait<int16>
 
+	{
 
+		enum{ID = float_or_int_value::INT};
 
+	};
 
+
 
+	template <>
 
+	struct float_or_int_trait<int32>
 
+	{
 
+		enum{ID = float_or_int_value::INT};
 
+	};
 
+
 
+	template <>
 
+	struct float_or_int_trait<int64>
 
+	{
 
+		enum{ID = float_or_int_value::INT};
 
+	};
 
+
 
+	template <>
 
+	struct float_or_int_trait<uint8>
 
+	{
 
+		enum{ID = float_or_int_value::INT};
 
+	};
 
+
 
+	template <>
 
+	struct float_or_int_trait<uint16>
 
+	{
 
+		enum{ID = float_or_int_value::INT};
 
+	};
 
+
 
+	template <>
 
+	struct float_or_int_trait<uint32>
 
+	{
 
+		enum{ID = float_or_int_value::INT};
 
+	};
 
+
 
+	template <>
 
+	struct float_or_int_trait<uint64>
 
+	{
 
+		enum{ID = float_or_int_value::INT};
 
+	};
 
+
 
+	template <>
 
+	struct float_or_int_trait<float16>
 
+	{
 
+		enum{ID = float_or_int_value::FLOAT};
 
+	};
 
+
 
+	template <>
 
+	struct float_or_int_trait<float32>
 
+	{
 
+		enum{ID = float_or_int_value::FLOAT};
 
+	};
 
 
 
+	template <>
 
+	struct float_or_int_trait<float64>
 
+	{
 
+		enum{ID = float_or_int_value::FLOAT};
 
+	};
 
+
 
+}//namespace detail
 
 }//namespace glm
 
 }//namespace glm
 
 
 
 #if((GLM_COMPILER & GLM_COMPILER_VC) && (GLM_COMPILER >= GLM_COMPILER_VC2005))
 
 #if((GLM_COMPILER & GLM_COMPILER_VC) && (GLM_COMPILER >= GLM_COMPILER_VC2005))

+ 1 - 0
glm/core/func_common.inl
View File 

@@ -42,6 +42,7 @@ namespace detail
 
                 detail::type<genFIType>::is_float || 
                 detail::type<genFIType>::is_float || 
                 detail::type<genFIType>::is_int, "'abs' only accept floating-point and integer inputs");
 
                 detail::type<genFIType>::is_int, "'abs' only accept floating-point and integer inputs");
 
             return x >= genFIType(0) ? x : -x;
 
             return x >= genFIType(0) ? x : -x;
 
+			// TODO, perf comp with: *(((int *) &x) + 1) &= 0x7fffffff;
 
         }
 
         }
 
     };
 
     };

+ 25 - 3
glm/core/func_exponential.inl
View File 

@@ -224,6 +224,30 @@ namespace glm
 
             exp2(x.w));
 
             exp2(x.w));
 
     }
 
     }
 
 
 
+namespace detail
 
+{
 
+	template <int PATH = float_or_int_value::ERROR>
 
+	struct compute_log2
 
+	{
 
+		template <typename T>
 
+		T operator() (T const & Value) const
 
+		{
 
+			static_assert(0, "'log2' parameter has an invalid template parameter type");
 
+			return Value;
 
+		}
 
+	};
 
+
 
+	template <>
 
+	struct compute_log2<float_or_int_value::FLOAT>
 
+	{
 
+		template <typename T>
 
+		T operator() (T const & Value) const
 
+		{
 
+			return ::std::log(Value) / T(0.69314718055994530941723212145818);
 
+		}
 
+	};
 
+}//namespace detail
 
+
 
     // log2, ln2 = 0.69314718055994530941723212145818f
 
     // log2, ln2 = 0.69314718055994530941723212145818f
 
     template <typename genType>
 
     template <typename genType>
 
     GLM_FUNC_QUALIFIER genType log2
 
     GLM_FUNC_QUALIFIER genType log2
 
@@ -231,9 +255,7 @@ namespace glm
 
 		genType const & x
 
 		genType const & x
 
 	)
 
 	)
 
     {
 
     {
 
-		GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'log2' only accept floating-point input");
 
-
 
-        return ::std::log(x) / genType(0.69314718055994530941723212145818);
 
+		return detail::compute_log2<detail::float_or_int_trait<genType>::ID>()(x);
 
     }
 
     }
 
 
 
     template <typename T>
 
     template <typename T>

+ 32 - 0
glm/core/func_integer.inl
View File 

@@ -26,6 +26,11 @@
 
 /// @author Christophe Riccio
 
 /// @author Christophe Riccio
 
 ///////////////////////////////////////////////////////////////////////////////////
 
 ///////////////////////////////////////////////////////////////////////////////////
 
 
 
+#if(GLM_COMPILER & GLM_COMPILER_VC)
 
+#include <intrin.h>
 
+#pragma intrinsic(_BitScanReverse)
 
+#endif
 
+
 
 namespace glm
 
 namespace glm
 
 {
 
 {
 
 	// uaddCarry
 
 	// uaddCarry
 
@@ -550,6 +555,32 @@ namespace glm
 
 	}
 
 	}
 
 
 
 	// findMSB
 
 	// findMSB
 
+#if(GLM_COMPILER & GLM_COMPILER_VC)
 
+
 
+	template <typename genIUType>
 
+	GLM_FUNC_QUALIFIER int findMSB
 
+	(
 
+		genIUType const & Value
 
+	)
 
+	{
 
+		unsigned long Result(0);
 
+		_BitScanReverse(&Result, Value); 
+		return int(Result);
 
+	}
 
+
 
+#elif((GLM_COMPILER & GLM_COMPILER_GCC) && __has_builtin(__builtin_clz))
 
+
 
+	template <typename genIUType>
 
+	GLM_FUNC_QUALIFIER int findMSB
 
+	(
 
+		genIUType const & Value
 
+	)
 
+	{
 
+		return __builtin_clz(x);
 
+	}
 
+
 
+#else
 
+
 
 	template <typename genIUType>
 
 	template <typename genIUType>
 
 	GLM_FUNC_QUALIFIER int findMSB
 
 	GLM_FUNC_QUALIFIER int findMSB
 
 	(
 
 	(
 
@@ -564,6 +595,7 @@ namespace glm
 
 		for(genIUType tmp = Value; tmp; tmp >>= 1, ++bit){}
 
 		for(genIUType tmp = Value; tmp; tmp >>= 1, ++bit){}
 
 		return bit;
 
 		return bit;
 
 	}
 
 	}
 
+#endif//(GLM_COMPILER)
 
 
 
 	template <typename T>
 
 	template <typename T>
 
 	GLM_FUNC_QUALIFIER detail::tvec2<int> findMSB
 
 	GLM_FUNC_QUALIFIER detail::tvec2<int> findMSB

+ 334 - 2
glm/core/func_noise.inl
View File 

@@ -22,11 +22,343 @@
 
 ///
 
 ///
 
 /// @ref core
 
 /// @ref core
 
 /// @file glm/core/func_noise.inl
 
 /// @file glm/core/func_noise.inl
 
-/// @date 2008-08-01 / 2011-06-15
 
+/// @date 2008-08-01 / 2011-09-27
 
 /// @author Christophe Riccio
 
 /// @author Christophe Riccio
 
 ///////////////////////////////////////////////////////////////////////////////////
 
 ///////////////////////////////////////////////////////////////////////////////////
 
 
 
 namespace glm
 
 namespace glm
 
-{
 
+{	
+	template <typename T>
 
+	GLM_FUNC_QUALIFIER T noise1(T const & x)
 
+	{
 
+		return noise1(glm::detail::tvec2<T>(x, T(0)));
 
+	}
 
 
 
+	template <typename T>
 
+	GLM_FUNC_QUALIFIER glm::detail::tvec2<T> noise2(T const & x)
 
+	{
 
+		return glm::detail::tvec2<T>(
 
+			noise1(x + T(0.0)),
 
+			noise1(x + T(1.0)));
 
+	}
 
+
 
+	template <typename T>
 
+	GLM_FUNC_QUALIFIER glm::detail::tvec3<T> noise3(T const & x)
 
+	{
 
+		return glm::detail::tvec3<T>(
 
+			noise1(x - T(1.0)),
 
+			noise1(x + T(0.0)),
 
+			noise1(x + T(1.0)));
 
+	}
 
+
 
+	template <typename T>
 
+	GLM_FUNC_QUALIFIER glm::detail::tvec4<T> noise4(T const & x)
 
+	{
 
+		return glm::detail::tvec4<T>(
 
+			noise1(x - T(1.0)),
 
+			noise1(x + T(0.0)),
 
+			noise1(x + T(1.0)),
 
+			noise1(x + T(2.0)));
 
+	}
 
+	
+	template <typename T>
 
+	GLM_FUNC_QUALIFIER T noise1(glm::detail::tvec2<T> const & v)
 
+	{
 
+		detail::tvec4<T> const C = detail::tvec4<T>(
 
+													T( 0.211324865405187),  // (3.0 -  sqrt(3.0)) / 6.0
 
+													T( 0.366025403784439),  //  0.5 * (sqrt(3.0)  - 1.0)
 
+													T(-0.577350269189626),	// -1.0 + 2.0 * C.x
 
+													T( 0.024390243902439)); //  1.0 / 41.0
 
+		
+		// First corner
 
+		detail::tvec2<T> i  = floor(v + dot(v, detail::tvec2<T>(C[1])));
 
+		detail::tvec2<T> x0 = v -   i + dot(i, detail::tvec2<T>(C[0]));
 
+		
+		// Other corners
 
+		//i1.x = step( x0.y, x0.x ); // x0.x > x0.y ? 1.0 : 0.0
 
+		//i1.y = 1.0 - i1.x;
 
+		detail::tvec2<T> i1 = (x0.x > x0.y) ? detail::tvec2<T>(1, 0) : detail::tvec2<T>(0, 1);
 
+		// x0 = x0 - 0.0 + 0.0 * C.xx ;
 
+		// x1 = x0 - i1 + 1.0 * C.xx ;
 
+		// x2 = x0 - 1.0 + 2.0 * C.xx ;
 
+		detail::tvec4<T> x12 = detail::tvec4<T>(x0.x, x0.y, x0.x, x0.y) + detail::tvec4<T>(C.x, C.x, C.z, C.z);
 
+		x12 = detail::tvec4<T>(detail::tvec2<T>(x12) - i1, x12.z, x12.w);
 
+		
+		// Permutations
 
+		i = mod(i, T(289)); // Avoid truncation effects in permutation
 
+		detail::tvec3<T> p = permute(
 
+									 permute(i.y + detail::tvec3<T>(T(0), i1.y, T(1)))
 
+									 + i.x + detail::tvec3<T>(T(0), i1.x, T(1)));
 
+		
+		detail::tvec3<T> m = max(T(0.5) - detail::tvec3<T>(
 
+														   dot(x0, x0), 
+														   dot(detail::tvec2<T>(x12.x, x12.y), detail::tvec2<T>(x12.x, x12.y)), 
+														   dot(detail::tvec2<T>(x12.z, x12.w), detail::tvec2<T>(x12.z, x12.w))), T(0));
 
+		m = m * m ;
 
+		m = m * m ;
 
+		
+		// Gradients: 41 points uniformly over a line, mapped onto a diamond.
 
+		// The ring size 17*17 = 289 is close to a multiple of 41 (41*7 = 287)
 
+		
+		detail::tvec3<T> x = T(2) * fract(p * C.w) - T(1);
 
+		detail::tvec3<T> h = abs(x) - T(0.5);
 
+		detail::tvec3<T> ox = floor(x + T(0.5));
 
+		detail::tvec3<T> a0 = x - ox;
 
+		
+		// Normalise gradients implicitly by scaling m
 
+		// Inlined for speed: m *= taylorInvSqrt( a0*a0 + h*h );
 
+		m *= T(1.79284291400159) - T(0.85373472095314) * (a0 * a0 + h * h);
 
+		
+		// Compute final noise value at P
 
+		detail::tvec3<T> g;
 
+		g.x  = a0.x  * x0.x  + h.x  * x0.y;
 
+		//g.yz = a0.yz * x12.xz + h.yz * x12.yw;
 
+		g.y = a0.y * x12.x + h.y * x12.y;
 
+		g.z = a0.z * x12.z + h.z * x12.w;
 
+		return T(130) * dot(m, g);
 
+	}
 
+	
+	template <typename T>
 
+	GLM_FUNC_QUALIFIER T noise1(detail::tvec3<T> const & v)
 
+	{ 
+		detail::tvec2<T> const C(1.0 / 6.0, 1.0 / 3.0);
 
+		detail::tvec4<T> const D(0.0, 0.5, 1.0, 2.0);
 
+		
+		// First corner
 
+		detail::tvec3<T> i(floor(v + dot(v, detail::tvec3<T>(C.y))));
 
+		detail::tvec3<T> x0(v - i + dot(i, detail::tvec3<T>(C.x)));
 
+		
+		// Other corners
 
+		detail::tvec3<T> g(step(detail::tvec3<T>(x0.y, x0.z, x0.x), x0));
 
+		detail::tvec3<T> l(T(1) - g);
 
+		detail::tvec3<T> i1(min(g, detail::tvec3<T>(l.z, l.x, l.y)));
 
+		detail::tvec3<T> i2(max(g, detail::tvec3<T>(l.z, l.x, l.y)));
 
+		
+		//   x0 = x0 - 0.0 + 0.0 * C.xxx;
 
+		//   x1 = x0 - i1  + 1.0 * C.xxx;
 
+		//   x2 = x0 - i2  + 2.0 * C.xxx;
 
+		//   x3 = x0 - 1.0 + 3.0 * C.xxx;
 
+		detail::tvec3<T> x1(x0 - i1 + C.x);
 
+		detail::tvec3<T> x2(x0 - i2 + C.y); // 2.0*C.x = 1/3 = C.y
 
+		detail::tvec3<T> x3(x0 - D.y);      // -1.0+3.0*C.x = -0.5 = -D.y
 
+		
+		// Permutations
 
+		i = mod289(i); 
+		detail::tvec4<T> p(permute(permute(permute( 
+												   i.z + detail::tvec4<T>(T(0), i1.z, i2.z, T(1))) + 
+										   i.y + detail::tvec4<T>(T(0), i1.y, i2.y, T(1))) + 
+								   i.x + detail::tvec4<T>(T(0), i1.x, i2.x, T(1))));
 
+		
+		// Gradients: 7x7 points over a square, mapped onto an octahedron.
 
+		// The ring size 17*17 = 289 is close to a multiple of 49 (49*6 = 294)
 
+		T n_ = T(0.142857142857); // 1.0/7.0
 
+		detail::tvec3<T> ns(n_ * detail::tvec3<T>(D.w, D.y, D.z) - detail::tvec3<T>(D.x, D.z, D.x));
 
+		
+		detail::tvec4<T> j(p - T(49) * floor(p * ns.z * ns.z));  //  mod(p,7*7)
 
+		
+		detail::tvec4<T> x_(floor(j * ns.z));
 
+		detail::tvec4<T> y_(floor(j - T(7) * x_));    // mod(j,N)
 
+		
+		detail::tvec4<T> x(x_ * ns.x + ns.y);
 
+		detail::tvec4<T> y(y_ * ns.x + ns.y);
 
+		detail::tvec4<T> h(T(1) - abs(x) - abs(y));
 
+		
+		detail::tvec4<T> b0(x.x, x.y, y.x, y.y);
 
+		detail::tvec4<T> b1(x.z, x.w, y.z, y.w);
 
+		
+		// vec4 s0 = vec4(lessThan(b0,0.0))*2.0 - 1.0;
 
+		// vec4 s1 = vec4(lessThan(b1,0.0))*2.0 - 1.0;
 
+		detail::tvec4<T> s0(floor(b0) * T(2) + T(1));
 
+		detail::tvec4<T> s1(floor(b1) * T(2) + T(1));
 
+		detail::tvec4<T> sh(-step(h, detail::tvec4<T>(0.0)));
 
+		
+		detail::tvec4<T> a0 = detail::tvec4<T>(b0.x, b0.z, b0.y, b0.w) + detail::tvec4<T>(s0.x, s0.z, s0.y, s0.w) * detail::tvec4<T>(sh.x, sh.x, sh.y, sh.y);
 
+		detail::tvec4<T> a1 = detail::tvec4<T>(b1.x, b1.z, b1.y, b1.w) + detail::tvec4<T>(s1.x, s1.z, s1.y, s1.w) * detail::tvec4<T>(sh.z, sh.z, sh.w, sh.w);
 
+		
+		detail::tvec3<T> p0(a0.x, a0.y, h.x);
 
+		detail::tvec3<T> p1(a0.z, a0.w, h.y);
 
+		detail::tvec3<T> p2(a1.x, a1.y, h.z);
 
+		detail::tvec3<T> p3(a1.z, a1.w, h.w);
 
+		
+		// Normalise gradients
 
+		detail::tvec4<T> norm = taylorInvSqrt(detail::tvec4<T>(dot(p0, p0), dot(p1, p1), dot(p2, p2), dot(p3, p3)));
 
+		p0 *= norm.x;
 
+		p1 *= norm.y;
 
+		p2 *= norm.z;
 
+		p3 *= norm.w;
 
+		
+		// Mix final noise value
 
+		detail::tvec4<T> m = max(T(0.6) - detail::tvec4<T>(dot(x0, x0), dot(x1, x1), dot(x2, x2), dot(x3, x3)), T(0));
 
+		m = m * m;
 
+		return T(42) * dot(m * m, detail::tvec4<T>(dot(p0, x0), dot(p1, x1), dot(p2, x2), dot(p3, x3)));
 
+	}
 
+	
+	template <typename T>
 
+	GLM_FUNC_QUALIFIER T noise1(detail::tvec4<T> const & v)
 
+	{
 
+		detail::tvec4<T> const C(
 
+								 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
 
+		T const F4 = T(0.309016994374947451);
 
+		
+		// First corner
 
+		detail::tvec4<T> i  = floor(v + dot(v, vec4(F4)));
 
+		detail::tvec4<T> x0 = v -   i + dot(i, vec4(C.x));
 
+		
+		// Other corners
 
+		
+		// Rank sorting originally contributed by Bill Licea-Kane, AMD (formerly ATI)
 
+		detail::tvec4<T> i0;
 
+		detail::tvec3<T> isX = step(detail::tvec3<T>(x0.y, x0.z, x0.w), detail::tvec3<T>(x0.x));
 
+		detail::tvec3<T> isYZ = step(detail::tvec3<T>(x0.z, x0.w, x0.w), detail::tvec3<T>(x0.y, x0.y, x0.z));
 
+		//  i0.x = dot(isX, vec3(1.0));
 
+		//i0.x = isX.x + isX.y + isX.z;
 
+		//i0.yzw = T(1) - isX;
 
+		i0 = detail::tvec4<T>(isX.x + isX.y + isX.z, T(1) - isX);
 
+		//  i0.y += dot(isYZ.xy, vec2(1.0));
 
+		i0.y += isYZ.x + isYZ.y;
 
+		//i0.zw += 1.0 - detail::tvec2<T>(isYZ.x, isYZ.y);
 
+		i0.z += T(1) - isYZ.x;
 
+		i0.w += T(1) - isYZ.y;
 
+		i0.z += isYZ.z;
 
+		i0.w += T(1) - isYZ.z;
 
+		
+		// i0 now contains the unique values 0,1,2,3 in each channel
 
+		detail::tvec4<T> i3 = clamp(i0, 0.0, 1.0);
 
+		detail::tvec4<T> i2 = clamp(i0 - 1.0, 0.0, 1.0);
 
+		detail::tvec4<T> i1 = clamp(i0 - 2.0, 0.0, 1.0);
 
+		
+		//  x0 = x0 - 0.0 + 0.0 * C.xxxx
 
+		//  x1 = x0 - i1  + 0.0 * C.xxxx
 
+		//  x2 = x0 - i2  + 0.0 * C.xxxx
 
+		//  x3 = x0 - i3  + 0.0 * C.xxxx
 
+		//  x4 = x0 - 1.0 + 4.0 * C.xxxx
 
+		detail::tvec4<T> x1 = x0 - i1 + C.x;
 
+		detail::tvec4<T> x2 = x0 - i2 + C.y;
 
+		detail::tvec4<T> x3 = x0 - i3 + C.z;
 
+		detail::tvec4<T> x4 = x0 + C.w;
 
+		
+		// Permutations
 
+		i = mod(i, T(289)); 
+		T j0 = permute(permute(permute(permute(i.w) + i.z) + i.y) + i.x);
 
+		detail::tvec4<T> j1 = permute(permute(permute(permute(
 
+															  i.w + detail::tvec4<T>(i1.w, i2.w, i3.w, T(1)))
 
+													  + i.z + detail::tvec4<T>(i1.z, i2.z, i3.z, T(1)))
 
+											  + i.y + detail::tvec4<T>(i1.y, i2.y, i3.y, T(1)))
 
+									  + i.x + detail::tvec4<T>(i1.x, i2.x, i3.x, T(1)));
 
+		
+		// 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.
 
+		detail::tvec4<T> ip = detail::tvec4<T>(T(1) / T(294), T(1) / T(49), T(1) / T(7), T(0));
 
+		
+		detail::tvec4<T> p0 = grad4(j0,   ip);
 
+		detail::tvec4<T> p1 = grad4(j1.x, ip);
 
+		detail::tvec4<T> p2 = grad4(j1.y, ip);
 
+		detail::tvec4<T> p3 = grad4(j1.z, ip);
 
+		detail::tvec4<T> p4 = grad4(j1.w, ip);
 
+		
+		// Normalise gradients
 
+		detail::tvec4<T> norm = taylorInvSqrt(detail::tvec4<T>(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
 
+		detail::tvec3<T> m0 = max(T(0.6) - detail::tvec3<T>(dot(x0, x0), dot(x1, x1), dot(x2, x2)), T(0));
 
+		detail::tvec2<T> m1 = max(T(0.6) - detail::tvec2<T>(dot(x3, x3), dot(x4, x4)             ), T(0));
 
+		m0 = m0 * m0;
 
+		m1 = m1 * m1;
 
+		return T(49) * 
+		(dot(m0 * m0, detail::tvec3<T>(dot(p0, x0), dot(p1, x1), dot(p2, x2))) + 
+		 dot(m1 * m1, detail::tvec2<T>(dot(p3, x3), dot(p4, x4))));
 
+	}
 
+	
+	template <typename T>
 
+	GLM_FUNC_QUALIFIER glm::detail::tvec2<T> noise2(glm::detail::tvec2<T> const & x)
 
+	{
 
+		return glm::detail::tvec2<T>(
 
+			noise1(x + glm::detail::tvec2<T>(0.0)),
 
+			noise1(glm::detail::tvec2<T>(0.0) - x));
 
+	}
 
+	
+	template <typename T>
 
+	GLM_FUNC_QUALIFIER glm::detail::tvec2<T> noise2(glm::detail::tvec3<T> const & x)
 
+	{
 
+		return glm::detail::tvec2<T>(
 
+			noise1(x + glm::detail::tvec3<T>(0.0)),
 
+			noise1(glm::detail::tvec3<T>(0.0) - x));
 
+	}
 
+	
+	template <typename T>
 
+	GLM_FUNC_QUALIFIER glm::detail::tvec2<T> noise2(glm::detail::tvec4<T> const & x)
 
+	{
 
+		return glm::detail::tvec2<T>(
 
+			noise1(x + glm::detail::tvec4<T>(0.0)),
 
+			noise1(glm::detail::tvec4<T>(0.0) - x));
 
+	}
 
+	
+	template <typename T>
 
+	GLM_FUNC_QUALIFIER glm::detail::tvec3<T> noise3(glm::detail::tvec2<T> const & x)
 
+	{
 
+		return glm::detail::tvec3<T>(
 
+			noise1(x - glm::detail::tvec2<T>(1.0)),
 
+			noise1(x + glm::detail::tvec2<T>(0.0)),
 
+			noise1(x + glm::detail::tvec2<T>(1.0)));
 
+	}
 
+	
+	template <typename T>
 
+	GLM_FUNC_QUALIFIER glm::detail::tvec3<T> noise3(glm::detail::tvec3<T> const & x)
 
+	{
 
+		return glm::detail::tvec3<T>(
 
+			noise1(x - glm::detail::tvec3<T>(1.0)),
 
+			noise1(x + glm::detail::tvec3<T>(0.0)),
 
+			noise1(x + glm::detail::tvec3<T>(1.0)));
 
+	}
 
+	
+	template <typename T>
 
+	GLM_FUNC_QUALIFIER glm::detail::tvec3<T> noise3(glm::detail::tvec4<T> const & x)
 
+	{
 
+		return glm::detail::tvec3<T>(
 
+			noise1(x - glm::detail::tvec4<T>(1.0)),
 
+			noise1(x + glm::detail::tvec4<T>(0.0)),
 
+			noise1(x + glm::detail::tvec4<T>(1.0)));
 
+	}
 
+	
+	template <typename T>
 
+	GLM_FUNC_QUALIFIER glm::detail::tvec4<T> noise4(glm::detail::tvec2<T> const & x)
 
+	{
 
+		return glm::detail::tvec4<T>(
 
+			noise1(x - glm::detail::tvec2<T>(1.0)),
 
+			noise1(x + glm::detail::tvec2<T>(0.0)),
 
+			noise1(x + glm::detail::tvec2<T>(1.0)),
 
+			noise1(x + glm::detail::tvec2<T>(2.0)));
 
+	}
 
+
 
+	
+	template <typename T>
 
+	GLM_FUNC_QUALIFIER glm::detail::tvec4<T> noise4(glm::detail::tvec3<T> const & x)
 
+	{
 
+		return glm::detail::tvec4<T>(
 
+			noise1(x - glm::detail::tvec3<T>(1.0)),
 
+			noise1(x + glm::detail::tvec3<T>(0.0)),
 
+			noise1(x + glm::detail::tvec3<T>(1.0)),
 
+			noise1(x + glm::detail::tvec3<T>(2.0)));
 
+	}
 
+	
+	template <typename T>
 
+	GLM_FUNC_QUALIFIER glm::detail::tvec4<T> noise4(glm::detail::tvec4<T> const & x)
 
+	{
 
+		return glm::detail::tvec4<T>(
 
+			noise1(x - glm::detail::tvec4<T>(1.0)),
 
+			noise1(x + glm::detail::tvec4<T>(0.0)),
 
+			noise1(x + glm::detail::tvec4<T>(1.0)),
 
+			noise1(x + glm::detail::tvec4<T>(2.0)));
 
+	}
 
+	
 }//namespace glm
 
 }//namespace glm

+ 1 - 1
glm/core/func_packing.inl
View File 

@@ -144,7 +144,7 @@ GLM_FUNC_QUALIFIER detail::tvec2<uint> unpackDouble2x32(double const & v)
 
 	return *(detail::tvec2<uint>*)&v;
 
 	return *(detail::tvec2<uint>*)&v;
 
 }
 
 }
 
 
 
-GLM_FUNC_QUALIFIER uint packHalf2x16(vec2 const & v)
 
+GLM_FUNC_QUALIFIER uint packHalf2x16(detail::tvec2<float> const & v)
 
 {
 
 {
 
 	detail::tvec2<detail::hdata> Pack(detail::toFloat16(v.x), detail::toFloat16(v.y));
 
 	detail::tvec2<detail::hdata> Pack(detail::toFloat16(v.x), detail::toFloat16(v.y));
 
 	return *(uint*)&Pack;
 
 	return *(uint*)&Pack;

+ 17 - 10
glm/core/intrinsic_common.inl
View File 

@@ -29,6 +29,9 @@
 
 namespace glm{
 
 namespace glm{
 
 namespace detail{
 
 namespace detail{
 
 
 
+#pragma warning(push)
 
+#pragma warning(disable : 4510 4512 4610)
 
+
 
 	union ieee754_QNAN
 
 	union ieee754_QNAN
 
 	{
 
 	{
 
 	   const float f;
 
 	   const float f;
 
@@ -40,6 +43,8 @@ namespace detail{
 
 	   ieee754_QNAN() : f(0.0)/*, mantissa(0x7FFFFF), exp(0xFF), sign(0x0)*/ {}
 
 	   ieee754_QNAN() : f(0.0)/*, mantissa(0x7FFFFF), exp(0xFF), sign(0x0)*/ {}
 
 	};
 
 	};
 
 
 
+#pragma warning(pop)
 
+
 
 	static const __m128 GLM_VAR_USED zero = _mm_setzero_ps();
 
 	static const __m128 GLM_VAR_USED zero = _mm_setzero_ps();
 
 	static const __m128 GLM_VAR_USED one = _mm_set_ps1(1.0f);
 
 	static const __m128 GLM_VAR_USED one = _mm_set_ps1(1.0f);
 
 	static const __m128 GLM_VAR_USED minus_one = _mm_set_ps1(-1.0f);
 
 	static const __m128 GLM_VAR_USED minus_one = _mm_set_ps1(-1.0f);
 
@@ -224,11 +229,13 @@ GLM_FUNC_QUALIFIER __m128 sse_mod_ps(__m128 x, __m128 y)
 
 }
 
 }
 
 
 
 /// TODO
 
 /// TODO
 
+/*
 
 GLM_FUNC_QUALIFIER __m128 sse_modf_ps(__m128 x, __m128i & i)
 
 GLM_FUNC_QUALIFIER __m128 sse_modf_ps(__m128 x, __m128i & i)
 
 {
 
 {
 
 	__m128 empty;
 
 	__m128 empty;
 
     return empty;
 
     return empty;
 
 }
 
 }
 
+*/
 
 
 
 //GLM_FUNC_QUALIFIER __m128 _mm_min_ps(__m128 x, __m128 y)
 
 //GLM_FUNC_QUALIFIER __m128 _mm_min_ps(__m128 x, __m128 y)
 
 
 
@@ -273,18 +280,18 @@ GLM_FUNC_QUALIFIER __m128 sse_ssp_ps(__m128 edge0, __m128 edge1, __m128 x)
 
 }
 
 }
 
 
 
 /// \todo
 
 /// \todo
 
-GLM_FUNC_QUALIFIER __m128 sse_nan_ps(__m128 x)
 
-{
 
-	__m128 empty;
 
-    return empty;
 
-}
 
+//GLM_FUNC_QUALIFIER __m128 sse_nan_ps(__m128 x)
 
+//{
 
+//	__m128 empty;
 
+//    return empty;
 
+//}
 
 
 
 /// \todo
 
 /// \todo
 
-GLM_FUNC_QUALIFIER __m128 sse_inf_ps(__m128 x)
 
-{
 
-	__m128 empty;
 
-    return empty;
 
-}
 
+//GLM_FUNC_QUALIFIER __m128 sse_inf_ps(__m128 x)
 
+//{
 
+//	__m128 empty;
 
+//    return empty;
 
+//}
 
 
 
 // SSE scalar reciprocal sqrt using rsqrt op, plus one Newton-Rhaphson iteration
 
 // SSE scalar reciprocal sqrt using rsqrt op, plus one Newton-Rhaphson iteration
 
 // By Elan Ruskin, http://assemblyrequired.crashworks.org/
 
 // By Elan Ruskin, http://assemblyrequired.crashworks.org/

+ 5 - 5
glm/core/type_half.inl
View File 

@@ -60,7 +60,7 @@ namespace detail
 
 				//
 
 				//
 
 
 
 				detail::uif result;
 
 				detail::uif result;
 
-				result.i = s << 31;
 
+				result.i = (unsigned int)(s << 31);
 
 				return result.f;
 
 				return result.f;
 
 			}
 
 			}
 
 			else
 
 			else
 
@@ -88,7 +88,7 @@ namespace detail
 
 				//
 
 				//
 
 
 
 				uif result;
 
 				uif result;
 
-				result.i = (s << 31) | 0x7f800000;
 
+				result.i = (unsigned int)((s << 31) | 0x7f800000);
 
 				return result.f;
 
 				return result.f;
 
 			}
 
 			}
 
 			else
 
 			else
 
@@ -98,7 +98,7 @@ namespace detail
 
 				//
 
 				//
 
 
 
 				uif result;
 
 				uif result;
 
-				result.i = (s << 31) | 0x7f800000 | (m << 13);
 
+				result.i = (unsigned int)((s << 31) | 0x7f800000 | (m << 13));
 
 				return result.f;
 
 				return result.f;
 
 			}
 
 			}
 
 		}
 
 		}
 
@@ -115,7 +115,7 @@ namespace detail
 
 		//
 
 		//
 
 
 
 		uif Result;
 
 		uif Result;
 
-		Result.i = (s << 31) | (e << 23) | m;
 
+		Result.i = (unsigned int)((s << 31) | (e << 23) | m);
 
 		return Result.f;
 
 		return Result.f;
 
 	}
 
 	}
 
 
 
@@ -123,7 +123,7 @@ namespace detail
 
 	{
 
 	{
 
 		uif Entry;
 
 		uif Entry;
 
 		Entry.f = f;
 
 		Entry.f = f;
 
-		int i = Entry.i;
 
+		int i = (int)Entry.i;
 
 
 
 		//
 
 		//
 
 		// Our floating point number, f, is represented by the bit
 
 		// Our floating point number, f, is represented by the bit

+ 4 - 2
glm/core/type_vec2.hpp
View File 

@@ -220,8 +220,10 @@ namespace detail
 
 		GLM_FUNC_DECL tref2<T> & operator= (tref2<T> const & r);
 
 		GLM_FUNC_DECL tref2<T> & operator= (tref2<T> const & r);
 
 		GLM_FUNC_DECL tref2<T> & operator= (tvec2<T> const & v);
 
 		GLM_FUNC_DECL tref2<T> & operator= (tvec2<T> const & v);
 
 
 
-		T& x;
 
-		T& y;
 
+		GLM_FUNC_DECL tvec2<T> operator() ();
 
+
 
+		T & x;
 
+		T & y;
 
 	};
 
 	};
 
 
 
 	GLM_DETAIL_IS_VECTOR(tvec2);
 
 	GLM_DETAIL_IS_VECTOR(tvec2);

+ 6 - 0
glm/core/type_vec2.inl
View File 

@@ -1025,5 +1025,11 @@ namespace detail
 
 		return *this;
 
 		return *this;
 
 	}
 
 	}
 
 
 
+	template <typename T> 
+	GLM_FUNC_QUALIFIER tvec2<T> tref2<T>::operator() ()
 
+	{
 
+		return tvec2<T>(this->x, this->y);
 
+	}
 
+
 
 }//namespace detail
 
 }//namespace detail
 
 }//namespace glm
 
 }//namespace glm

+ 32 - 11
glm/core/type_vec3.hpp
View File 

@@ -111,17 +111,6 @@ namespace detail
 
 			value_type const & s2, 
 			value_type const & s2, 
 			value_type const & s3);
 
 			value_type const & s3);
 
 
 
-		//////////////////////////////////////
 
-		// Swizzle constructors
 
-
 
-		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
 
 		// Convertion scalar constructors
 
 
 
@@ -152,6 +141,35 @@ namespace detail
 
 		template <typename U> 
 		template <typename U> 
 		GLM_FUNC_DECL explicit tvec3(tvec4<U> const & v);
 
 		GLM_FUNC_DECL explicit tvec3(tvec4<U> const & v);
 
 
 
+		//////////////////////////////////////
 
+		// Swizzle constructors
 
+
 
+		GLM_FUNC_DECL tvec3(tref3<T> const & r);
 
+
 
+		template <typename A, typename B> 
+		GLM_FUNC_DECL explicit tvec3(tref2<A> const & v, B const & s);
 
+
 
+		template <typename A, typename B> 
+		GLM_FUNC_DECL explicit tvec3(A const & s, tref2<B> const & v);
 
+
 
+        template <int E0, int E1, int E2>
 
+        GLM_FUNC_DECL tvec3(glm::detail::swizzle<3, T, tvec3<T>, E0, E1, E2, -1> const & that)
 
+        {
 
+            *this = that();
 
+        }
 
+
 
+        template <int E0, int E1>
 
+        GLM_FUNC_DECL tvec3(glm::detail::swizzle<2, T, tvec2<T>, E0, E1, -1, -2> const & v, T const & s)
 
+        {
 
+            *this = tvec3<T>(v(), s);
 
+        }
 
+
 
+        template <int E0, int E1>
 
+        GLM_FUNC_DECL tvec3(T const & s, glm::detail::swizzle<2, T, tvec2<T>, E0, E1, -1, -2> const & v)
 
+        {
 
+            *this = tvec3<T>(s, v());
 
+        }
 
+
 
 		//////////////////////////////////////
 
 		//////////////////////////////////////
 
 		// Unary arithmetic operators
 
 		// Unary arithmetic operators
 
 
 
@@ -213,6 +231,7 @@ namespace detail
 
 		GLM_FUNC_DECL tvec2<T> swizzle(comp X, comp Y) const;
 
 		GLM_FUNC_DECL tvec2<T> swizzle(comp X, comp Y) const;
 
 		GLM_FUNC_DECL tvec3<T> swizzle(comp X, comp Y, comp Z) const;
 
 		GLM_FUNC_DECL tvec3<T> swizzle(comp X, comp Y, comp Z) const;
 
 		GLM_FUNC_DECL tvec4<T> swizzle(comp X, comp Y, comp Z, comp W) const;
 
 		GLM_FUNC_DECL tvec4<T> swizzle(comp X, comp Y, comp Z, comp W) const;
 
+		GLM_FUNC_DECL tref2<T> swizzle(comp X, comp Y);
 
 		GLM_FUNC_DECL tref3<T> swizzle(comp X, comp Y, comp Z);
 
 		GLM_FUNC_DECL tref3<T> swizzle(comp X, comp Y, comp Z);
 
 	};
 
 	};
 
 
 
@@ -226,6 +245,8 @@ namespace detail
 
 		GLM_FUNC_DECL tref3<T> & operator= (tref3<T> const & r);
 
 		GLM_FUNC_DECL tref3<T> & operator= (tref3<T> const & r);
 
 		GLM_FUNC_DECL tref3<T> & operator= (tvec3<T> const & v);
 
 		GLM_FUNC_DECL tref3<T> & operator= (tvec3<T> const & v);
 
 
 
+		GLM_FUNC_DECL tvec3<T> operator() ();
 
+
 
 		T & x;
 
 		T & x;
 
 		T & y;
 
 		T & y;
 
 		T & z;
 
 		T & z;

+ 42 - 0
glm/core/type_vec3.inl
View File 

@@ -131,6 +131,30 @@ namespace detail
 
 		z(r.z)
 
 		z(r.z)
 
 	{}
 
 	{}
 
 
 
+	template <typename T>
 
+	template <typename A, typename B> 
+	GLM_FUNC_QUALIFIER tvec3<T>::tvec3
 
+	(
 
+		tref2<A> const & v, 
+		B const & s
 
+	) : 
+		x(value_type(v.x)),
 
+		y(value_type(v.y)),
 
+		z(value_type(s))
 
+	{}
 
+
 
+	template <typename T>
 
+	template <typename A, typename B> 
+	GLM_FUNC_QUALIFIER tvec3<T>::tvec3
 
+	(
 
+		A const & s, 
+		tref2<B> const & v
 
+	) :
 
+		x(value_type(s)),
 
+		y(value_type(v.x)),
 
+		z(value_type(v.y))
 
+	{}
 
+
 
 	//////////////////////////////////////
 
 	//////////////////////////////////////
 
 	// Convertion scalar constructors
 
 	// Convertion scalar constructors
 
 		
 		
@@ -594,6 +618,18 @@ namespace detail
 
 			(*this)[w]);
 
 			(*this)[w]);
 
 	}
 
 	}
 
 
 
+	template <typename T>
 
+	GLM_FUNC_QUALIFIER tref2<T> tvec3<T>::swizzle
 
+	(
 
+		comp x, 
+		comp y
 
+	)
 
+	{
 
+		return tref2<T>(
 
+			(*this)[x],
 
+			(*this)[y]);
 
+	}
 
+
 
 	template <typename T>
 
 	template <typename T>
 
 	GLM_FUNC_QUALIFIER tref3<T> tvec3<T>::swizzle
 
 	GLM_FUNC_QUALIFIER tref3<T> tvec3<T>::swizzle
 
 	(
 
 	(
 
@@ -1112,5 +1148,11 @@ namespace detail
 
 		return *this;
 
 		return *this;
 
 	}
 
 	}
 
 
 
+	template <typename T> 
+	GLM_FUNC_QUALIFIER tvec3<T> tref3<T>::operator() ()
 
+	{
 
+		return tvec3<T>(this->x, this->y, this->z);
 
+	}
 
+
 
 }//namespace detail
 
 }//namespace detail
 
 }//namespace glm
 
 }//namespace glm

+ 76 - 11
glm/core/type_vec4.hpp
View File 

@@ -113,17 +113,6 @@ namespace detail
 
 			value_type const & s2, 
 			value_type const & s2, 
 			value_type const & s3);
 
 			value_type const & s3);
 
 
 
-		//////////////////////////////////////
 
-		// Swizzle constructors
 
-
 
-		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
 
 		// Convertion scalar constructors
 
 
 
@@ -164,6 +153,78 @@ namespace detail
 
 		template <typename U> 
 		template <typename U> 
 		GLM_FUNC_DECL explicit tvec4(tvec4<U> const & v);
 
 		GLM_FUNC_DECL explicit tvec4(tvec4<U> const & v);
 
 
 
+        template <int E0, int E1, int E2, int E3>
 
+        GLM_FUNC_DECL tvec4(glm::detail::swizzle<4, T, tvec4<T>, E0, E1, E2, E3> const & that)
 
+        {
 
+            *this = that();
 
+        }
 
+
 
+        template <int E0, int E1, int F0, int F1>
 
+        GLM_FUNC_DECL tvec4(glm::detail::swizzle<2, T, tvec2<T>, E0, E1, -1, -2> const & v, glm::detail::swizzle<2, T, tvec2<T>, F0, F1, -1, -2> const & u)
 
+        {
 
+            *this = tvec4<T>(v(), u());
 
+        }
 
+
 
+        template <int E0, int E1>
 
+        GLM_FUNC_DECL tvec4(T const & x, T const & y, glm::detail::swizzle<2, T, tvec2<T>, E0, E1, -1, -2> const & v)
 
+        {
 
+            *this = tvec4<T>(x, y, v());
 
+        }
 
+
 
+        template <int E0, int E1>
 
+        GLM_FUNC_DECL tvec4(T const & x, glm::detail::swizzle<2, T, tvec2<T>, E0, E1, -1, -2> const & v, T const & w)
 
+        {
 
+            *this = tvec4<T>(x, v(), w);
 
+        }
 
+
 
+        template <int E0, int E1>
 
+        GLM_FUNC_DECL tvec4(glm::detail::swizzle<2, T, tvec2<T>, E0, E1, -1, -2> const & v, T const & z, T const & w)
 
+        {
 
+            *this = tvec4<T>(v(), z, w);
 
+        }
 
+
 
+        template <int E0, int E1, int E2>
 
+        GLM_FUNC_DECL tvec4(glm::detail::swizzle<3, T, tvec3<T>, E0, E1, E2, -1> const & v, T const & w)
 
+        {
 
+            *this = tvec4<T>(v(), w);
 
+        }
 
+
 
+        template <int E0, int E1, int E2>
 
+        GLM_FUNC_DECL tvec4(T const & x, glm::detail::swizzle<3, T, tvec3<T>, E0, E1, E2, -1> const & v)
 
+        {
 
+            *this = tvec4<T>(x, v());
 
+        }
 
+
 
+		//////////////////////////////////////
 
+		// Swizzle constructors
 
+
 
+		GLM_FUNC_DECL tvec4(tref4<T> const & r);
 
+
 
+		//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
 
+		template <typename A, typename B, typename C> 
+		GLM_FUNC_DECL explicit tvec4(tref2<A> const & v, B const & s1, C const & s2);
 
+		//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
 
+		template <typename A, typename B, typename C> 
+		GLM_FUNC_DECL explicit tvec4(A const & s1, tref2<B> const & v, C const & s2);
 
+		//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
 
+		template <typename A, typename B, typename C> 
+		GLM_FUNC_DECL explicit tvec4(A const & s1, B const & s2, tref2<C> const & v);
 
+		//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
 
+		template <typename A, typename B> 
+		GLM_FUNC_DECL explicit tvec4(tref3<A> const & v, B const & s);
 
+		//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
 
+		template <typename A, typename B> 
+		GLM_FUNC_DECL explicit tvec4(A const & s, tref3<B> const & v);
 
+		//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
 
+		template <typename A, typename B> 
+		GLM_FUNC_DECL explicit tvec4(tref2<A> const & v1, tref2<B> const & v2);
 
+		//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
 
+		template <typename A, typename B> 
+		GLM_FUNC_DECL explicit tvec4(tvec2<A> const & v1, tref2<B> const & v2);
 
+		//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
 
+		template <typename A, typename B> 
+		GLM_FUNC_DECL explicit tvec4(tref2<A> const & v1, tvec2<B> const & v2);
 
+
 
 		//////////////////////////////////////
 
 		//////////////////////////////////////
 
 		// Unary arithmetic operators
 
 		// Unary arithmetic operators
 
 
 
@@ -225,6 +286,8 @@ namespace detail
 
 		GLM_FUNC_DECL tvec2<T> swizzle(comp X, comp Y) const;
 
 		GLM_FUNC_DECL tvec2<T> swizzle(comp X, comp Y) const;
 
 		GLM_FUNC_DECL tvec3<T> swizzle(comp X, comp Y, comp Z) const;
 
 		GLM_FUNC_DECL tvec3<T> swizzle(comp X, comp Y, comp Z) const;
 
 		GLM_FUNC_DECL tvec4<T> swizzle(comp X, comp Y, comp Z, comp W) const;
 
 		GLM_FUNC_DECL tvec4<T> swizzle(comp X, comp Y, comp Z, comp W) const;
 
+		GLM_FUNC_DECL tref2<T> swizzle(comp X, comp Y);
 
+		GLM_FUNC_DECL tref3<T> swizzle(comp X, comp Y, comp Z);
 
 		GLM_FUNC_DECL tref4<T> swizzle(comp X, comp Y, comp Z, comp W);
 
 		GLM_FUNC_DECL tref4<T> swizzle(comp X, comp Y, comp Z, comp W);
 
 	};
 
 	};
 
 
 
@@ -238,6 +301,8 @@ namespace detail
 
 		GLM_FUNC_DECL tref4<T> & operator= (tref4<T> const & r);
 
 		GLM_FUNC_DECL tref4<T> & operator= (tref4<T> const & r);
 
 		GLM_FUNC_DECL tref4<T> & operator= (tvec4<T> const & v);
 
 		GLM_FUNC_DECL tref4<T> & operator= (tvec4<T> const & v);
 
 
 
+		GLM_FUNC_DECL tvec4<T> operator() ();
 
+
 
 		T & x;
 
 		T & x;
 
 		T & y;
 
 		T & y;
 
 		T & z;
 
 		T & z;

+ 139 - 0
glm/core/type_vec4.inl
View File 

@@ -137,6 +137,113 @@ namespace detail
 
 		w(r.w)
 
 		w(r.w)
 
 	{}
 
 	{}
 
 
 
+	template <typename T>
 
+	template <typename A, typename B, typename C> 
+	GLM_FUNC_QUALIFIER tvec4<T>::tvec4
 
+	(
 
+		tref2<A> const & v, 
+		B const & s1, 
+		C const & s2
 
+	) :
 
+		x(value_type(v.x)),
 
+		y(value_type(v.y)),
 
+		z(value_type(s1)),
 
+		w(value_type(s2))
 
+	{}
 
+
 
+	template <typename T>
 
+	template <typename A, typename B, typename C> 
+	GLM_FUNC_QUALIFIER tvec4<T>::tvec4
 
+	(
 
+		A const & s1, 
+		tref2<B> const & v, 
+		C const & s2
 
+	) :
 
+		x(value_type(s1)),
 
+		y(value_type(v.x)),
 
+		z(value_type(v.y)),
 
+		w(value_type(s2))
 
+	{}
 
+
 
+	template <typename T>
 
+	template <typename A, typename B, typename C> 
+	GLM_FUNC_QUALIFIER tvec4<T>::tvec4
 
+	(
 
+		A const & s1, 
+		B const & s2, 
+		tref2<C> const & v
 
+	) :
 
+		x(value_type(s1)),
 
+		y(value_type(s2)),
 
+		z(value_type(v.x)),
 
+		w(value_type(v.y))
 
+	{}
 
+
 
+	template <typename T>
 
+	template <typename A, typename B> 
+	GLM_FUNC_QUALIFIER tvec4<T>::tvec4
 
+	(
 
+		tref3<A> const & v, 
+		B const & s
 
+	) :
 
+		x(value_type(v.x)),
 
+		y(value_type(v.y)),
 
+		z(value_type(v.z)),
 
+		w(value_type(s))
 
+	{}
 
+
 
+	template <typename T>
 
+	template <typename A, typename B> 
+	GLM_FUNC_QUALIFIER tvec4<T>::tvec4
 
+	(
 
+		A const & s, 
+		tref3<B> const & v
 
+	) :
 
+		x(value_type(s)),
 
+		y(value_type(v.x)),
 
+		z(value_type(v.y)),
 
+		w(value_type(v.z))
 
+	{}
 
+
 
+	template <typename T>
 
+	template <typename A, typename B> 
+	GLM_FUNC_QUALIFIER tvec4<T>::tvec4
 
+	(
 
+		tref2<A> const & v1, 
+		tref2<B> const & v2
 
+	) :
 
+		x(value_type(v1.x)),
 
+		y(value_type(v1.y)),
 
+		z(value_type(v2.x)),
 
+		w(value_type(v2.y))
 
+	{}
 
+
 
+	template <typename T>
 
+	template <typename A, typename B> 
+	GLM_FUNC_QUALIFIER tvec4<T>::tvec4
 
+	(
 
+		tvec2<A> const & v1, 
+		tref2<B> const & v2
 
+	) :
 
+		x(value_type(v1.x)),
 
+		y(value_type(v1.y)),
 
+		z(value_type(v2.x)),
 
+		w(value_type(v2.y))
 
+	{}
 
+
 
+	template <typename T>
 
+	template <typename A, typename B> 
+	GLM_FUNC_QUALIFIER tvec4<T>::tvec4
 
+	(
 
+		tref2<A> const & v1, 
+		tvec2<B> const & v2
 
+	) :
 
+		x(value_type(v1.x)),
 
+		y(value_type(v1.y)),
 
+		z(value_type(v2.x)),
 
+		w(value_type(v2.y))
 
+	{}
 
+
 
 	//////////////////////////////////////
 
 	//////////////////////////////////////
 
 	// Convertion scalar constructors
 
 	// Convertion scalar constructors
 
 		
 		
@@ -651,6 +758,32 @@ namespace detail
 
 			(*this)[w]);
 
 			(*this)[w]);
 
 	}
 
 	}
 
 
 
+	template <typename T>
 
+	GLM_FUNC_QUALIFIER tref2<T> tvec4<T>::swizzle
 
+	(
 
+		comp x, 
+		comp y
 
+	)
 
+	{
 
+		return tref2<T>(
 
+			(*this)[x],
 
+			(*this)[y]);
 
+	}
 
+
 
+	template <typename T>
 
+	GLM_FUNC_QUALIFIER tref3<T> tvec4<T>::swizzle
 
+	(
 
+		comp x, 
+		comp y, 
+		comp z
 
+	)
 
+	{
 
+		return tref3<T>(
 
+			(*this)[x],
 
+			(*this)[y],
 
+			(*this)[z]);
 
+	}
 
+
 
 	template <typename T>
 
 	template <typename T>
 
 	GLM_FUNC_QUALIFIER tref4<T> tvec4<T>::swizzle
 
 	GLM_FUNC_QUALIFIER tref4<T> tvec4<T>::swizzle
 
 	(
 
 	(
 
@@ -1241,5 +1374,11 @@ namespace detail
 
 		return *this;
 
 		return *this;
 
 	}
 
 	}
 
 
 
+	template <typename T> 
+	GLM_FUNC_QUALIFIER tvec4<T> tref4<T>::operator() ()
 
+	{
 
+		return tvec4<T>(this->x, this->y, this->z, this->w);
 
+	}
 
+
 
 }//namespace detail
 
 }//namespace detail
 
 }//namespace glm
 
 }//namespace glm

+ 0 - 1
glm/ext.hpp
View File 

@@ -124,7 +124,6 @@
 
 #include "./gtx/transform.hpp"
 
 #include "./gtx/transform.hpp"
 
 #include "./gtx/transform2.hpp"
 
 #include "./gtx/transform2.hpp"
 
 #include "./gtx/ulp.hpp"
 
 #include "./gtx/ulp.hpp"
 
-#include "./gtx/unsigned_int.hpp"
 
 #include "./gtx/vec1.hpp"
 
 #include "./gtx/vec1.hpp"
 
 #include "./gtx/vector_access.hpp"
 
 #include "./gtx/vector_access.hpp"
 
 #include "./gtx/vector_angle.hpp"
 
 #include "./gtx/vector_angle.hpp"

+ 1 - 0
glm/glm.hpp
View File 

@@ -84,6 +84,7 @@
 
 #include <climits>
 
 #include <climits>
 
 #include <cfloat>
 
 #include <cfloat>
 
 #include <limits>
 
 #include <limits>
 
+#include <type_traits>
 
 #include "core/setup.hpp"
 
 #include "core/setup.hpp"
 
 
 
 #if(defined(GLM_MESSAGES) && !defined(GLM_MESSAGE_CORE_INCLUDED_DISPLAYED))
 
 #if(defined(GLM_MESSAGES) && !defined(GLM_MESSAGE_CORE_INCLUDED_DISPLAYED))

+ 81 - 0
glm/gtc/noise.hpp
View File 

@@ -0,0 +1,81 @@
 
+///////////////////////////////////////////////////////////////////////////////////
 
+/// OpenGL Mathematics (glm.g-truc.net)
 
+///
 
+/// Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
 
+/// Permission is hereby granted, free of charge, to any person obtaining a copy
 
+/// of this software and associated documentation files (the "Software"), to deal
 
+/// in the Software without restriction, including without limitation the rights
 
+/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 
+/// copies of the Software, and to permit persons to whom the Software is
 
+/// furnished to do so, subject to the following conditions:
 
+/// 
+/// The above copyright notice and this permission notice shall be included in
 
+/// all copies or substantial portions of the Software.
 
+/// 
+/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 
+/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 
+/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 
+/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 
+/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 
+/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 
+/// THE SOFTWARE.
 
+///
 
+/// @ref gtc_noise
 
+/// @file glm/gtc/noise.hpp
 
+/// @date 2011-04-21 / 2011-09-27
 
+/// @author Christophe Riccio
 
+///
 
+/// @see core (dependence)
 
+///
 
+/// @defgroup gtx_noise GLM_GTX_noise: Procedural noise functions
 
+/// @ingroup gtx
 
+/// 
+/// Defines 2D, 3D and 4D procedural noise functions 
+/// Based on the work of Stefan Gustavson and Ashima Arts on "webgl-noise": 
+/// https://github.com/ashima/webgl-noise 
+/// Following Stefan Gustavson's paper "Simplex noise demystified": 
+/// http://www.itn.liu.se/~stegu/simplexnoise/simplexnoise.pdf
 
+/// Defines the half-precision floating-point type, along with various typedefs for vectors and matrices.
 
+/// <glm/gtx/noise.hpp> need to be included to use these functionalities.
 
+///////////////////////////////////////////////////////////////////////////////////
 
+
 
+#ifndef GLM_GTC_noise
 
+#define GLM_GTC_noise GLM_VERSION
 
+
 
+// Dependency:
 
+#include "../glm.hpp"
 
+
 
+#if(defined(GLM_MESSAGES) && !defined(glm_ext))
 
+#	pragma message("GLM: GLM_GTC_noise extension included")
 
+#endif
 
+
 
+namespace glm
 
+{
 
+	/// @addtogroup gtx_noise
 
+	/// @{
 
+
 
+	/// Classic perlin noise.
 
+	/// From GLM_GTC_noise extension.
 
+	template <typename T, template<typename> class vecType> 
+    T perlin(
 
+		vecType<T> const & p);
 
+		
+	/// Periodic perlin noise.
 
+	/// From GLM_GTC_noise extension.
 
+	template <typename T, template<typename> class vecType> 
+    T perlin(
 
+		vecType<T> const & p, 
+		vecType<T> const & rep);
 
+
 
+	/// Simplex noise.
 
+	/// From GLM_GTC_noise extension.
 
+	template <typename T, template<typename> class vecType> 
+    T simplex(
 
+		vecType<T> const & p);
 
+
 
+	/// @}
 
+}//namespace glm
 
+
 
+#include "noise.inl"
 
+
 
+#endif//GLM_GTC_noise

+ 852 - 0
glm/gtc/noise.inl
View File 

@@ -0,0 +1,852 @@
 
+///////////////////////////////////////////////////////////////////////////////////////////////////
 
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
 
+///////////////////////////////////////////////////////////////////////////////////////////////////
 
+// Based on the work of Stefan Gustavson and Ashima Arts on "webgl-noise": 
+// https://github.com/ashima/webgl-noise 
+// Following Stefan Gustavson's paper "Simplex noise demystified": 
+// http://www.itn.liu.se/~stegu/simplexnoise/simplexnoise.pdf
 
+///////////////////////////////////////////////////////////////////////////////////////////////////
 
+// Created : 2011-04-21
 
+// Updated : 2011-09-27
 
+// Licence : This source is under MIT License
 
+// File    : glm/gtc/noise.inl
 
+///////////////////////////////////////////////////////////////////////////////////////////////////
 
+// Dependency:
 
+// - GLM core
 
+///////////////////////////////////////////////////////////////////////////////////////////////////
 
+
 
+namespace glm{
 
+
 
+template <typename T>
 
+GLM_FUNC_QUALIFIER T mod289(T const & x)
 
+{
 
+	return x - floor(x * T(1.0 / 289.0)) * T(289.0);
 
+}
 
+
 
+template <typename T>
 
+GLM_FUNC_QUALIFIER T permute(T const & x)
 
+{
 
+	return mod289(((x * T(34)) + T(1)) * x);
 
+}
 
+
 
+template <typename T, template<typename> class vecType>
 
+GLM_FUNC_QUALIFIER vecType<T> permute(vecType<T> const & x)
 
+{
 
+	return mod289(((x * T(34)) + T(1)) * x);
 
+}
 
+  
+template <typename T>
 
+GLM_FUNC_QUALIFIER T taylorInvSqrt(T const & r)
 
+{
 
+	return T(1.79284291400159) - T(0.85373472095314) * r;
 
+}
 
+
 
+template <typename T, template<typename> class vecType>
 
+GLM_FUNC_QUALIFIER vecType<T> taylorInvSqrt(vecType<T> const & r)
 
+{
 
+	return T(1.79284291400159) - T(0.85373472095314) * r;
 
+}
 
+
 
+template <typename T, template <typename> class vecType> 
+GLM_FUNC_QUALIFIER vecType<T> fade(vecType<T> const & t) 
+{
 
+	return t * t * t * (t * (t * T(6) - T(15)) + T(10));
 
+}
 
+
 
+template <typename T>
 
+GLM_FUNC_QUALIFIER detail::tvec4<T> grad4(T const & j, detail::tvec4<T> const & ip)
 
+{
 
+	detail::tvec3<T> pXYZ = floor(fract(detail::tvec3<T>(j) * detail::tvec3<T>(ip)) * T(7)) * ip[2] - T(1);
 
+	T pW = T(1.5) - dot(abs(pXYZ), detail::tvec3<T>(1));
 
+	detail::tvec4<T> s = detail::tvec4<T>(lessThan(detail::tvec4<T>(pXYZ, pW), detail::tvec4<T>(0.0)));
 
+	pXYZ = pXYZ + (detail::tvec3<T>(s) * T(2) - T(1)) * s.w; 
+	return detail::tvec4<T>(pXYZ, pW);
 
+}
 
+
 
+// Classic Perlin noise
 
+template <typename T>
 
+GLM_FUNC_QUALIFIER T perlin(detail::tvec2<T> const & P)
 
+{
 
+	detail::tvec4<T> Pi = glm::floor(detail::tvec4<T>(P.x, P.y, P.x, P.y)) + detail::tvec4<T>(0.0, 0.0, 1.0, 1.0);
 
+	detail::tvec4<T> Pf = glm::fract(detail::tvec4<T>(P.x, P.y, P.x, P.y)) - detail::tvec4<T>(0.0, 0.0, 1.0, 1.0);
 
+	Pi = mod(Pi, T(289)); // To avoid truncation effects in permutation
 
+	detail::tvec4<T> ix(Pi.x, Pi.z, Pi.x, Pi.z);
 
+	detail::tvec4<T> iy(Pi.y, Pi.y, Pi.w, Pi.w);
 
+	detail::tvec4<T> fx(Pf.x, Pf.z, Pf.x, Pf.z);
 
+	detail::tvec4<T> fy(Pf.y, Pf.y, Pf.w, Pf.w);
 
+
 
+	detail::tvec4<T> i = glm::permute(glm::permute(ix) + iy);
 
+
 
+	detail::tvec4<T> gx = T(2) * glm::fract(i / T(41)) - T(1);
 
+	detail::tvec4<T> gy = glm::abs(gx) - T(0.5);
 
+	detail::tvec4<T> tx = glm::floor(gx + T(0.5));
 
+	gx = gx - tx;
 
+
 
+	detail::tvec2<T> g00(gx.x, gy.x);
 
+	detail::tvec2<T> g10(gx.y, gy.y);
 
+	detail::tvec2<T> g01(gx.z, gy.z);
 
+	detail::tvec2<T> g11(gx.w, gy.w);
 
+
 
+	detail::tvec4<T> norm = taylorInvSqrt(detail::tvec4<T>(dot(g00, g00), dot(g01, g01), dot(g10, g10), dot(g11, g11)));
 
+	g00 *= norm.x;  
+	g01 *= norm.y;  
+	g10 *= norm.z;  
+	g11 *= norm.w;  
+
 
+	T n00 = dot(g00, detail::tvec2<T>(fx.x, fy.x));
 
+	T n10 = dot(g10, detail::tvec2<T>(fx.y, fy.y));
 
+	T n01 = dot(g01, detail::tvec2<T>(fx.z, fy.z));
 
+	T n11 = dot(g11, detail::tvec2<T>(fx.w, fy.w));
 
+
 
+	detail::tvec2<T> fade_xy = fade(detail::tvec2<T>(Pf.x, Pf.y));
 
+	detail::tvec2<T> n_x = mix(detail::tvec2<T>(n00, n01), detail::tvec2<T>(n10, n11), fade_xy.x);
 
+	T n_xy = mix(n_x.x, n_x.y, fade_xy.y);
 
+	return T(2.3) * n_xy;
 
+}
 
+
 
+// Classic Perlin noise
 
+template <typename T>
 
+GLM_FUNC_QUALIFIER T perlin(detail::tvec3<T> const & P)
 
+{
 
+	detail::tvec3<T> Pi0 = floor(P); // Integer part for indexing
 
+	detail::tvec3<T> Pi1 = Pi0 + T(1); // Integer part + 1
 
+	Pi0 = mod289(Pi0);
 
+	Pi1 = mod289(Pi1);
 
+	detail::tvec3<T> Pf0 = fract(P); // Fractional part for interpolation
 
+	detail::tvec3<T> Pf1 = Pf0 - T(1); // Fractional part - 1.0
 
+	detail::tvec4<T> ix(Pi0.x, Pi1.x, Pi0.x, Pi1.x);
 
+	detail::tvec4<T> iy = detail::tvec4<T>(detail::tvec2<T>(Pi0.y), detail::tvec2<T>(Pi1.y));
 
+	detail::tvec4<T> iz0(Pi0.z);
 
+	detail::tvec4<T> iz1(Pi1.z);
 
+
 
+	detail::tvec4<T> ixy = permute(permute(ix) + iy);
 
+	detail::tvec4<T> ixy0 = permute(ixy + iz0);
 
+	detail::tvec4<T> ixy1 = permute(ixy + iz1);
 
+
 
+	detail::tvec4<T> gx0 = ixy0 * T(1.0 / 7.0);
 
+	detail::tvec4<T> gy0 = fract(floor(gx0) * T(1.0 / 7.0)) - T(0.5);
 
+	gx0 = fract(gx0);
 
+	detail::tvec4<T> gz0 = detail::tvec4<T>(0.5) - abs(gx0) - abs(gy0);
 
+	detail::tvec4<T> sz0 = step(gz0, detail::tvec4<T>(0.0));
 
+	gx0 -= sz0 * (step(T(0), gx0) - T(0.5));
 
+	gy0 -= sz0 * (step(T(0), gy0) - T(0.5));
 
+
 
+	detail::tvec4<T> gx1 = ixy1 * T(1.0 / 7.0);
 
+	detail::tvec4<T> gy1 = fract(floor(gx1) * T(1.0 / 7.0)) - T(0.5);
 
+	gx1 = fract(gx1);
 
+	detail::tvec4<T> gz1 = detail::tvec4<T>(0.5) - abs(gx1) - abs(gy1);
 
+	detail::tvec4<T> sz1 = step(gz1, detail::tvec4<T>(0.0));
 
+	gx1 -= sz1 * (step(T(0), gx1) - T(0.5));
 
+	gy1 -= sz1 * (step(T(0), gy1) - T(0.5));
 
+
 
+	detail::tvec3<T> g000(gx0.x, gy0.x, gz0.x);
 
+	detail::tvec3<T> g100(gx0.y, gy0.y, gz0.y);
 
+	detail::tvec3<T> g010(gx0.z, gy0.z, gz0.z);
 
+	detail::tvec3<T> g110(gx0.w, gy0.w, gz0.w);
 
+	detail::tvec3<T> g001(gx1.x, gy1.x, gz1.x);
 
+	detail::tvec3<T> g101(gx1.y, gy1.y, gz1.y);
 
+	detail::tvec3<T> g011(gx1.z, gy1.z, gz1.z);
 
+	detail::tvec3<T> g111(gx1.w, gy1.w, gz1.w);
 
+
 
+	detail::tvec4<T> norm0 = taylorInvSqrt(detail::tvec4<T>(dot(g000, g000), dot(g010, g010), dot(g100, g100), dot(g110, g110)));
 
+	g000 *= norm0.x;
 
+	g010 *= norm0.y;
 
+	g100 *= norm0.z;
 
+	g110 *= norm0.w;
 
+	detail::tvec4<T> norm1 = taylorInvSqrt(detail::tvec4<T>(dot(g001, g001), dot(g011, g011), dot(g101, g101), dot(g111, g111)));
 
+	g001 *= norm1.x;
 
+	g011 *= norm1.y;
 
+	g101 *= norm1.z;
 
+	g111 *= norm1.w;
 
+
 
+	T n000 = dot(g000, Pf0);
 
+	T n100 = dot(g100, detail::tvec3<T>(Pf1.x, Pf0.y, Pf0.z));
 
+	T n010 = dot(g010, detail::tvec3<T>(Pf0.x, Pf1.y, Pf0.z));
 
+	T n110 = dot(g110, detail::tvec3<T>(Pf1.x, Pf1.y, Pf0.z));
 
+	T n001 = dot(g001, detail::tvec3<T>(Pf0.x, Pf0.y, Pf1.z));
 
+	T n101 = dot(g101, detail::tvec3<T>(Pf1.x, Pf0.y, Pf1.z));
 
+	T n011 = dot(g011, detail::tvec3<T>(Pf0.x, Pf1.y, Pf1.z));
 
+	T n111 = dot(g111, Pf1);
 
+
 
+	detail::tvec3<T> fade_xyz = fade(Pf0);
 
+	detail::tvec4<T> n_z = mix(detail::tvec4<T>(n000, n100, n010, n110), detail::tvec4<T>(n001, n101, n011, n111), fade_xyz.z);
 
+	detail::tvec2<T> n_yz = mix(detail::tvec2<T>(n_z.x, n_z.y), detail::tvec2<T>(n_z.z, n_z.w), fade_xyz.y);
 
+	T n_xyz = mix(n_yz.x, n_yz.y, fade_xyz.x); 
+	return T(2.2) * n_xyz;
 
+}
 
+/*
 
+// Classic Perlin noise
 
+template <typename T>
 
+GLM_FUNC_QUALIFIER T perlin(detail::tvec3<T> const & P)
 
+{
 
+	detail::tvec3<T> Pi0 = floor(P); // Integer part for indexing
 
+	detail::tvec3<T> Pi1 = Pi0 + T(1); // Integer part + 1
 
+	Pi0 = mod(Pi0, T(289));
 
+	Pi1 = mod(Pi1, T(289));
 
+	detail::tvec3<T> Pf0 = fract(P); // Fractional part for interpolation
 
+	detail::tvec3<T> Pf1 = Pf0 - T(1); // Fractional part - 1.0
 
+	detail::tvec4<T> ix(Pi0.x, Pi1.x, Pi0.x, Pi1.x);
 
+	detail::tvec4<T> iy(Pi0.y, Pi0.y, Pi1.y, Pi1.y);
 
+	detail::tvec4<T> iz0(Pi0.z);
 
+	detail::tvec4<T> iz1(Pi1.z);
 
+
 
+	detail::tvec4<T> ixy = permute(permute(ix) + iy);
 
+	detail::tvec4<T> ixy0 = permute(ixy + iz0);
 
+	detail::tvec4<T> ixy1 = permute(ixy + iz1);
 
+
 
+	detail::tvec4<T> gx0 = ixy0 / T(7);
 
+	detail::tvec4<T> gy0 = fract(floor(gx0) / T(7)) - T(0.5);
 
+	gx0 = fract(gx0);
 
+	detail::tvec4<T> gz0 = detail::tvec4<T>(0.5) - abs(gx0) - abs(gy0);
 
+	detail::tvec4<T> sz0 = step(gz0, detail::tvec4<T>(0.0));
 
+	gx0 -= sz0 * (step(0.0, gx0) - T(0.5));
 
+	gy0 -= sz0 * (step(0.0, gy0) - T(0.5));
 
+
 
+	detail::tvec4<T> gx1 = ixy1 / T(7);
 
+	detail::tvec4<T> gy1 = fract(floor(gx1) / T(7)) - T(0.5);
 
+	gx1 = fract(gx1);
 
+	detail::tvec4<T> gz1 = detail::tvec4<T>(0.5) - abs(gx1) - abs(gy1);
 
+	detail::tvec4<T> sz1 = step(gz1, detail::tvec4<T>(0.0));
 
+	gx1 -= sz1 * (step(T(0), gx1) - T(0.5));
 
+	gy1 -= sz1 * (step(T(0), gy1) - T(0.5));
 
+
 
+	detail::tvec3<T> g000(gx0.x, gy0.x, gz0.x);
 
+	detail::tvec3<T> g100(gx0.y, gy0.y, gz0.y);
 
+	detail::tvec3<T> g010(gx0.z, gy0.z, gz0.z);
 
+	detail::tvec3<T> g110(gx0.w, gy0.w, gz0.w);
 
+	detail::tvec3<T> g001(gx1.x, gy1.x, gz1.x);
 
+	detail::tvec3<T> g101(gx1.y, gy1.y, gz1.y);
 
+	detail::tvec3<T> g011(gx1.z, gy1.z, gz1.z);
 
+	detail::tvec3<T> g111(gx1.w, gy1.w, gz1.w);
 
+
 
+	detail::tvec4<T> norm0 = taylorInvSqrt(detail::tvec4<T>(dot(g000, g000), dot(g010, g010), dot(g100, g100), dot(g110, g110)));
 
+	g000 *= norm0.x;
 
+	g010 *= norm0.y;
 
+	g100 *= norm0.z;
 
+	g110 *= norm0.w;
 
+	detail::tvec4<T> norm1 = taylorInvSqrt(detail::tvec4<T>(dot(g001, g001), dot(g011, g011), dot(g101, g101), dot(g111, g111)));
 
+	g001 *= norm1.x;
 
+	g011 *= norm1.y;
 
+	g101 *= norm1.z;
 
+	g111 *= norm1.w;
 
+
 
+	T n000 = dot(g000, Pf0);
 
+	T n100 = dot(g100, detail::tvec3<T>(Pf1.x, Pf0.y, Pf0.z));
 
+	T n010 = dot(g010, detail::tvec3<T>(Pf0.x, Pf1.y, Pf0.z));
 
+	T n110 = dot(g110, detail::tvec3<T>(Pf1.x, Pf1.y, Pf0.z));
 
+	T n001 = dot(g001, detail::tvec3<T>(Pf0.x, Pf0.y, Pf1.z));
 
+	T n101 = dot(g101, detail::tvec3<T>(Pf1.x, Pf0.y, Pf1.z));
 
+	T n011 = dot(g011, detail::tvec3<T>(Pf0.x, Pf1.y, Pf1.z));
 
+	T n111 = dot(g111, Pf1);
 
+
 
+	detail::tvec3<T> fade_xyz = fade(Pf0);
 
+	detail::tvec4<T> n_z = mix(detail::tvec4<T>(n000, n100, n010, n110), detail::tvec4<T>(n001, n101, n011, n111), fade_xyz.z);
 
+	detail::tvec2<T> n_yz = mix(
 
+        detail::tvec2<T>(n_z.x, n_z.y), 
+        detail::tvec2<T>(n_z.z, n_z.w), fade_xyz.y);
 
+	T n_xyz = mix(n_yz.x, n_yz.y, fade_xyz.x); 
+	return T(2.2) * n_xyz;
 
+}
 
+*/
 
+// Classic Perlin noise
 
+template <typename T>
 
+GLM_FUNC_QUALIFIER T perlin(detail::tvec4<T> const & P)
 
+{
 
+	detail::tvec4<T> Pi0 = floor(P); // Integer part for indexing
 
+	detail::tvec4<T> Pi1 = Pi0 + T(1); // Integer part + 1
 
+	Pi0 = mod(Pi0, T(289));
 
+	Pi1 = mod(Pi1, T(289));
 
+	detail::tvec4<T> Pf0 = fract(P); // Fractional part for interpolation
 
+	detail::tvec4<T> Pf1 = Pf0 - T(1); // Fractional part - 1.0
 
+	detail::tvec4<T> ix(Pi0.x, Pi1.x, Pi0.x, Pi1.x);
 
+	detail::tvec4<T> iy(Pi0.y, Pi0.y, Pi1.y, Pi1.y);
 
+	detail::tvec4<T> iz0(Pi0.z);
 
+	detail::tvec4<T> iz1(Pi1.z);
 
+	detail::tvec4<T> iw0(Pi0.w);
 
+	detail::tvec4<T> iw1(Pi1.w);
 
+
 
+	detail::tvec4<T> ixy = permute(permute(ix) + iy);
 
+	detail::tvec4<T> ixy0 = permute(ixy + iz0);
 
+	detail::tvec4<T> ixy1 = permute(ixy + iz1);
 
+	detail::tvec4<T> ixy00 = permute(ixy0 + iw0);
 
+	detail::tvec4<T> ixy01 = permute(ixy0 + iw1);
 
+	detail::tvec4<T> ixy10 = permute(ixy1 + iw0);
 
+	detail::tvec4<T> ixy11 = permute(ixy1 + iw1);
 
+
 
+	detail::tvec4<T> gx00 = ixy00 / T(7);
 
+	detail::tvec4<T> gy00 = floor(gx00) / T(7);
 
+	detail::tvec4<T> gz00 = floor(gy00) / T(6);
 
+	gx00 = fract(gx00) - T(0.5);
 
+	gy00 = fract(gy00) - T(0.5);
 
+	gz00 = fract(gz00) - T(0.5);
 
+	detail::tvec4<T> gw00 = detail::tvec4<T>(0.75) - abs(gx00) - abs(gy00) - abs(gz00);
 
+	detail::tvec4<T> sw00 = step(gw00, detail::tvec4<T>(0.0));
 
+	gx00 -= sw00 * (step(T(0), gx00) - T(0.5));
 
+	gy00 -= sw00 * (step(T(0), gy00) - T(0.5));
 
+
 
+	detail::tvec4<T> gx01 = ixy01 / T(7);
 
+	detail::tvec4<T> gy01 = floor(gx01) / T(7);
 
+	detail::tvec4<T> gz01 = floor(gy01) / T(6);
 
+	gx01 = fract(gx01) - T(0.5);
 
+	gy01 = fract(gy01) - T(0.5);
 
+	gz01 = fract(gz01) - T(0.5);
 
+	detail::tvec4<T> gw01 = detail::tvec4<T>(0.75) - abs(gx01) - abs(gy01) - abs(gz01);
 
+	detail::tvec4<T> sw01 = step(gw01, detail::tvec4<T>(0.0));
 
+	gx01 -= sw01 * (step(T(0), gx01) - T(0.5));
 
+	gy01 -= sw01 * (step(T(0), gy01) - T(0.5));
 
+
 
+	detail::tvec4<T> gx10 = ixy10 / T(7);
 
+	detail::tvec4<T> gy10 = floor(gx10) / T(7);
 
+	detail::tvec4<T> gz10 = floor(gy10) / T(6);
 
+	gx10 = fract(gx10) - T(0.5);
 
+	gy10 = fract(gy10) - T(0.5);
 
+	gz10 = fract(gz10) - T(0.5);
 
+	detail::tvec4<T> gw10 = detail::tvec4<T>(0.75) - abs(gx10) - abs(gy10) - abs(gz10);
 
+	detail::tvec4<T> sw10 = step(gw10, detail::tvec4<T>(0));
 
+	gx10 -= sw10 * (step(T(0), gx10) - T(0.5));
 
+	gy10 -= sw10 * (step(T(0), gy10) - T(0.5));
 
+
 
+	detail::tvec4<T> gx11 = ixy11 / T(7);
 
+	detail::tvec4<T> gy11 = floor(gx11) / T(7);
 
+	detail::tvec4<T> gz11 = floor(gy11) / T(6);
 
+	gx11 = fract(gx11) - T(0.5);
 
+	gy11 = fract(gy11) - T(0.5);
 
+	gz11 = fract(gz11) - T(0.5);
 
+	detail::tvec4<T> gw11 = detail::tvec4<T>(0.75) - abs(gx11) - abs(gy11) - abs(gz11);
 
+	detail::tvec4<T> sw11 = step(gw11, detail::tvec4<T>(0.0));
 
+	gx11 -= sw11 * (step(T(0), gx11) - T(0.5));
 
+	gy11 -= sw11 * (step(T(0), gy11) - T(0.5));
 
+
 
+	detail::tvec4<T> g0000(gx00.x, gy00.x, gz00.x, gw00.x);
 
+	detail::tvec4<T> g1000(gx00.y, gy00.y, gz00.y, gw00.y);
 
+	detail::tvec4<T> g0100(gx00.z, gy00.z, gz00.z, gw00.z);
 
+	detail::tvec4<T> g1100(gx00.w, gy00.w, gz00.w, gw00.w);
 
+	detail::tvec4<T> g0010(gx10.x, gy10.x, gz10.x, gw10.x);
 
+	detail::tvec4<T> g1010(gx10.y, gy10.y, gz10.y, gw10.y);
 
+	detail::tvec4<T> g0110(gx10.z, gy10.z, gz10.z, gw10.z);
 
+	detail::tvec4<T> g1110(gx10.w, gy10.w, gz10.w, gw10.w);
 
+	detail::tvec4<T> g0001(gx01.x, gy01.x, gz01.x, gw01.x);
 
+	detail::tvec4<T> g1001(gx01.y, gy01.y, gz01.y, gw01.y);
 
+	detail::tvec4<T> g0101(gx01.z, gy01.z, gz01.z, gw01.z);
 
+	detail::tvec4<T> g1101(gx01.w, gy01.w, gz01.w, gw01.w);
 
+	detail::tvec4<T> g0011(gx11.x, gy11.x, gz11.x, gw11.x);
 
+	detail::tvec4<T> g1011(gx11.y, gy11.y, gz11.y, gw11.y);
 
+	detail::tvec4<T> g0111(gx11.z, gy11.z, gz11.z, gw11.z);
 
+	detail::tvec4<T> g1111(gx11.w, gy11.w, gz11.w, gw11.w);
 
+
 
+	detail::tvec4<T> norm00 = taylorInvSqrt(detail::tvec4<T>(dot(g0000, g0000), dot(g0100, g0100), dot(g1000, g1000), dot(g1100, g1100)));
 
+	g0000 *= norm00.x;
 
+	g0100 *= norm00.y;
 
+	g1000 *= norm00.z;
 
+	g1100 *= norm00.w;
 
+
 
+	detail::tvec4<T> norm01 = taylorInvSqrt(detail::tvec4<T>(dot(g0001, g0001), dot(g0101, g0101), dot(g1001, g1001), dot(g1101, g1101)));
 
+	g0001 *= norm01.x;
 
+	g0101 *= norm01.y;
 
+	g1001 *= norm01.z;
 
+	g1101 *= norm01.w;
 
+
 
+	detail::tvec4<T> norm10 = taylorInvSqrt(detail::tvec4<T>(dot(g0010, g0010), dot(g0110, g0110), dot(g1010, g1010), dot(g1110, g1110)));
 
+	g0010 *= norm10.x;
 
+	g0110 *= norm10.y;
 
+	g1010 *= norm10.z;
 
+	g1110 *= norm10.w;
 
+
 
+	detail::tvec4<T> norm11 = taylorInvSqrt(detail::tvec4<T>(dot(g0011, g0011), dot(g0111, g0111), dot(g1011, g1011), dot(g1111, g1111)));
 
+	g0011 *= norm11.x;
 
+	g0111 *= norm11.y;
 
+	g1011 *= norm11.z;
 
+	g1111 *= norm11.w;
 
+
 
+	T n0000 = dot(g0000, Pf0);
 
+	T n1000 = dot(g1000, detail::tvec4<T>(Pf1.x, Pf0.y, Pf0.z, Pf0.w));
 
+	T n0100 = dot(g0100, detail::tvec4<T>(Pf0.x, Pf1.y, Pf0.z, Pf0.w));
 
+	T n1100 = dot(g1100, detail::tvec4<T>(Pf1.x, Pf1.y, Pf0.z, Pf0.w));
 
+	T n0010 = dot(g0010, detail::tvec4<T>(Pf0.x, Pf0.y, Pf1.z, Pf0.w));
 
+	T n1010 = dot(g1010, detail::tvec4<T>(Pf1.x, Pf0.y, Pf1.z, Pf0.w));
 
+	T n0110 = dot(g0110, detail::tvec4<T>(Pf0.x, Pf1.y, Pf1.z, Pf0.w));
 
+	T n1110 = dot(g1110, detail::tvec4<T>(Pf1.x, Pf1.y, Pf1.z, Pf0.w));
 
+	T n0001 = dot(g0001, detail::tvec4<T>(Pf0.x, Pf0.y, Pf0.z, Pf1.w));
 
+	T n1001 = dot(g1001, detail::tvec4<T>(Pf1.x, Pf0.y, Pf0.z, Pf1.w));
 
+	T n0101 = dot(g0101, detail::tvec4<T>(Pf0.x, Pf1.y, Pf0.z, Pf1.w));
 
+	T n1101 = dot(g1101, detail::tvec4<T>(Pf1.x, Pf1.y, Pf0.z, Pf1.w));
 
+	T n0011 = dot(g0011, detail::tvec4<T>(Pf0.x, Pf0.y, Pf1.z, Pf1.w));
 
+	T n1011 = dot(g1011, detail::tvec4<T>(Pf1.x, Pf0.y, Pf1.z, Pf1.w));
 
+	T n0111 = dot(g0111, detail::tvec4<T>(Pf0.x, Pf1.y, Pf1.z, Pf1.w));
 
+	T n1111 = dot(g1111, Pf1);
 
+
 
+	detail::tvec4<T> fade_xyzw = fade(Pf0);
 
+	detail::tvec4<T> n_0w = mix(detail::tvec4<T>(n0000, n1000, n0100, n1100), detail::tvec4<T>(n0001, n1001, n0101, n1101), fade_xyzw.w);
 
+	detail::tvec4<T> n_1w = mix(detail::tvec4<T>(n0010, n1010, n0110, n1110), detail::tvec4<T>(n0011, n1011, n0111, n1111), fade_xyzw.w);
 
+	detail::tvec4<T> n_zw = mix(n_0w, n_1w, fade_xyzw.z);
 
+	detail::tvec2<T> n_yzw = mix(detail::tvec2<T>(n_zw.x, n_zw.y), detail::tvec2<T>(n_zw.z, n_zw.w), fade_xyzw.y);
 
+	T n_xyzw = mix(n_yzw.x, n_yzw.y, fade_xyzw.x);
 
+	return T(2.2) * n_xyzw;
 
+}
 
+
 
+// Classic Perlin noise, periodic variant
 
+template <typename T>
 
+GLM_FUNC_QUALIFIER T perlin(detail::tvec2<T> const & P, detail::tvec2<T> const & rep)
 
+{
 
+	detail::tvec4<T> Pi = floor(detail::tvec4<T>(P.x, P.y, P.x, P.y)) + detail::tvec4<T>(0.0, 0.0, 1.0, 1.0);
 
+	detail::tvec4<T> Pf = fract(detail::tvec4<T>(P.x, P.y, P.x, P.y)) - detail::tvec4<T>(0.0, 0.0, 1.0, 1.0);
 
+	Pi = mod(Pi, detail::tvec4<T>(rep.x, rep.y, rep.x, rep.y)); // To create noise with explicit period
 
+	Pi = mod(Pi, T(289)); // To avoid truncation effects in permutation
 
+	detail::tvec4<T> ix(Pi.x, Pi.z, Pi.x, Pi.z);
 
+	detail::tvec4<T> iy(Pi.y, Pi.y, Pi.w, Pi.w);
 
+	detail::tvec4<T> fx(Pf.x, Pf.z, Pf.x, Pf.z);
 
+	detail::tvec4<T> fy(Pf.y, Pf.y, Pf.w, Pf.w);
 
+
 
+	detail::tvec4<T> i = permute(permute(ix) + iy);
 
+
 
+	detail::tvec4<T> gx = T(2) * fract(i / T(41)) - T(1);
 
+	detail::tvec4<T> gy = abs(gx) - T(0.5);
 
+	detail::tvec4<T> tx = floor(gx + T(0.5));
 
+	gx = gx - tx;
 
+
 
+	detail::tvec2<T> g00(gx.x, gy.x);
 
+	detail::tvec2<T> g10(gx.y, gy.y);
 
+	detail::tvec2<T> g01(gx.z, gy.z);
 
+	detail::tvec2<T> g11(gx.w, gy.w);
 
+
 
+	detail::tvec4<T> norm = taylorInvSqrt(detail::tvec4<T>(dot(g00, g00), dot(g01, g01), dot(g10, g10), dot(g11, g11)));
 
+	g00 *= norm.x;  
+	g01 *= norm.y;  
+	g10 *= norm.z;  
+	g11 *= norm.w;  
+
 
+	T n00 = dot(g00, detail::tvec2<T>(fx.x, fy.x));
 
+	T n10 = dot(g10, detail::tvec2<T>(fx.y, fy.y));
 
+	T n01 = dot(g01, detail::tvec2<T>(fx.z, fy.z));
 
+	T n11 = dot(g11, detail::tvec2<T>(fx.w, fy.w));
 
+
 
+	detail::tvec2<T> fade_xy = fade(detail::tvec2<T>(Pf.x, Pf.y));
 
+	detail::tvec2<T> n_x = mix(detail::tvec2<T>(n00, n01), detail::tvec2<T>(n10, n11), fade_xy.x);
 
+	T n_xy = mix(n_x.x, n_x.y, fade_xy.y);
 
+	return T(2.3) * n_xy;
 
+}
 
+
 
+// Classic Perlin noise, periodic variant
 
+template <typename T>
 
+GLM_FUNC_QUALIFIER T perlin(detail::tvec3<T> const & P, detail::tvec3<T> const & rep)
 
+{
 
+	detail::tvec3<T> Pi0 = mod(floor(P), rep); // Integer part, modulo period
 
+	detail::tvec3<T> Pi1 = mod(Pi0 + detail::tvec3<T>(1.0), rep); // Integer part + 1, mod period
 
+	Pi0 = mod(Pi0, T(289));
 
+	Pi1 = mod(Pi1, T(289));
 
+	detail::tvec3<T> Pf0 = fract(P); // Fractional part for interpolation
 
+	detail::tvec3<T> Pf1 = Pf0 - detail::tvec3<T>(1.0); // Fractional part - 1.0
 
+	detail::tvec4<T> ix = detail::tvec4<T>(Pi0.x, Pi1.x, Pi0.x, Pi1.x);
 
+	detail::tvec4<T> iy = detail::tvec4<T>(Pi0.y, Pi0.y, Pi1.y, Pi1.y);
 
+	detail::tvec4<T> iz0(Pi0.z);
 
+	detail::tvec4<T> iz1(Pi1.z);
 
+
 
+	detail::tvec4<T> ixy = permute(permute(ix) + iy);
 
+	detail::tvec4<T> ixy0 = permute(ixy + iz0);
 
+	detail::tvec4<T> ixy1 = permute(ixy + iz1);
 
+
 
+	detail::tvec4<T> gx0 = ixy0 / T(7);
 
+	detail::tvec4<T> gy0 = fract(floor(gx0) / T(7)) - T(0.5);
 
+	gx0 = fract(gx0);
 
+	detail::tvec4<T> gz0 = detail::tvec4<T>(0.5) - abs(gx0) - abs(gy0);
 
+	detail::tvec4<T> sz0 = step(gz0, detail::tvec4<T>(0));
 
+	gx0 -= sz0 * (step(0.0, gx0) - T(0.5));
 
+	gy0 -= sz0 * (step(0.0, gy0) - T(0.5));
 
+
 
+	detail::tvec4<T> gx1 = ixy1 / T(7);
 
+	detail::tvec4<T> gy1 = fract(floor(gx1) / T(7)) - T(0.5);
 
+	gx1 = fract(gx1);
 
+	detail::tvec4<T> gz1 = detail::tvec4<T>(0.5) - abs(gx1) - abs(gy1);
 
+	detail::tvec4<T> sz1 = step(gz1, detail::tvec4<T>(0.0));
 
+	gx1 -= sz1 * (step(0.0, gx1) - T(0.5));
 
+	gy1 -= sz1 * (step(0.0, gy1) - T(0.5));
 
+
 
+	detail::tvec3<T> g000 = detail::tvec3<T>(gx0.x, gy0.x, gz0.x);
 
+	detail::tvec3<T> g100 = detail::tvec3<T>(gx0.y, gy0.y, gz0.y);
 
+	detail::tvec3<T> g010 = detail::tvec3<T>(gx0.z, gy0.z, gz0.z);
 
+	detail::tvec3<T> g110 = detail::tvec3<T>(gx0.w, gy0.w, gz0.w);
 
+	detail::tvec3<T> g001 = detail::tvec3<T>(gx1.x, gy1.x, gz1.x);
 
+	detail::tvec3<T> g101 = detail::tvec3<T>(gx1.y, gy1.y, gz1.y);
 
+	detail::tvec3<T> g011 = detail::tvec3<T>(gx1.z, gy1.z, gz1.z);
 
+	detail::tvec3<T> g111 = detail::tvec3<T>(gx1.w, gy1.w, gz1.w);
 
+
 
+	detail::tvec4<T> norm0 = taylorInvSqrt(detail::tvec4<T>(dot(g000, g000), dot(g010, g010), dot(g100, g100), dot(g110, g110)));
 
+	g000 *= norm0.x;
 
+	g010 *= norm0.y;
 
+	g100 *= norm0.z;
 
+	g110 *= norm0.w;
 
+	detail::tvec4<T> norm1 = taylorInvSqrt(detail::tvec4<T>(dot(g001, g001), dot(g011, g011), dot(g101, g101), dot(g111, g111)));
 
+	g001 *= norm1.x;
 
+	g011 *= norm1.y;
 
+	g101 *= norm1.z;
 
+	g111 *= norm1.w;
 
+
 
+	T n000 = dot(g000, Pf0);
 
+	T n100 = dot(g100, detail::tvec3<T>(Pf1.x, Pf0.y, Pf0.z));
 
+	T n010 = dot(g010, detail::tvec3<T>(Pf0.x, Pf1.y, Pf0.z));
 
+	T n110 = dot(g110, detail::tvec3<T>(Pf1.x, Pf1.y, Pf0.z));
 
+	T n001 = dot(g001, detail::tvec3<T>(Pf0.x, Pf0.y, Pf1.z));
 
+	T n101 = dot(g101, detail::tvec3<T>(Pf1.x, Pf0.y, Pf1.z));
 
+	T n011 = dot(g011, detail::tvec3<T>(Pf0.x, Pf1.y, Pf1.z));
 
+	T n111 = dot(g111, Pf1);
 
+
 
+	detail::tvec3<T> fade_xyz = fade(Pf0);
 
+	detail::tvec4<T> n_z = mix(detail::tvec4<T>(n000, n100, n010, n110), detail::tvec4<T>(n001, n101, n011, n111), fade_xyz.z);
 
+	detail::tvec2<T> n_yz = mix(detail::tvec2<T>(n_z.x, n_z.y), detail::tvec2<T>(n_z.z, n_z.w), fade_xyz.y);
 
+	T n_xyz = mix(n_yz.x, n_yz.y, fade_xyz.x); 
+	return T(2.2) * n_xyz;
 
+}
 
+
 
+// Classic Perlin noise, periodic version
 
+template <typename T>
 
+GLM_FUNC_QUALIFIER T perlin(detail::tvec4<T> const & P, detail::tvec4<T> const & rep)
 
+{
 
+	detail::tvec4<T> Pi0 = mod(floor(P), rep); // Integer part modulo rep
 
+	detail::tvec4<T> Pi1 = mod(Pi0 + T(1), rep); // Integer part + 1 mod rep
 
+	detail::tvec4<T> Pf0 = fract(P); // Fractional part for interpolation
 
+	detail::tvec4<T> Pf1 = Pf0 - T(1); // Fractional part - 1.0
 
+	detail::tvec4<T> ix = detail::tvec4<T>(Pi0.x, Pi1.x, Pi0.x, Pi1.x);
 
+	detail::tvec4<T> iy = detail::tvec4<T>(Pi0.y, Pi0.y, Pi1.y, Pi1.y);
 
+	detail::tvec4<T> iz0(Pi0.z);
 
+	detail::tvec4<T> iz1(Pi1.z);
 
+	detail::tvec4<T> iw0(Pi0.w);
 
+	detail::tvec4<T> iw1(Pi1.w);
 
+
 
+	detail::tvec4<T> ixy = permute(permute(ix) + iy);
 
+	detail::tvec4<T> ixy0 = permute(ixy + iz0);
 
+	detail::tvec4<T> ixy1 = permute(ixy + iz1);
 
+	detail::tvec4<T> ixy00 = permute(ixy0 + iw0);
 
+	detail::tvec4<T> ixy01 = permute(ixy0 + iw1);
 
+	detail::tvec4<T> ixy10 = permute(ixy1 + iw0);
 
+	detail::tvec4<T> ixy11 = permute(ixy1 + iw1);
 
+
 
+	detail::tvec4<T> gx00 = ixy00 / T(7);
 
+	detail::tvec4<T> gy00 = floor(gx00) / T(7);
 
+	detail::tvec4<T> gz00 = floor(gy00) / T(6);
 
+	gx00 = fract(gx00) - T(0.5);
 
+	gy00 = fract(gy00) - T(0.5);
 
+	gz00 = fract(gz00) - T(0.5);
 
+	detail::tvec4<T> gw00 = detail::tvec4<T>(0.75) - abs(gx00) - abs(gy00) - abs(gz00);
 
+	detail::tvec4<T> sw00 = step(gw00, detail::tvec4<T>(0));
 
+	gx00 -= sw00 * (step(0.0, gx00) - T(0.5));
 
+	gy00 -= sw00 * (step(0.0, gy00) - T(0.5));
 
+
 
+	detail::tvec4<T> gx01 = ixy01 / T(7);
 
+	detail::tvec4<T> gy01 = floor(gx01) / T(7);
 
+	detail::tvec4<T> gz01 = floor(gy01) / T(6);
 
+	gx01 = fract(gx01) - T(0.5);
 
+	gy01 = fract(gy01) - T(0.5);
 
+	gz01 = fract(gz01) - T(0.5);
 
+	detail::tvec4<T> gw01 = detail::tvec4<T>(0.75) - abs(gx01) - abs(gy01) - abs(gz01);
 
+	detail::tvec4<T> sw01 = step(gw01, detail::tvec4<T>(0.0));
 
+	gx01 -= sw01 * (step(0.0, gx01) - T(0.5));
 
+	gy01 -= sw01 * (step(0.0, gy01) - T(0.5));
 
+
 
+	detail::tvec4<T> gx10 = ixy10 / T(7);
 
+	detail::tvec4<T> gy10 = floor(gx10) / T(7);
 
+	detail::tvec4<T> gz10 = floor(gy10) / T(6);
 
+	gx10 = fract(gx10) - T(0.5);
 
+	gy10 = fract(gy10) - T(0.5);
 
+	gz10 = fract(gz10) - T(0.5);
 
+	detail::tvec4<T> gw10 = detail::tvec4<T>(0.75) - abs(gx10) - abs(gy10) - abs(gz10);
 
+	detail::tvec4<T> sw10 = step(gw10, detail::tvec4<T>(0.0));
 
+	gx10 -= sw10 * (step(0.0, gx10) - T(0.5));
 
+	gy10 -= sw10 * (step(0.0, gy10) - T(0.5));
 
+
 
+	detail::tvec4<T> gx11 = ixy11 / T(7);
 
+	detail::tvec4<T> gy11 = floor(gx11) / T(7);
 
+	detail::tvec4<T> gz11 = floor(gy11) / T(6);
 
+	gx11 = fract(gx11) - T(0.5);
 
+	gy11 = fract(gy11) - T(0.5);
 
+	gz11 = fract(gz11) - T(0.5);
 
+	detail::tvec4<T> gw11 = detail::tvec4<T>(0.75) - abs(gx11) - abs(gy11) - abs(gz11);
 
+	detail::tvec4<T> sw11 = step(gw11, detail::tvec4<T>(0.0));
 
+	gx11 -= sw11 * (step(0.0, gx11) - T(0.5));
 
+	gy11 -= sw11 * (step(0.0, gy11) - T(0.5));
 
+
 
+	detail::tvec4<T> g0000(gx00.x, gy00.x, gz00.x, gw00.x);
 
+	detail::tvec4<T> g1000(gx00.y, gy00.y, gz00.y, gw00.y);
 
+	detail::tvec4<T> g0100(gx00.z, gy00.z, gz00.z, gw00.z);
 
+	detail::tvec4<T> g1100(gx00.w, gy00.w, gz00.w, gw00.w);
 
+	detail::tvec4<T> g0010(gx10.x, gy10.x, gz10.x, gw10.x);
 
+	detail::tvec4<T> g1010(gx10.y, gy10.y, gz10.y, gw10.y);
 
+	detail::tvec4<T> g0110(gx10.z, gy10.z, gz10.z, gw10.z);
 
+	detail::tvec4<T> g1110(gx10.w, gy10.w, gz10.w, gw10.w);
 
+	detail::tvec4<T> g0001(gx01.x, gy01.x, gz01.x, gw01.x);
 
+	detail::tvec4<T> g1001(gx01.y, gy01.y, gz01.y, gw01.y);
 
+	detail::tvec4<T> g0101(gx01.z, gy01.z, gz01.z, gw01.z);
 
+	detail::tvec4<T> g1101(gx01.w, gy01.w, gz01.w, gw01.w);
 
+	detail::tvec4<T> g0011(gx11.x, gy11.x, gz11.x, gw11.x);
 
+	detail::tvec4<T> g1011(gx11.y, gy11.y, gz11.y, gw11.y);
 
+	detail::tvec4<T> g0111(gx11.z, gy11.z, gz11.z, gw11.z);
 
+	detail::tvec4<T> g1111(gx11.w, gy11.w, gz11.w, gw11.w);
 
+
 
+	detail::tvec4<T> norm00 = taylorInvSqrt(detail::tvec4<T>(dot(g0000, g0000), dot(g0100, g0100), dot(g1000, g1000), dot(g1100, g1100)));
 
+	g0000 *= norm00.x;
 
+	g0100 *= norm00.y;
 
+	g1000 *= norm00.z;
 
+	g1100 *= norm00.w;
 
+
 
+	detail::tvec4<T> norm01 = taylorInvSqrt(detail::tvec4<T>(dot(g0001, g0001), dot(g0101, g0101), dot(g1001, g1001), dot(g1101, g1101)));
 
+	g0001 *= norm01.x;
 
+	g0101 *= norm01.y;
 
+	g1001 *= norm01.z;
 
+	g1101 *= norm01.w;
 
+
 
+	detail::tvec4<T> norm10 = taylorInvSqrt(detail::tvec4<T>(dot(g0010, g0010), dot(g0110, g0110), dot(g1010, g1010), dot(g1110, g1110)));
 
+	g0010 *= norm10.x;
 
+	g0110 *= norm10.y;
 
+	g1010 *= norm10.z;
 
+	g1110 *= norm10.w;
 
+
 
+	detail::tvec4<T> norm11 = taylorInvSqrt(detail::tvec4<T>(dot(g0011, g0011), dot(g0111, g0111), dot(g1011, g1011), dot(g1111, g1111)));
 
+	g0011 *= norm11.x;
 
+	g0111 *= norm11.y;
 
+	g1011 *= norm11.z;
 
+	g1111 *= norm11.w;
 
+
 
+	T n0000 = dot(g0000, Pf0);
 
+	T n1000 = dot(g1000, detail::tvec4<T>(Pf1.x, Pf0.y, Pf0.z, Pf0.w));
 
+	T n0100 = dot(g0100, detail::tvec4<T>(Pf0.x, Pf1.y, Pf0.z, Pf0.w));
 
+	T n1100 = dot(g1100, detail::tvec4<T>(Pf1.x, Pf1.y, Pf0.z, Pf0.w));
 
+	T n0010 = dot(g0010, detail::tvec4<T>(Pf0.x, Pf0.y, Pf1.z, Pf0.w));
 
+	T n1010 = dot(g1010, detail::tvec4<T>(Pf1.x, Pf0.y, Pf1.z, Pf0.w));
 
+	T n0110 = dot(g0110, detail::tvec4<T>(Pf0.x, Pf1.y, Pf1.z, Pf0.w));
 
+	T n1110 = dot(g1110, detail::tvec4<T>(Pf1.x, Pf1.y, Pf1.z, Pf0.w));
 
+	T n0001 = dot(g0001, detail::tvec4<T>(Pf0.x, Pf0.y, Pf0.z, Pf1.w));
 
+	T n1001 = dot(g1001, detail::tvec4<T>(Pf1.x, Pf0.y, Pf0.z, Pf1.w));
 
+	T n0101 = dot(g0101, detail::tvec4<T>(Pf0.x, Pf1.y, Pf0.z, Pf1.w));
 
+	T n1101 = dot(g1101, detail::tvec4<T>(Pf1.x, Pf1.y, Pf0.z, Pf1.w));
 
+	T n0011 = dot(g0011, detail::tvec4<T>(Pf0.x, Pf0.y, Pf1.z, Pf1.w));
 
+	T n1011 = dot(g1011, detail::tvec4<T>(Pf1.x, Pf0.y, Pf1.z, Pf1.w));
 
+	T n0111 = dot(g0111, detail::tvec4<T>(Pf0.x, Pf1.y, Pf1.z, Pf1.w));
 
+	T n1111 = dot(g1111, Pf1);
 
+
 
+	detail::tvec4<T> fade_xyzw = fade(Pf0);
 
+	detail::tvec4<T> n_0w = mix(detail::tvec4<T>(n0000, n1000, n0100, n1100), detail::tvec4<T>(n0001, n1001, n0101, n1101), fade_xyzw.w);
 
+	detail::tvec4<T> n_1w = mix(detail::tvec4<T>(n0010, n1010, n0110, n1110), detail::tvec4<T>(n0011, n1011, n0111, n1111), fade_xyzw.w);
 
+	detail::tvec4<T> n_zw = mix(n_0w, n_1w, fade_xyzw.z);
 
+	detail::tvec2<T> n_yzw = mix(detail::tvec2<T>(n_zw.x, n_zw.y), detail::tvec2<T>(n_zw.z, n_zw.w), fade_xyzw.y);
 
+	T n_xyzw = mix(n_yzw.x, n_yzw.y, fade_xyzw.x);
 
+	return T(2.2) * n_xyzw;
 
+}
 
+
 
+template <typename T>
 
+GLM_FUNC_QUALIFIER T simplex(glm::detail::tvec2<T> const & v)
 
+{
 
+	detail::tvec4<T> const C = detail::tvec4<T>(
 
+		T( 0.211324865405187),  // (3.0 -  sqrt(3.0)) / 6.0
 
+		T( 0.366025403784439),  //  0.5 * (sqrt(3.0)  - 1.0)
 
+		T(-0.577350269189626),	// -1.0 + 2.0 * C.x
 
+		T( 0.024390243902439)); //  1.0 / 41.0
 
+
 
+	// First corner
 
+	detail::tvec2<T> i  = floor(v + dot(v, detail::tvec2<T>(C[1])));
 
+	detail::tvec2<T> x0 = v -   i + dot(i, detail::tvec2<T>(C[0]));
 
+
 
+	// Other corners
 
+	//i1.x = step( x0.y, x0.x ); // x0.x > x0.y ? 1.0 : 0.0
 
+	//i1.y = 1.0 - i1.x;
 
+	detail::tvec2<T> i1 = (x0.x > x0.y) ? detail::tvec2<T>(1, 0) : detail::tvec2<T>(0, 1);
 
+	// x0 = x0 - 0.0 + 0.0 * C.xx ;
 
+	// x1 = x0 - i1 + 1.0 * C.xx ;
 
+	// x2 = x0 - 1.0 + 2.0 * C.xx ;
 
+	detail::tvec4<T> x12 = detail::tvec4<T>(x0.x, x0.y, x0.x, x0.y) + detail::tvec4<T>(C.x, C.x, C.z, C.z);
 
+	x12 = detail::tvec4<T>(detail::tvec2<T>(x12) - i1, x12.z, x12.w);
 
+
 
+	// Permutations
 
+	i = mod(i, T(289)); // Avoid truncation effects in permutation
 
+	detail::tvec3<T> p = permute(
 
+		permute(i.y + detail::tvec3<T>(T(0), i1.y, T(1)))
 
+		+ i.x + detail::tvec3<T>(T(0), i1.x, T(1)));
 
+
 
+	detail::tvec3<T> m = max(T(0.5) - detail::tvec3<T>(
 
+		dot(x0, x0), 
+		dot(detail::tvec2<T>(x12.x, x12.y), detail::tvec2<T>(x12.x, x12.y)), 
+		dot(detail::tvec2<T>(x12.z, x12.w), detail::tvec2<T>(x12.z, x12.w))), T(0));
 
+	m = m * m ;
 
+	m = m * m ;
 
+
 
+	// Gradients: 41 points uniformly over a line, mapped onto a diamond.
 
+	// The ring size 17*17 = 289 is close to a multiple of 41 (41*7 = 287)
 
+
 
+	detail::tvec3<T> x = T(2) * fract(p * C.w) - T(1);
 
+	detail::tvec3<T> h = abs(x) - T(0.5);
 
+	detail::tvec3<T> ox = floor(x + T(0.5));
 
+	detail::tvec3<T> a0 = x - ox;
 
+
 
+	// Normalise gradients implicitly by scaling m
 
+	// Inlined for speed: m *= taylorInvSqrt( a0*a0 + h*h );
 
+	m *= T(1.79284291400159) - T(0.85373472095314) * (a0 * a0 + h * h);
 
+
 
+	// Compute final noise value at P
 
+	detail::tvec3<T> g;
 
+	g.x  = a0.x  * x0.x  + h.x  * x0.y;
 
+	//g.yz = a0.yz * x12.xz + h.yz * x12.yw;
 
+	g.y = a0.y * x12.x + h.y * x12.y;
 
+	g.z = a0.z * x12.z + h.z * x12.w;
 
+	return T(130) * dot(m, g);
 
+}
 
+
 
+template <typename T>
 
+GLM_FUNC_QUALIFIER T simplex(detail::tvec3<T> const & v)
 
+{ 
+	detail::tvec2<T> const C(1.0 / 6.0, 1.0 / 3.0);
 
+	detail::tvec4<T> const D(0.0, 0.5, 1.0, 2.0);
 
+
 
+	// First corner
 
+	detail::tvec3<T> i(floor(v + dot(v, detail::tvec3<T>(C.y))));
 
+	detail::tvec3<T> x0(v - i + dot(i, detail::tvec3<T>(C.x)));
 
+
 
+	// Other corners
 
+	detail::tvec3<T> g(step(detail::tvec3<T>(x0.y, x0.z, x0.x), x0));
 
+	detail::tvec3<T> l(T(1) - g);
 
+	detail::tvec3<T> i1(min(g, detail::tvec3<T>(l.z, l.x, l.y)));
 
+	detail::tvec3<T> i2(max(g, detail::tvec3<T>(l.z, l.x, l.y)));
 
+
 
+	//   x0 = x0 - 0.0 + 0.0 * C.xxx;
 
+	//   x1 = x0 - i1  + 1.0 * C.xxx;
 
+	//   x2 = x0 - i2  + 2.0 * C.xxx;
 
+	//   x3 = x0 - 1.0 + 3.0 * C.xxx;
 
+	detail::tvec3<T> x1(x0 - i1 + C.x);
 
+	detail::tvec3<T> x2(x0 - i2 + C.y); // 2.0*C.x = 1/3 = C.y
 
+	detail::tvec3<T> x3(x0 - D.y);      // -1.0+3.0*C.x = -0.5 = -D.y
 
+
 
+	// Permutations
 
+	i = mod289(i); 
+	detail::tvec4<T> p(permute(permute(permute( 
+		i.z + detail::tvec4<T>(T(0), i1.z, i2.z, T(1))) + 
+		i.y + detail::tvec4<T>(T(0), i1.y, i2.y, T(1))) + 
+		i.x + detail::tvec4<T>(T(0), i1.x, i2.x, T(1))));
 
+
 
+	// Gradients: 7x7 points over a square, mapped onto an octahedron.
 
+	// The ring size 17*17 = 289 is close to a multiple of 49 (49*6 = 294)
 
+	T n_ = T(0.142857142857); // 1.0/7.0
 
+	detail::tvec3<T> ns(n_ * detail::tvec3<T>(D.w, D.y, D.z) - detail::tvec3<T>(D.x, D.z, D.x));
 
+
 
+	detail::tvec4<T> j(p - T(49) * floor(p * ns.z * ns.z));  //  mod(p,7*7)
 
+
 
+	detail::tvec4<T> x_(floor(j * ns.z));
 
+	detail::tvec4<T> y_(floor(j - T(7) * x_));    // mod(j,N)
 
+
 
+	detail::tvec4<T> x(x_ * ns.x + ns.y);
 
+	detail::tvec4<T> y(y_ * ns.x + ns.y);
 
+	detail::tvec4<T> h(T(1) - abs(x) - abs(y));
 
+
 
+	detail::tvec4<T> b0(x.x, x.y, y.x, y.y);
 
+	detail::tvec4<T> b1(x.z, x.w, y.z, y.w);
 
+
 
+	// vec4 s0 = vec4(lessThan(b0,0.0))*2.0 - 1.0;
 
+	// vec4 s1 = vec4(lessThan(b1,0.0))*2.0 - 1.0;
 
+	detail::tvec4<T> s0(floor(b0) * T(2) + T(1));
 
+	detail::tvec4<T> s1(floor(b1) * T(2) + T(1));
 
+	detail::tvec4<T> sh(-step(h, detail::tvec4<T>(0.0)));
 
+
 
+	detail::tvec4<T> a0 = detail::tvec4<T>(b0.x, b0.z, b0.y, b0.w) + detail::tvec4<T>(s0.x, s0.z, s0.y, s0.w) * detail::tvec4<T>(sh.x, sh.x, sh.y, sh.y);
 
+	detail::tvec4<T> a1 = detail::tvec4<T>(b1.x, b1.z, b1.y, b1.w) + detail::tvec4<T>(s1.x, s1.z, s1.y, s1.w) * detail::tvec4<T>(sh.z, sh.z, sh.w, sh.w);
 
+
 
+	detail::tvec3<T> p0(a0.x, a0.y, h.x);
 
+	detail::tvec3<T> p1(a0.z, a0.w, h.y);
 
+	detail::tvec3<T> p2(a1.x, a1.y, h.z);
 
+	detail::tvec3<T> p3(a1.z, a1.w, h.w);
 
+
 
+	// Normalise gradients
 
+	detail::tvec4<T> norm = taylorInvSqrt(detail::tvec4<T>(dot(p0, p0), dot(p1, p1), dot(p2, p2), dot(p3, p3)));
 
+	p0 *= norm.x;
 
+	p1 *= norm.y;
 
+	p2 *= norm.z;
 
+	p3 *= norm.w;
 
+
 
+	// Mix final noise value
 
+	detail::tvec4<T> m = max(T(0.6) - detail::tvec4<T>(dot(x0, x0), dot(x1, x1), dot(x2, x2), dot(x3, x3)), T(0));
 
+	m = m * m;
 
+	return T(42) * dot(m * m, detail::tvec4<T>(dot(p0, x0), dot(p1, x1), dot(p2, x2), dot(p3, x3)));
 
+}
 
+
 
+template <typename T>
 
+GLM_FUNC_QUALIFIER T simplex(detail::tvec4<T> const & v)
 
+{
 
+	detail::tvec4<T> const C(
 
+		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
 
+	T const F4 = T(0.309016994374947451);
 
+
 
+	// First corner
 
+	detail::tvec4<T> i  = floor(v + dot(v, vec4(F4)));
 
+	detail::tvec4<T> x0 = v -   i + dot(i, vec4(C.x));
 
+
 
+	// Other corners
 
+
 
+	// Rank sorting originally contributed by Bill Licea-Kane, AMD (formerly ATI)
 
+	detail::tvec4<T> i0;
 
+	detail::tvec3<T> isX = step(detail::tvec3<T>(x0.y, x0.z, x0.w), detail::tvec3<T>(x0.x));
 
+	detail::tvec3<T> isYZ = step(detail::tvec3<T>(x0.z, x0.w, x0.w), detail::tvec3<T>(x0.y, x0.y, x0.z));
 
+	//  i0.x = dot(isX, vec3(1.0));
 
+	//i0.x = isX.x + isX.y + isX.z;
 
+	//i0.yzw = T(1) - isX;
 
+    i0 = detail::tvec4<T>(isX.x + isX.y + isX.z, T(1) - isX);
 
+	//  i0.y += dot(isYZ.xy, vec2(1.0));
 
+	i0.y += isYZ.x + isYZ.y;
 
+	//i0.zw += 1.0 - detail::tvec2<T>(isYZ.x, isYZ.y);
 
+    i0.z += T(1) - isYZ.x;
 
+    i0.w += T(1) - isYZ.y;
 
+	i0.z += isYZ.z;
 
+	i0.w += T(1) - isYZ.z;
 
+
 
+	// i0 now contains the unique values 0,1,2,3 in each channel
 
+	detail::tvec4<T> i3 = clamp(i0, 0.0, 1.0);
 
+	detail::tvec4<T> i2 = clamp(i0 - 1.0, 0.0, 1.0);
 
+	detail::tvec4<T> i1 = clamp(i0 - 2.0, 0.0, 1.0);
 
+
 
+	//  x0 = x0 - 0.0 + 0.0 * C.xxxx
 
+	//  x1 = x0 - i1  + 0.0 * C.xxxx
 
+	//  x2 = x0 - i2  + 0.0 * C.xxxx
 
+	//  x3 = x0 - i3  + 0.0 * C.xxxx
 
+	//  x4 = x0 - 1.0 + 4.0 * C.xxxx
 
+	detail::tvec4<T> x1 = x0 - i1 + C.x;
 
+	detail::tvec4<T> x2 = x0 - i2 + C.y;
 
+	detail::tvec4<T> x3 = x0 - i3 + C.z;
 
+	detail::tvec4<T> x4 = x0 + C.w;
 
+
 
+	// Permutations
 
+	i = mod(i, T(289)); 
+	T j0 = permute(permute(permute(permute(i.w) + i.z) + i.y) + i.x);
 
+	detail::tvec4<T> j1 = permute(permute(permute(permute(
 
+				i.w + detail::tvec4<T>(i1.w, i2.w, i3.w, T(1)))
 
+			+ i.z + detail::tvec4<T>(i1.z, i2.z, i3.z, T(1)))
 
+			+ i.y + detail::tvec4<T>(i1.y, i2.y, i3.y, T(1)))
 
+			+ i.x + detail::tvec4<T>(i1.x, i2.x, i3.x, T(1)));
 
+
 
+	// 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.
 
+	detail::tvec4<T> ip = detail::tvec4<T>(T(1) / T(294), T(1) / T(49), T(1) / T(7), T(0));
 
+
 
+	detail::tvec4<T> p0 = grad4(j0,   ip);
 
+	detail::tvec4<T> p1 = grad4(j1.x, ip);
 
+	detail::tvec4<T> p2 = grad4(j1.y, ip);
 
+	detail::tvec4<T> p3 = grad4(j1.z, ip);
 
+	detail::tvec4<T> p4 = grad4(j1.w, ip);
 
+
 
+	// Normalise gradients
 
+	detail::tvec4<T> norm = taylorInvSqrt(detail::tvec4<T>(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
 
+	detail::tvec3<T> m0 = max(T(0.6) - detail::tvec3<T>(dot(x0, x0), dot(x1, x1), dot(x2, x2)), T(0));
 
+	detail::tvec2<T> m1 = max(T(0.6) - detail::tvec2<T>(dot(x3, x3), dot(x4, x4)             ), T(0));
 
+	m0 = m0 * m0;
 
+	m1 = m1 * m1;
 
+	return T(49) * 
+		(dot(m0 * m0, detail::tvec3<T>(dot(p0, x0), dot(p1, x1), dot(p2, x2))) + 
+		dot(m1 * m1, detail::tvec2<T>(dot(p3, x3), dot(p4, x4))));
 
+}
 
+
 
+}//namespace glm

+ 177 - 0
glm/gtx/constants.hpp
View File 

@@ -0,0 +1,177 @@
 
+///////////////////////////////////////////////////////////////////////////////////
 
+/// OpenGL Mathematics (glm.g-truc.net)
 
+///
 
+/// Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
 
+/// Permission is hereby granted, free of charge, to any person obtaining a copy
 
+/// of this software and associated documentation files (the "Software"), to deal
 
+/// in the Software without restriction, including without limitation the rights
 
+/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 
+/// copies of the Software, and to permit persons to whom the Software is
 
+/// furnished to do so, subject to the following conditions:
 
+/// 
+/// The above copyright notice and this permission notice shall be included in
 
+/// all copies or substantial portions of the Software.
 
+/// 
+/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 
+/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 
+/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 
+/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 
+/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 
+/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 
+/// THE SOFTWARE.
 
+///
 
+/// @ref constants
 
+/// @file glm/gtx/constants.hpp
 
+/// @date 2011-09-30 / 2011-09-30
 
+/// @author Christophe Riccio
 
+///
 
+/// @see core (dependence)
 
+/// @see gtc_half_float (dependence)
 
+///
 
+/// @defgroup gtx_constants GLM_GTX_constants: Provide build-in constants
 
+/// @ingroup gtx
 
+/// 
+/// @brief Allow to perform bit operations on integer values
 
+/// 
+/// <glm/gtx/constants.hpp> need to be included to use these functionalities.
 
+///////////////////////////////////////////////////////////////////////////////////
 
+
 
+#ifndef GLM_GTX_constants
 
+#define GLM_GTX_constants GLM_VERSION
 
+
 
+// Dependency:
 
+#include "../glm.hpp"
 
+#include "../gtc/half_float.hpp"
 
+
 
+#if(defined(GLM_MESSAGES) && !defined(glm_ext))
 
+#	pragma message("GLM: GLM_GTX_constants extension included")
 
+#endif
 
+
 
+namespace glm
 
+{
 
+	/// @addtogroup gtx_constants
 
+	/// @{
 
+
 
+	template <typename T>
 
+	T pi();
 
+
 
+	template <typename T>
 
+	GLM_FUNC_QUALIFIER T pi()
 
+	{
 
+		return T(3.14159265358979323846264338327950288);
 
+	}
 
+
 
+	template <typename T>
 
+	GLM_FUNC_QUALIFIER T root_pi()
 
+	{
 
+		return T(1.772453850905516027);
 
+	}
 
+
 
+	template <typename T>
 
+	GLM_FUNC_QUALIFIER T half_pi()
 
+	{
 
+		return T(1.57079632679489661923132169163975144);
 
+	}
 
+
 
+	template <typename T>
 
+	GLM_FUNC_QUALIFIER T quarter_pi()
 
+	{
 
+		return T(0.785398163397448309615660845819875721);
 
+	}
 
+
 
+	template <typename T>
 
+	GLM_FUNC_QUALIFIER T one_over_pi()
 
+	{
 
+		return T(0.318309886183790671537767526745028724);
 
+	}
 
+
 
+	template <typename T>
 
+	GLM_FUNC_QUALIFIER T two_over_pi()
 
+	{
 
+		return T(0.636619772367581343075535053490057448);
 
+	}
 
+
 
+	template <typename T>
 
+	GLM_FUNC_QUALIFIER T two_over_root_pi()
 
+	{
 
+		return T(1.12837916709551257389615890312154517);
 
+	}
 
+
 
+	template <typename T>
 
+	GLM_FUNC_QUALIFIER T one_over_root_two()
 
+	{
 
+		return T(0.707106781186547524400844362104849039);
 
+	}
 
+
 
+	template <typename T>
 
+	GLM_FUNC_QUALIFIER T root_half_pi()
 
+	{
 
+		return T(1.253314137315500251);
 
+	}
 
+
 
+	template <typename T>
 
+	GLM_FUNC_QUALIFIER T root_two_pi()
 
+	{
 
+		return T(2.506628274631000502);
 
+	}
 
+
 
+	template <typename T>
 
+	GLM_FUNC_QUALIFIER T root_ln_four()
 
+	{
 
+		return T(1.17741002251547469);
 
+	}
 
+
 
+	template <typename T>
 
+	GLM_FUNC_QUALIFIER T e()
 
+	{
 
+		return T(2.71828182845904523536);
 
+	}
 
+
 
+	template <typename T>
 
+	GLM_FUNC_QUALIFIER T euler()
 
+	{
 
+		return T(0.577215664901532860606);
 
+	}
 
+
 
+	template <typename T>
 
+	GLM_FUNC_QUALIFIER T root_two()
 
+	{
 
+		return T(1.41421356237309504880168872420969808);
 
+	}
 
+
 
+	template <typename T>
 
+	GLM_FUNC_QUALIFIER T ln_two()
 
+	{
 
+		return T(0.693147180559945309417232121458176568);
 
+	}
 
+
 
+	template <typename T>
 
+	GLM_FUNC_QUALIFIER T ln_ten(2.30258509299404568401799145468436421)
 
+	{
 
+		return T();
 
+	}
 
+
 
+	template <typename T>
 
+	GLM_FUNC_QUALIFIER T ln_ln_two()
 
+	{
 
+		return T(-0.3665129205816643);
 
+	}
 
+
 
+	template <typename T>
 
+	GLM_FUNC_QUALIFIER T third()
 
+	{
 
+		return T(0.333333333333333333);
 
+	}
 
+
 
+	template <typename T>
 
+	GLM_FUNC_QUALIFIER T twothirds()
 
+	{
 
+		return T(0.666666666666666666);
 
+	}
 
+
 
+	/// @}
 
+} //namespace glm
 
+
 
+#include "constants.inl"
 
+
 
+#endif//GLM_GTX_constants

+ 792 - 0
glm/gtx/constants.inl
View File 

@@ -0,0 +1,792 @@
 
+///////////////////////////////////////////////////////////////////////////////////
 
+/// OpenGL Mathematics (glm.g-truc.net)
 
+///
 
+/// Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
 
+/// Permission is hereby granted, free of charge, to any person obtaining a copy
 
+/// of this software and associated documentation files (the "Software"), to deal
 
+/// in the Software without restriction, including without limitation the rights
 
+/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 
+/// copies of the Software, and to permit persons to whom the Software is
 
+/// furnished to do so, subject to the following conditions:
 
+/// 
+/// The above copyright notice and this permission notice shall be included in
 
+/// all copies or substantial portions of the Software.
 
+/// 
+/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 
+/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 
+/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 
+/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 
+/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 
+/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 
+/// THE SOFTWARE.
 
+///
 
+/// @ref gtc_half_float
 
+/// @file glm/gtc/half_float.inl
 
+/// @date 2009-04-29 / 2011-06-05
 
+/// @author Christophe Riccio
 
+///////////////////////////////////////////////////////////////////////////////////
 
+
 
+#include "../core/_detail.hpp"
 
+
 
+namespace glm{
 
+
 
+template <typename genIType>
 
+GLM_FUNC_QUALIFIER genIType mask
 
+(
 
+	genIType const & count
 
+)
 
+{
 
+	return ((genIType(1) << (count)) - genIType(1));
 
+}
 
+
 
+template <typename valIType>
 
+GLM_FUNC_QUALIFIER detail::tvec2<valIType> mask
 
+(
 
+	detail::tvec2<valIType> const & count
 
+)
 
+{
 
+	return detail::tvec2<valIType>(
 
+		mask(count[0]),
 
+		mask(count[1]));
 
+}
 
+
 
+template <typename valIType>
 
+GLM_FUNC_QUALIFIER detail::tvec3<valIType> mask
 
+(
 
+	detail::tvec3<valIType> const & count
 
+)
 
+{
 
+	return detail::tvec3<valIType>(
 
+		mask(count[0]),
 
+		mask(count[1]),
 
+		mask(count[2]));
 
+}
 
+
 
+template <typename valIType>
 
+GLM_FUNC_QUALIFIER detail::tvec4<valIType> mask
 
+(
 
+	detail::tvec4<valIType> const & count
 
+)
 
+{
 
+	return detail::tvec4<valIType>(
 
+		mask(count[0]),
 
+		mask(count[1]),
 
+		mask(count[2]),
 
+		mask(count[3]));
 
+}
 
+
 
+// extractField
 
+template <typename genIType>
 
+GLM_FUNC_QUALIFIER genIType extractField
 
+(
 
+	half const & value, 
+	genIType const & first, 
+	genIType const & count
 
+)
 
+{
 
+	assert(first + count < sizeof(half));
 
+	return (value._data() << first) >> ((sizeof(half) << 3) - count);
 
+}
 
+
 
+template <typename genIType>
 
+GLM_FUNC_QUALIFIER genIType extractField
 
+(
 
+	float const & value, 
+	genIType const & first, 
+	genIType const & count
 
+)
 
+{
 
+	assert(first + count < sizeof(float));
 
+	return (detail::uif32(value).i << first) >> ((sizeof(float) << 3) - count);
 
+}
 
+
 
+template <typename genIType>
 
+GLM_FUNC_QUALIFIER genIType extractField
 
+(
 
+	double const & value, 
+	genIType const & first, 
+	genIType const & count
 
+)
 
+{
 
+	assert(first + count < sizeof(double));
 
+	return (detail::uif64(value).i << first) >> ((sizeof(double) << genIType(3)) - count);
 
+}
 
+
 
+template <typename genIUType, typename sizeType>
 
+GLM_FUNC_QUALIFIER genIUType extractField
 
+(
 
+	genIUType const & Value, 
+	sizeType const & First, 
+	sizeType const & Count
 
+)
 
+{
 
+	sizeType GenSize = sizeof(genIUType) << 3;
 
+
 
+	assert(First + Count <= GenSize);
 
+
 
+	genIUType ShiftLeft = Count ? Value << (GenSize - (Count + First)) : 0;
 
+	genIUType ShiftBack = ShiftLeft >> genIUType(GenSize - Count);
 
+
 
+	return ShiftBack;
 
+}
 
+
 
+template <typename genIUType, typename sizeType>
 
+GLM_FUNC_QUALIFIER detail::tvec2<genIUType> extractField
 
+(
 
+	detail::tvec2<genIUType> const & value, 
+	sizeType const & first, 
+	sizeType const & count
 
+)
 
+{
 
+	return detail::tvec2<genIUType>(
 
+		extractField(value[0], first, count),
 
+		extractField(value[1], first, count));
 
+}
 
+
 
+template <typename genIUType, typename sizeType>
 
+GLM_FUNC_QUALIFIER detail::tvec3<genIUType> extractField
 
+(
 
+	detail::tvec3<genIUType> const & value, 
+	sizeType const & first, 
+	sizeType const & count
 
+)
 
+{
 
+	return detail::tvec3<genIUType>(
 
+		extractField(value[0], first, count),
 
+		extractField(value[1], first, count),
 
+		extractField(value[2], first, count));
 
+}
 
+
 
+template <typename genIUType, typename sizeType>
 
+GLM_FUNC_QUALIFIER detail::tvec4<genIUType> extractField
 
+(
 
+	detail::tvec4<genIUType> const & value, 
+	sizeType const & first, 
+	sizeType const & count
 
+)
 
+{
 
+	return detail::tvec4<genIUType>(
 
+		extractField(value[0], first, count),
 
+		extractField(value[1], first, count),
 
+		extractField(value[2], first, count),
 
+		extractField(value[3], first, count));
 
+}
 
+
 
+template <typename genIUType, typename sizeType>
 
+GLM_FUNC_QUALIFIER detail::tvec2<genIUType> extractField
 
+(
 
+	detail::tvec2<genIUType> const & value, 
+	detail::tvec2<sizeType> const & first, 
+	detail::tvec2<sizeType> const & count
 
+)
 
+{
 
+	return detail::tvec2<genIUType>(
 
+		extractField(value[0], first[0], count[0]),
 
+		extractField(value[1], first[1], count[1]));
 
+}
 
+
 
+template <typename genIUType, typename sizeType>
 
+GLM_FUNC_QUALIFIER detail::tvec3<genIUType> extractField
 
+(
 
+	detail::tvec3<genIUType> const & value, 
+	detail::tvec3<sizeType> const & first, 
+	detail::tvec3<sizeType> const & count
 
+)
 
+{
 
+	return detail::tvec3<genIUType>(
 
+		extractField(value[0], first[0], count[0]),
 
+		extractField(value[1], first[1], count[1]),
 
+		extractField(value[2], first[2], count[2]));
 
+}
 
+
 
+template <typename genIUType, typename sizeType>
 
+GLM_FUNC_QUALIFIER detail::tvec4<genIUType> extractField
 
+(
 
+	detail::tvec4<genIUType> const & value, 
+	detail::tvec4<sizeType> const & first, 
+	detail::tvec4<sizeType> const & count
 
+)
 
+{
 
+	return detail::tvec4<genIUType>(
 
+		extractField(value[0], first[0], count[0]),
 
+		extractField(value[1], first[1], count[1]),
 
+		extractField(value[2], first[2], count[2]),
 
+		extractField(value[3], first[3], count[3]));
 
+}
 
+
 
+template <typename genIUType, typename sizeType>
 
+GLM_FUNC_QUALIFIER detail::tvec2<genIUType> extractField
 
+(
 
+	genIUType const & value, 
+	detail::tvec2<sizeType> const & first, 
+	detail::tvec2<sizeType> const & count
 
+)
 
+{
 
+	return detail::tvec2<genIUType>(
 
+		extractField(value, first[0], count[0]),
 
+		extractField(value, first[1], count[1]));
 
+}
 
+
 
+template <typename genIUType, typename sizeType>
 
+GLM_FUNC_QUALIFIER detail::tvec3<genIUType> extractField
 
+(
 
+	genIUType const & value, 
+	detail::tvec3<sizeType> const & first, 
+	detail::tvec3<sizeType> const & count
 
+)
 
+{
 
+	return detail::tvec3<genIUType>(
 
+		extractField(value, first[0], count[0]),
 
+		extractField(value, first[1], count[1]),
 
+		extractField(value, first[2], count[2]));
 
+}
 
+
 
+template <typename genIUType, typename sizeType>
 
+GLM_FUNC_QUALIFIER detail::tvec4<genIUType> extractField
 
+(
 
+	genIUType const & value, 
+	detail::tvec4<sizeType> const & first, 
+	detail::tvec4<sizeType> const & count
 
+)
 
+{
 
+	return detail::tvec4<genIUType>(
 
+		extractField(value, first[0], count[0]),
 
+		extractField(value, first[1], count[1]),
 
+		extractField(value, first[2], count[2]),
 
+		extractField(value, first[3], count[3]));
 
+}
 
+
 
+// lowestBit
 
+template <typename genType>
 
+GLM_FUNC_QUALIFIER int lowestBit
 
+(
 
+	genType const & Value
 
+)
 
+{
 
+	assert(Value != genType(0)); // not valid call
 
+
 
+	genType Bit;
 
+	for(Bit = genType(0); !(Value & (1 << Bit)); ++Bit){}
 
+	return Bit;
 
+}
 
+
 
+template <typename valType>
 
+GLM_FUNC_QUALIFIER detail::tvec2<int> lowestBit
 
+(
 
+	detail::tvec2<valType> const & value
 
+)
 
+{
 
+	return detail::tvec2<int>(
 
+		lowestBit(value[0]),
 
+		lowestBit(value[1]));
 
+}
 
+
 
+template <typename valType>
 
+GLM_FUNC_QUALIFIER detail::tvec3<int> lowestBit
 
+(
 
+	detail::tvec3<valType> const & value
 
+)
 
+{
 
+	return detail::tvec3<int>(
 
+		lowestBit(value[0]),
 
+		lowestBit(value[1]),
 
+		lowestBit(value[2]));
 
+}
 
+
 
+template <typename valType>
 
+GLM_FUNC_QUALIFIER detail::tvec4<int> lowestBit
 
+(
 
+	detail::tvec4<valType> const & value
 
+)
 
+{
 
+	return detail::tvec4<int>(
 
+		lowestBit(value[0]),
 
+		lowestBit(value[1]),
 
+		lowestBit(value[2]),
 
+		lowestBit(value[3]));
 
+}
 
+
 
+// highestBit
 
+template <typename genType>
 
+GLM_FUNC_QUALIFIER int highestBit
 
+(
 
+	genType const & value
 
+)
 
+{
 
+	assert(value != genType(0)); // not valid call
 
+
 
+	genType bit = genType(-1);
 
+	for(genType tmp = value; tmp; tmp >>= 1, ++bit){}
 
+	return bit;
 
+}
 
+
 
+//template <>
 
+//GLM_FUNC_QUALIFIER int highestBit<int>
 
+//(
 
+//	int value
 
+//)
 
+//{
 
+//	int bit = -1;
 
+//	for(int tmp = value; tmp; tmp >>= 1, ++bit);
 
+//	return bit;
 
+//}
 
+
 
+template <typename valType>
 
+GLM_FUNC_QUALIFIER detail::tvec2<int> highestBit
 
+(
 
+	detail::tvec2<valType> const & value
 
+)
 
+{
 
+	return detail::tvec2<int>(
 
+		highestBit(value[0]),
 
+		highestBit(value[1]));
 
+}
 
+
 
+template <typename valType>
 
+GLM_FUNC_QUALIFIER detail::tvec3<int> highestBit
 
+(
 
+	detail::tvec3<valType> const & value
 
+)
 
+{
 
+	return detail::tvec3<int>(
 
+		highestBit(value[0]),
 
+		highestBit(value[1]),
 
+		highestBit(value[2]));
 
+}
 
+
 
+template <typename valType>
 
+GLM_FUNC_QUALIFIER detail::tvec4<int> highestBit
 
+(
 
+	detail::tvec4<valType> const & value
 
+)
 
+{
 
+	return detail::tvec4<int>(
 
+		highestBit(value[0]),
 
+		highestBit(value[1]),
 
+		highestBit(value[2]),
 
+		highestBit(value[3]));
 
+}
 
+
 
+// highestBitValue
 
+template <typename genType>
 
+GLM_FUNC_QUALIFIER genType highestBitValue
 
+(
 
+	genType const & value
 
+)
 
+{
 
+	genType tmp = value;
 
+	genType result = genType(0);
 
+	while(tmp)
 
+	{
 
+		result = (tmp & (~tmp + 1)); // grab lowest bit
 
+		tmp &= ~result; // clear lowest bit
 
+	}
 
+	return result;
 
+}
 
+
 
+template <typename valType>
 
+GLM_FUNC_QUALIFIER detail::tvec2<int> highestBitValue
 
+(
 
+	detail::tvec2<valType> const & value
 
+)
 
+{
 
+	return detail::tvec2<int>(
 
+		highestBitValue(value[0]),
 
+		highestBitValue(value[1]));
 
+}
 
+
 
+template <typename valType>
 
+GLM_FUNC_QUALIFIER detail::tvec3<int> highestBitValue
 
+(
 
+	detail::tvec3<valType> const & value
 
+)
 
+{
 
+	return detail::tvec3<int>(
 
+		highestBitValue(value[0]),
 
+		highestBitValue(value[1]),
 
+		highestBitValue(value[2]));
 
+}
 
+
 
+template <typename valType>
 
+GLM_FUNC_QUALIFIER detail::tvec4<int> highestBitValue
 
+(
 
+	detail::tvec4<valType> const & value
 
+)
 
+{
 
+	return detail::tvec4<int>(
 
+		highestBitValue(value[0]),
 
+		highestBitValue(value[1]),
 
+		highestBitValue(value[2]),
 
+		highestBitValue(value[3]));
 
+}
 
+
 
+// isPowerOfTwo
 
+template <typename genType>
 
+GLM_FUNC_QUALIFIER bool isPowerOfTwo(genType const & Value)
 
+{
 
+	//detail::If<std::numeric_limits<genType>::is_signed>::apply(abs, Value);
 
+	//return !(Value & (Value - 1));
 
+
 
+    // For old complier?
 
+	genType Result = Value;
 
+	if(std::numeric_limits<genType>::is_signed)
 
+		Result = abs(Result);
 
+	return !(Result & (Result - 1));
 
+}
 
+
 
+template <typename valType>
 
+GLM_FUNC_QUALIFIER detail::tvec2<bool> isPowerOfTwo
 
+(
 
+	detail::tvec2<valType> const & value
 
+)
 
+{
 
+	return detail::tvec2<bool>(
 
+		isPowerOfTwo(value[0]),
 
+		isPowerOfTwo(value[1]));
 
+}
 
+
 
+template <typename valType>
 
+GLM_FUNC_QUALIFIER detail::tvec3<bool> isPowerOfTwo
 
+(
 
+	detail::tvec3<valType> const & value
 
+)
 
+{
 
+	return detail::tvec3<bool>(
 
+		isPowerOfTwo(value[0]),
 
+		isPowerOfTwo(value[1]),
 
+		isPowerOfTwo(value[2]));
 
+}
 
+
 
+template <typename valType>
 
+GLM_FUNC_QUALIFIER detail::tvec4<bool> isPowerOfTwo
 
+(
 
+	detail::tvec4<valType> const & value
 
+)
 
+{
 
+	return detail::tvec4<bool>(
 
+		isPowerOfTwo(value[0]),
 
+		isPowerOfTwo(value[1]),
 
+		isPowerOfTwo(value[2]),
 
+		isPowerOfTwo(value[3]));
 
+}
 
+
 
+// powerOfTwoAbove
 
+template <typename genType>
 
+GLM_FUNC_QUALIFIER genType powerOfTwoAbove(genType const & value)
 
+{
 
+	return isPowerOfTwo(value) ? value : highestBitValue(value) << 1;
 
+}
 
+
 
+template <typename valType>
 
+GLM_FUNC_QUALIFIER detail::tvec2<valType> powerOfTwoAbove
 
+(
 
+	detail::tvec2<valType> const & value
 
+)
 
+{
 
+	return detail::tvec2<valType>(
 
+		powerOfTwoAbove(value[0]),
 
+		powerOfTwoAbove(value[1]));
 
+}
 
+
 
+template <typename valType>
 
+GLM_FUNC_QUALIFIER detail::tvec3<valType> powerOfTwoAbove
 
+(
 
+	detail::tvec3<valType> const & value
 
+)
 
+{
 
+	return detail::tvec3<valType>(
 
+		powerOfTwoAbove(value[0]),
 
+		powerOfTwoAbove(value[1]),
 
+		powerOfTwoAbove(value[2]));
 
+}
 
+
 
+template <typename valType>
 
+GLM_FUNC_QUALIFIER detail::tvec4<valType> powerOfTwoAbove
 
+(
 
+	detail::tvec4<valType> const & value
 
+)
 
+{
 
+	return detail::tvec4<valType>(
 
+		powerOfTwoAbove(value[0]),
 
+		powerOfTwoAbove(value[1]),
 
+		powerOfTwoAbove(value[2]),
 
+		powerOfTwoAbove(value[3]));
 
+}
 
+
 
+// powerOfTwoBelow
 
+template <typename genType>
 
+GLM_FUNC_QUALIFIER genType powerOfTwoBelow
 
+(
 
+	genType const & value
 
+)
 
+{
 
+	return isPowerOfTwo(value) ? value : highestBitValue(value);
 
+}
 
+
 
+template <typename valType>
 
+GLM_FUNC_QUALIFIER detail::tvec2<valType> powerOfTwoBelow
 
+(
 
+	detail::tvec2<valType> const & value
 
+)
 
+{
 
+	return detail::tvec2<valType>(
 
+		powerOfTwoBelow(value[0]),
 
+		powerOfTwoBelow(value[1]));
 
+}
 
+
 
+template <typename valType>
 
+GLM_FUNC_QUALIFIER detail::tvec3<valType> powerOfTwoBelow
 
+(
 
+	detail::tvec3<valType> const & value
 
+)
 
+{
 
+	return detail::tvec3<valType>(
 
+		powerOfTwoBelow(value[0]),
 
+		powerOfTwoBelow(value[1]),
 
+		powerOfTwoBelow(value[2]));
 
+}
 
+
 
+template <typename valType>
 
+GLM_FUNC_QUALIFIER detail::tvec4<valType> powerOfTwoBelow
 
+(
 
+	detail::tvec4<valType> const & value
 
+)
 
+{
 
+	return detail::tvec4<valType>(
 
+		powerOfTwoBelow(value[0]),
 
+		powerOfTwoBelow(value[1]),
 
+		powerOfTwoBelow(value[2]),
 
+		powerOfTwoBelow(value[3]));
 
+}
 
+
 
+// powerOfTwoNearest
 
+template <typename genType>
 
+GLM_FUNC_QUALIFIER genType powerOfTwoNearest
 
+(
 
+	genType const & value
 
+)
 
+{
 
+	if(isPowerOfTwo(value))
 
+		return value;
 
+
 
+	genType prev = highestBitValue(value);
 
+	genType next = prev << 1;
 
+	return (next - value) < (value - prev) ? next : prev;
 
+}
 
+
 
+template <typename valType>
 
+GLM_FUNC_QUALIFIER detail::tvec2<valType> powerOfTwoNearest
 
+(
 
+	detail::tvec2<valType> const & value
 
+)
 
+{
 
+	return detail::tvec2<valType>(
 
+		powerOfTwoNearest(value[0]),
 
+		powerOfTwoNearest(value[1]));
 
+}
 
+
 
+template <typename valType>
 
+GLM_FUNC_QUALIFIER detail::tvec3<valType> powerOfTwoNearest
 
+(
 
+	detail::tvec3<valType> const & value
 
+)
 
+{
 
+	return detail::tvec3<valType>(
 
+		powerOfTwoNearest(value[0]),
 
+		powerOfTwoNearest(value[1]),
 
+		powerOfTwoNearest(value[2]));
 
+}
 
+
 
+template <typename valType>
 
+GLM_FUNC_QUALIFIER detail::tvec4<valType> powerOfTwoNearest
 
+(
 
+	detail::tvec4<valType> const & value
 
+)
 
+{
 
+	return detail::tvec4<valType>(
 
+		powerOfTwoNearest(value[0]),
 
+		powerOfTwoNearest(value[1]),
 
+		powerOfTwoNearest(value[2]),
 
+		powerOfTwoNearest(value[3]));
 
+}
 
+
 
+template <typename genType>
 
+GLM_FUNC_QUALIFIER genType bitRevert(genType const & In)
 
+{
 
+	GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_integer, "'bitRevert' only accept integer values");
 
+
 
+	genType Out = 0;
 
+	std::size_t BitSize = sizeof(genType) * 8;
 
+	for(std::size_t i = 0; i < BitSize; ++i)
 
+		if(In & (genType(1) << i))
 
+			Out |= genType(1) << (BitSize - 1 - i);
 
+	return Out;
 
+}
 
+
 
+template <typename valType>
 
+GLM_FUNC_QUALIFIER detail::tvec2<valType> bitRevert
 
+(
 
+	detail::tvec2<valType> const & Value
 
+)
 
+{
 
+	return detail::tvec2<valType>(
 
+		bitRevert(Value[0]),
 
+		bitRevert(Value[1]));
 
+}
 
+
 
+template <typename valType>
 
+GLM_FUNC_QUALIFIER detail::tvec3<valType> bitRevert
 
+(
 
+	detail::tvec3<valType> const & Value
 
+)
 
+{
 
+	return detail::tvec3<valType>(
 
+		bitRevert(Value[0]),
 
+		bitRevert(Value[1]),
 
+		bitRevert(Value[2]));
 
+}
 
+
 
+template <typename valType>
 
+GLM_FUNC_QUALIFIER detail::tvec4<valType> bitRevert
 
+(
 
+	detail::tvec4<valType> const & Value
 
+)
 
+{
 
+	return detail::tvec4<valType>(
 
+		bitRevert(Value[0]),
 
+		bitRevert(Value[1]),
 
+		bitRevert(Value[2]),
 
+		bitRevert(Value[3]));
 
+}
 
+
 
+template <typename genType>
 
+GLM_FUNC_QUALIFIER genType bitRotateRight(genType const & In, std::size_t Shift)
 
+{
 
+	GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_integer, "'bitRotateRight' only accept integer values");
 
+
 
+	std::size_t BitSize = sizeof(genType) * 8;
 
+	return (In << Shift) | (In >> (BitSize - Shift));
 
+}
 
+
 
+template <typename valType>
 
+GLM_FUNC_QUALIFIER detail::tvec2<valType> bitRotateRight
 
+(
 
+	detail::tvec2<valType> const & Value, 
+	std::size_t Shift
 
+)
 
+{
 
+	return detail::tvec2<valType>(
 
+		bitRotateRight(Value[0], Shift),
 
+		bitRotateRight(Value[1], Shift));
 
+}
 
+
 
+template <typename valType>
 
+GLM_FUNC_QUALIFIER detail::tvec3<valType> bitRotateRight
 
+(
 
+	detail::tvec3<valType> const & Value, 
+	std::size_t Shift
 
+)
 
+{
 
+	return detail::tvec3<valType>(
 
+		bitRotateRight(Value[0], Shift),
 
+		bitRotateRight(Value[1], Shift),
 
+		bitRotateRight(Value[2], Shift));
 
+}
 
+
 
+template <typename valType>
 
+GLM_FUNC_QUALIFIER detail::tvec4<valType> bitRotateRight
 
+(
 
+	detail::tvec4<valType> const & Value, 
+	std::size_t Shift
 
+)
 
+{
 
+	return detail::tvec4<valType>(
 
+		bitRotateRight(Value[0], Shift),
 
+		bitRotateRight(Value[1], Shift),
 
+		bitRotateRight(Value[2], Shift),
 
+		bitRotateRight(Value[3], Shift));
 
+}
 
+
 
+template <typename genType>
 
+GLM_FUNC_QUALIFIER genType bitRotateLeft(genType const & In, std::size_t Shift)
 
+{
 
+	GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_integer, "'bitRotateLeft' only accept integer values");
 
+
 
+	std::size_t BitSize = sizeof(genType) * 8;
 
+	return (In >> Shift) | (In << (BitSize - Shift));
 
+}
 
+
 
+template <typename valType>
 
+GLM_FUNC_QUALIFIER detail::tvec2<valType> bitRotateLeft
 
+(
 
+	detail::tvec2<valType> const & Value, 
+	std::size_t Shift
 
+)
 
+{
 
+	return detail::tvec2<valType>(
 
+		bitRotateLeft(Value[0], Shift),
 
+		bitRotateLeft(Value[1], Shift));
 
+}
 
+
 
+template <typename valType>
 
+GLM_FUNC_QUALIFIER detail::tvec3<valType> bitRotateLeft
 
+(
 
+	detail::tvec3<valType> const & Value, 
+	std::size_t Shift
 
+)
 
+{
 
+	return detail::tvec3<valType>(
 
+		bitRotateLeft(Value[0], Shift),
 
+		bitRotateLeft(Value[1], Shift),
 
+		bitRotateLeft(Value[2], Shift));
 
+}
 
+
 
+template <typename valType>
 
+GLM_FUNC_QUALIFIER detail::tvec4<valType> bitRotateLeft
 
+(
 
+	detail::tvec4<valType> const & Value, 
+	std::size_t Shift
 
+)
 
+{
 
+	return detail::tvec4<valType>(
 
+		bitRotateLeft(Value[0], Shift),
 
+		bitRotateLeft(Value[1], Shift),
 
+		bitRotateLeft(Value[2], Shift),
 
+		bitRotateLeft(Value[3], Shift));
 
+}
 
+
 
+template <typename genIUType>
 
+GLM_FUNC_QUALIFIER genIUType fillBitfieldWithOne
 
+(
 
+	genIUType const & Value,
 
+	int const & FromBit, 
+	int const & ToBit
 
+)
 
+{
 
+	assert(FromBit <= ToBit);
 
+	assert(ToBit <= sizeof(genIUType) * std::size_t(8));
 
+
 
+	genIUType Result = Value;
 
+	for(std::size_t i = 0; i <= ToBit; ++i)
 
+		Result |= (1 << i);
 
+	return Result;
 
+}
 
+
 
+template <typename genIUType>
 
+GLM_FUNC_QUALIFIER genIUType fillBitfieldWithZero
 
+(
 
+	genIUType const & Value,
 
+	int const & FromBit, 
+	int const & ToBit
 
+)
 
+{
 
+	assert(FromBit <= ToBit);
 
+	assert(ToBit <= sizeof(genIUType) * std::size_t(8));
 
+
 
+	genIUType Result = Value;
 
+	for(std::size_t i = 0; i <= ToBit; ++i)
 
+		Result &= ~(1 << i);
 
+	return Result;
 
+}
 
+
 
+}//namespace glm

+ 6 - 6
glm/gtx/gradient_paint.hpp
View File 

@@ -55,18 +55,18 @@ namespace glm
 
 	/// @see - gtx_gradient_paint
 
 	/// @see - gtx_gradient_paint
 
 	template <typename valType>
 
 	template <typename valType>
 
 	valType radialGradient(
 
 	valType radialGradient(
 
-		glm::detail::tvec2<valType> const & Center,
 
+		detail::tvec2<valType> const & Center,
 
 		valType const & Radius,
 
 		valType const & Radius,
 
-		glm::detail::tvec2<valType> const & Focal,
 
-		glm::detail::tvec2<valType> const & Position);
 
+		detail::tvec2<valType> const & Focal,
 
+		detail::tvec2<valType> const & Position);
 
 
 
 	/// Return a color from a linear gradient.
 
 	/// Return a color from a linear gradient.
 
 	/// @see - gtx_gradient_paint
 
 	/// @see - gtx_gradient_paint
 
 	template <typename valType>
 
 	template <typename valType>
 
 	valType linearGradient(
 
 	valType linearGradient(
 
-		glm::detail::tvec2<valType> const & Point0,
 
-		glm::detail::tvec2<valType> const & Point1,
 
-		glm::detail::tvec2<valType> const & Position);
 
+		detail::tvec2<valType> const & Point0,
 
+		detail::tvec2<valType> const & Point1,
 
+		detail::tvec2<valType> const & Position);
 
 
 
 	/// @}
 
 	/// @}
 
 }// namespace glm
 
 }// namespace glm

+ 19 - 15
glm/gtx/gradient_paint.inl
View File 

@@ -10,30 +10,34 @@
 
 namespace glm{
 
 namespace glm{
 
 
 
 template <typename valType>
 
 template <typename valType>
 
-valType radialGradient(
 
-	glm::detail::tvec2<valType> const & Center,
 
+valType radialGradient
 
+(
 
+	detail::tvec2<valType> const & Center,
 
 	valType const & Radius,
 
 	valType const & Radius,
 
-	glm::detail::tvec2<valType> const & Focal,
 
-	glm::detail::tvec2<valType> const & Position)
 
+	detail::tvec2<valType> const & Focal,
 
+	detail::tvec2<valType> const & Position
 
+)
 
 {
 
 {
 
-	glm::detail::tvec2<valType> F = Focal - Center;
 
-	glm::detail::tvec2<valType> D = Position - Focal;
 
-	valType Radius2 = gtx::pow2(Radius);
 
-	valType Fx2 = gtx::pow2(F.x);
 
-	valType Fy2 = gtx::pow2(F.y);
 
+	detail::tvec2<valType> F = Focal - Center;
 
+	detail::tvec2<valType> D = Position - Focal;
 
+	valType Radius2 = pow2(Radius);
 
+	valType Fx2 = pow2(F.x);
 
+	valType Fy2 = pow2(F.y);
 
 
 
-	valType Numerator = (D.x * F.x + D.y * F.y) + glm::sqrt(Radius2 * (gtx::pow2(D.x) + gtx::pow2(D.y)) - gtx::pow2(D.x * F.y - D.y * F.x));
 
+	valType Numerator = (D.x * F.x + D.y * F.y) + sqrt(Radius2 * (pow2(D.x) + pow2(D.y)) - pow2(D.x * F.y - D.y * F.x));
 
 	valType Denominator = Radius2 - (Fx2 + Fy2);
 
 	valType Denominator = Radius2 - (Fx2 + Fy2);
 
 	return Numerator / Denominator;
 
 	return Numerator / Denominator;
 
 }
 
 }
 
 
 
 template <typename valType>
 
 template <typename valType>
 
-valType linearGradient(
 
-	glm::detail::tvec2<valType> const & Point0,
 
-	glm::detail::tvec2<valType> const & Point1,
 
-	glm::detail::tvec2<valType> const & Position)
 
+valType linearGradient
 
+(
 
+	detail::tvec2<valType> const & Point0,
 
+	detail::tvec2<valType> const & Point1,
 
+	detail::tvec2<valType> const & Position
 
+)
 
 {
 
 {
 
-	glm::detail::tvec2<valType> Dist = Point1 - Point0;
 
+	detail::tvec2<valType> Dist = Point1 - Point0;
 
 	return (Dist.x * (Position.x - Point0.x) + Dist.y * (Position.y - Point0.y)) / glm::dot(Dist, Dist);
 
 	return (Dist.x * (Position.x - Point0.x) + Dist.y * (Position.y - Point0.y)) / glm::dot(Dist, Dist);
 
 }
 
 }

+ 30 - 1
glm/gtx/integer.hpp
View File 

@@ -22,7 +22,7 @@
 
 ///
 
 ///
 
 /// @ref gtx_integer
 
 /// @ref gtx_integer
 
 /// @file glm/gtx/integer.hpp
 
 /// @file glm/gtx/integer.hpp
 
-/// @date 2005-12-24 / 2011-06-07
 
+/// @date 2005-12-24 / 2011-10-13
 
 /// @author Christophe Riccio
 
 /// @author Christophe Riccio
 
 ///
 
 ///
 
 /// @see core (dependence)
 
 /// @see core (dependence)
 
@@ -58,6 +58,15 @@ namespace glm
 
 	//! From GLM_GTX_integer extension.
 
 	//! From GLM_GTX_integer extension.
 
 	int sqrt(int x);
 
 	int sqrt(int x);
 
 
 
+	//! Returns the log2 of x. Can be reliably using to compute mipmap count from the texture size.
 
+	//! From GLM_GTX_integer extension.
 
+	template <typename genType>
 
+	genType log2(genType const & x);
 
+
 
+	//! Returns the floor log2 of x.
 
+	//! From GLM_GTX_integer extension.
 
+	unsigned int floor_log2(unsigned int x);
 
+
 
 	//! Modulus. Returns x - y * floor(x / y) for each component in x using the floating point value y.
 
 	//! Modulus. Returns x - y * floor(x / y) for each component in x using the floating point value y.
 
 	//! From GLM_GTX_integer extension.
 
 	//! From GLM_GTX_integer extension.
 
 	int mod(int x, int y);
 
 	int mod(int x, int y);
 
@@ -67,6 +76,26 @@ namespace glm
 
 	template <typename genType> 
 	template <typename genType> 
 	genType factorial(genType const & x);
 
 	genType factorial(genType const & x);
 
 
 
+	//! 32bit signed integer. 
+	//! From GLM_GTX_integer extension.
 
+	typedef signed int					sint;
 
+
 
+	//! Returns x raised to the y power.
 
+	//! From GLM_GTX_integer extension.
 
+	uint pow(uint x, uint y);
 
+
 
+	//! Returns the positive square root of x. 
+	//! From GLM_GTX_integer extension.
 
+	uint sqrt(uint x);
 
+
 
+	//! Modulus. Returns x - y * floor(x / y) for each component in x using the floating point value y.
 
+	//! From GLM_GTX_integer extension.
 
+	uint mod(uint x, uint y);
 
+
 
+	//! Returns the number of leading zeros.
 
+	//! From GLM_GTX_integer extension.
 
+	uint nlz(uint x);
 
+
 
 	/// @}
 
 	/// @}
 
 }//namespace glm
 
 }//namespace glm

+ 115 - 1
glm/gtx/integer.inl
View File 

@@ -2,7 +2,7 @@
 
 // OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
 
 // OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 // Created : 2005-12-24
 
 // Created : 2005-12-24
 
-// Updated : 2006-12-06
 
+// Updated : 2011-10-13
 
 // Licence : This source is under MIT License
 
 // Licence : This source is under MIT License
 
 // File    : glm/gtx/integer.inl
 
 // File    : glm/gtx/integer.inl
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
@@ -37,6 +37,50 @@ GLM_FUNC_QUALIFIER int sqrt(int x)
 
     return CurrentAnswer;
 
     return CurrentAnswer;
 
 }
 
 }
 
 
 
+// Henry Gordon Dietz: http://aggregate.org/MAGIC/
 
+namespace detail
 
+{
 
+	GLM_FUNC_QUALIFIER unsigned int ones32(unsigned int x)
 
+	{
 
+		/* 32-bit recursive reduction using SWAR...
 
+		but first step is mapping 2-bit values
 
+		into sum of 2 1-bit values in sneaky way
 
+		*/
 
+		x -= ((x >> 1) & 0x55555555);
 
+		x = (((x >> 2) & 0x33333333) + (x & 0x33333333));
 
+		x = (((x >> 4) + x) & 0x0f0f0f0f);
 
+		x += (x >> 8);
 
+		x += (x >> 16);
 
+		return(x & 0x0000003f);
 
+	}
 
+
 
+	template <>
 
+	struct compute_log2<float_or_int_value::INT>
 
+	{
 
+		template <typename T>
 
+		T operator() (T const & Value) const
 
+		{
 
+#if(GLM_COMPILER & (GLM_COMPILER_VC | GLM_COMPILER_GCC))
 
+			return Value <= T(1) ? T(0) : T(32) - nlz(Value - T(1));
 
+#else
 
+			return T(32) - nlz(Value - T(1));
 
+#endif
 
+		}
 
+	};
 
+}//namespace detail
 
+
 
+// Henry Gordon Dietz: http://aggregate.org/MAGIC/
 
+unsigned int floor_log2(unsigned int x)
 
+{
 
+	x |= (x >> 1);
 
+	x |= (x >> 2);
 
+	x |= (x >> 4);
 
+	x |= (x >> 8);
 
+	x |= (x >> 16);
 
+
 
+	return(detail::ones32(x) - 1);
 
+}
 
+
 
 // mod
 
 // mod
 
 GLM_FUNC_QUALIFIER int mod(int x, int y)
 
 GLM_FUNC_QUALIFIER int mod(int x, int y)
 
 {
 
 {
 
@@ -84,4 +128,74 @@ GLM_FUNC_QUALIFIER detail::tvec4<valType> factorial(
 
         factorial(x.w));
 
         factorial(x.w));
 
 }
 
 }
 
 
 
+GLM_FUNC_QUALIFIER uint pow(uint x, uint y)
 
+{
 
+    uint result = x;
 
+    for(uint i = 1; i < y; ++i)
 
+        result *= x;
 
+    return result;
 
+}
 
+
 
+GLM_FUNC_QUALIFIER uint sqrt(uint x)
 
+{
 
+    if(x <= 1) return x;
 
+
 
+    uint NextTrial = x >> 1;
 
+    uint CurrentAnswer;
 
+
 
+    do
 
+    {
 
+        CurrentAnswer = NextTrial;
 
+        NextTrial = (NextTrial + x / NextTrial) >> 1;
 
+    } while(NextTrial < CurrentAnswer);
 
+
 
+    return CurrentAnswer;
 
+}
 
+
 
+GLM_FUNC_QUALIFIER uint mod(uint x, uint y)
 
+{
 
+	return x - y * (x / y);
 
+}
 
+
 
+#if(GLM_COMPILER & (GLM_COMPILER_VC | GLM_COMPILER_GCC))
 
+
 
+GLM_FUNC_QUALIFIER unsigned int nlz(unsigned int x) 
+{
 
+	return 31u - findMSB(x);
 
+}
 
+
 
+#else
 
+
 
+// Hackers Delight: http://www.hackersdelight.org/HDcode/nlz.c.txt
 
+GLM_FUNC_QUALIFIER unsigned int nlz(unsigned int x) 
+{
 
+   int y, m, n;
 
+
 
+   y = -int(x >> 16);      // If left half of x is 0,
 
+   m = (y >> 16) & 16;  // set n = 16.  If left half
 
+   n = 16 - m;          // is nonzero, set n = 0 and
 
+   x = x >> m;          // shift x right 16.
 
+                        // Now x is of the form 0000xxxx.
 
+   y = x - 0x100;       // If positions 8-15 are 0,
 
+   m = (y >> 16) & 8;   // add 8 to n and shift x left 8.
 
+   n = n + m;
 
+   x = x << m;
 
+
 
+   y = x - 0x1000;      // If positions 12-15 are 0,
 
+   m = (y >> 16) & 4;   // add 4 to n and shift x left 4.
 
+   n = n + m;
 
+   x = x << m;
 
+
 
+   y = x - 0x4000;      // If positions 14-15 are 0,
 
+   m = (y >> 16) & 2;   // add 2 to n and shift x left 2.
 
+   n = n + m;
 
+   x = x << m;
 
+
 
+   y = x >> 14;         // Set y = 0, 1, 2, or 3.
 
+   m = y & ~(y >> 1);   // Set m = 0, 1, 2, or 2 resp.
 
+   return unsigned(n + 2 - m);
 
+}
 
+
 
+#endif//(GLM_COMPILER)
 
+
 
 }//namespace glm
 
 }//namespace glm

+ 1 - 19
glm/gtx/noise.hpp
View File 

@@ -44,6 +44,7 @@
 
 
 
 // Dependency:
 
 // Dependency:
 
 #include "../glm.hpp"
 
 #include "../glm.hpp"
 
+#include "../gtc/noise.hpp"
 
 
 
 #if(defined(GLM_MESSAGES) && !defined(glm_ext))
 
 #if(defined(GLM_MESSAGES) && !defined(glm_ext))
 
 #	pragma message("GLM: GLM_GTX_noise extension included")
 
 #	pragma message("GLM: GLM_GTX_noise extension included")
 
@@ -54,25 +55,6 @@ namespace glm
 
 	/// @addtogroup gtx_noise
 
 	/// @addtogroup gtx_noise
 
 	/// @{
 
 	/// @{
 
 
 
-	//! Classic perlin noise.
 
-	//! From GLM_GTX_noise extension.
 
-	template <typename T, template<typename> class vecType> 
-    T perlin(
 
-		vecType<T> const & p);
 
-		
-	//! Periodic perlin noise.
 
-	//! From GLM_GTX_noise extension.
 
-	template <typename T, template<typename> class vecType> 
-    T perlin(
 
-		vecType<T> const & p, 
-		vecType<T> const & rep);
 
-
 
-	//! Simplex noise.
 
-	//! From GLM_GTX_noise extension.
 
-	template <typename T, template<typename> class vecType> 
-    T simplex(
 
-		vecType<T> const & p);
 
-
 
 	/// @}
 
 	/// @}
 
 }//namespace glm
 
 }//namespace glm

+ 0 - 832
glm/gtx/noise.inl
View File 

@@ -17,836 +17,4 @@
 
 
 
 namespace glm{
 
 namespace glm{
 
 
 
-template <typename T>
 
-GLM_FUNC_QUALIFIER T mod289(T const & x)
 
-{
 
-	return x - floor(x * T(1.0 / 289.0)) * T(289.0);
 
-}
 
-
 
-template <typename T>
 
-GLM_FUNC_QUALIFIER T permute(T const & x)
 
-{
 
-	return mod289(((x * T(34)) + T(1)) * x);
 
-}
 
-
 
-template <typename T, template<typename> class vecType>
 
-GLM_FUNC_QUALIFIER vecType<T> permute(vecType<T> const & x)
 
-{
 
-	return mod289(((x * T(34)) + T(1)) * x);
 
-}
 
-  
-template <typename T>
 
-GLM_FUNC_QUALIFIER T taylorInvSqrt(T const & r)
 
-{
 
-	return T(1.79284291400159) - T(0.85373472095314) * r;
 
-}
 
-
 
-template <typename T, template<typename> class vecType>
 
-GLM_FUNC_QUALIFIER vecType<T> taylorInvSqrt(vecType<T> const & r)
 
-{
 
-	return T(1.79284291400159) - T(0.85373472095314) * r;
 
-}
 
-
 
-template <typename T, template <typename> class vecType> 
-GLM_FUNC_QUALIFIER vecType<T> fade(vecType<T> const & t) 
-{
 
-	return t * t * t * (t * (t * T(6) - T(15)) + T(10));
 
-}
 
-
 
-template <typename T>
 
-GLM_FUNC_QUALIFIER detail::tvec4<T> grad4(T const & j, detail::tvec4<T> const & ip)
 
-{
 
-	detail::tvec3<T> pXYZ = floor(fract(detail::tvec3<T>(j) * detail::tvec3<T>(ip)) * T(7)) * ip[2] - T(1);
 
-	T pW = T(1.5) - dot(abs(pXYZ), detail::tvec3<T>(1));
 
-	detail::tvec4<T> s = detail::tvec4<T>(lessThan(detail::tvec4<T>(pXYZ, pW), detail::tvec4<T>(0.0)));
 
-	pXYZ = pXYZ + (detail::tvec3<T>(s) * T(2) - T(1)) * s.w; 
-	return detail::tvec4<T>(pXYZ, pW);
 
-}
 
-
 
-// Classic Perlin noise
 
-template <typename T>
 
-GLM_FUNC_QUALIFIER T perlin(detail::tvec2<T> const & P)
 
-{
 
-	detail::tvec4<T> Pi = glm::floor(detail::tvec4<T>(P.x, P.y, P.x, P.y)) + detail::tvec4<T>(0.0, 0.0, 1.0, 1.0);
 
-	detail::tvec4<T> Pf = glm::fract(detail::tvec4<T>(P.x, P.y, P.x, P.y)) - detail::tvec4<T>(0.0, 0.0, 1.0, 1.0);
 
-	Pi = mod(Pi, T(289)); // To avoid truncation effects in permutation
 
-	detail::tvec4<T> ix(Pi.x, Pi.z, Pi.x, Pi.z);
 
-	detail::tvec4<T> iy(Pi.y, Pi.y, Pi.w, Pi.w);
 
-	detail::tvec4<T> fx(Pf.x, Pf.z, Pf.x, Pf.z);
 
-	detail::tvec4<T> fy(Pf.y, Pf.y, Pf.w, Pf.w);
 
-
 
-	detail::tvec4<T> i = glm::permute(glm::permute(ix) + iy);
 
-
 
-	detail::tvec4<T> gx = T(2) * glm::fract(i / T(41)) - T(1);
 
-	detail::tvec4<T> gy = glm::abs(gx) - T(0.5);
 
-	detail::tvec4<T> tx = glm::floor(gx + T(0.5));
 
-	gx = gx - tx;
 
-
 
-	detail::tvec2<T> g00(gx.x, gy.x);
 
-	detail::tvec2<T> g10(gx.y, gy.y);
 
-	detail::tvec2<T> g01(gx.z, gy.z);
 
-	detail::tvec2<T> g11(gx.w, gy.w);
 
-
 
-	detail::tvec4<T> norm = taylorInvSqrt(detail::tvec4<T>(dot(g00, g00), dot(g01, g01), dot(g10, g10), dot(g11, g11)));
 
-	g00 *= norm.x;  
-	g01 *= norm.y;  
-	g10 *= norm.z;  
-	g11 *= norm.w;  
-
 
-	T n00 = dot(g00, detail::tvec2<T>(fx.x, fy.x));
 
-	T n10 = dot(g10, detail::tvec2<T>(fx.y, fy.y));
 
-	T n01 = dot(g01, detail::tvec2<T>(fx.z, fy.z));
 
-	T n11 = dot(g11, detail::tvec2<T>(fx.w, fy.w));
 
-
 
-	detail::tvec2<T> fade_xy = fade(detail::tvec2<T>(Pf.x, Pf.y));
 
-	detail::tvec2<T> n_x = mix(detail::tvec2<T>(n00, n01), detail::tvec2<T>(n10, n11), fade_xy.x);
 
-	T n_xy = mix(n_x.x, n_x.y, fade_xy.y);
 
-	return T(2.3) * n_xy;
 
-}
 
-
 
-// Classic Perlin noise
 
-template <typename T>
 
-GLM_FUNC_QUALIFIER T perlin(detail::tvec3<T> const & P)
 
-{
 
-	detail::tvec3<T> Pi0 = floor(P); // Integer part for indexing
 
-	detail::tvec3<T> Pi1 = Pi0 + T(1); // Integer part + 1
 
-	Pi0 = mod289(Pi0);
 
-	Pi1 = mod289(Pi1);
 
-	detail::tvec3<T> Pf0 = fract(P); // Fractional part for interpolation
 
-	detail::tvec3<T> Pf1 = Pf0 - T(1); // Fractional part - 1.0
 
-	detail::tvec4<T> ix(Pi0.x, Pi1.x, Pi0.x, Pi1.x);
 
-	detail::tvec4<T> iy = detail::tvec4<T>(detail::tvec2<T>(Pi0.y), detail::tvec2<T>(Pi1.y));
 
-	detail::tvec4<T> iz0(Pi0.z);
 
-	detail::tvec4<T> iz1(Pi1.z);
 
-
 
-	detail::tvec4<T> ixy = permute(permute(ix) + iy);
 
-	detail::tvec4<T> ixy0 = permute(ixy + iz0);
 
-	detail::tvec4<T> ixy1 = permute(ixy + iz1);
 
-
 
-	detail::tvec4<T> gx0 = ixy0 * T(1.0 / 7.0);
 
-	detail::tvec4<T> gy0 = fract(floor(gx0) * T(1.0 / 7.0)) - T(0.5);
 
-	gx0 = fract(gx0);
 
-	detail::tvec4<T> gz0 = detail::tvec4<T>(0.5) - abs(gx0) - abs(gy0);
 
-	detail::tvec4<T> sz0 = step(gz0, detail::tvec4<T>(0.0));
 
-	gx0 -= sz0 * (step(T(0), gx0) - T(0.5));
 
-	gy0 -= sz0 * (step(T(0), gy0) - T(0.5));
 
-
 
-	detail::tvec4<T> gx1 = ixy1 * T(1.0 / 7.0);
 
-	detail::tvec4<T> gy1 = fract(floor(gx1) * T(1.0 / 7.0)) - T(0.5);
 
-	gx1 = fract(gx1);
 
-	detail::tvec4<T> gz1 = detail::tvec4<T>(0.5) - abs(gx1) - abs(gy1);
 
-	detail::tvec4<T> sz1 = step(gz1, detail::tvec4<T>(0.0));
 
-	gx1 -= sz1 * (step(T(0), gx1) - T(0.5));
 
-	gy1 -= sz1 * (step(T(0), gy1) - T(0.5));
 
-
 
-	detail::tvec3<T> g000(gx0.x, gy0.x, gz0.x);
 
-	detail::tvec3<T> g100(gx0.y, gy0.y, gz0.y);
 
-	detail::tvec3<T> g010(gx0.z, gy0.z, gz0.z);
 
-	detail::tvec3<T> g110(gx0.w, gy0.w, gz0.w);
 
-	detail::tvec3<T> g001(gx1.x, gy1.x, gz1.x);
 
-	detail::tvec3<T> g101(gx1.y, gy1.y, gz1.y);
 
-	detail::tvec3<T> g011(gx1.z, gy1.z, gz1.z);
 
-	detail::tvec3<T> g111(gx1.w, gy1.w, gz1.w);
 
-
 
-	detail::tvec4<T> norm0 = taylorInvSqrt(detail::tvec4<T>(dot(g000, g000), dot(g010, g010), dot(g100, g100), dot(g110, g110)));
 
-	g000 *= norm0.x;
 
-	g010 *= norm0.y;
 
-	g100 *= norm0.z;
 
-	g110 *= norm0.w;
 
-	detail::tvec4<T> norm1 = taylorInvSqrt(detail::tvec4<T>(dot(g001, g001), dot(g011, g011), dot(g101, g101), dot(g111, g111)));
 
-	g001 *= norm1.x;
 
-	g011 *= norm1.y;
 
-	g101 *= norm1.z;
 
-	g111 *= norm1.w;
 
-
 
-	T n000 = dot(g000, Pf0);
 
-	T n100 = dot(g100, detail::tvec3<T>(Pf1.x, Pf0.y, Pf0.z));
 
-	T n010 = dot(g010, detail::tvec3<T>(Pf0.x, Pf1.y, Pf0.z));
 
-	T n110 = dot(g110, detail::tvec3<T>(Pf1.x, Pf1.y, Pf0.z));
 
-	T n001 = dot(g001, detail::tvec3<T>(Pf0.x, Pf0.y, Pf1.z));
 
-	T n101 = dot(g101, detail::tvec3<T>(Pf1.x, Pf0.y, Pf1.z));
 
-	T n011 = dot(g011, detail::tvec3<T>(Pf0.x, Pf1.y, Pf1.z));
 
-	T n111 = dot(g111, Pf1);
 
-
 
-	detail::tvec3<T> fade_xyz = fade(Pf0);
 
-	detail::tvec4<T> n_z = mix(detail::tvec4<T>(n000, n100, n010, n110), detail::tvec4<T>(n001, n101, n011, n111), fade_xyz.z);
 
-	detail::tvec2<T> n_yz = mix(detail::tvec2<T>(n_z.x, n_z.y), detail::tvec2<T>(n_z.z, n_z.w), fade_xyz.y);
 
-	T n_xyz = mix(n_yz.x, n_yz.y, fade_xyz.x); 
-	return T(2.2) * n_xyz;
 
-}
 
-/*
 
-// Classic Perlin noise
 
-template <typename T>
 
-GLM_FUNC_QUALIFIER T perlin(detail::tvec3<T> const & P)
 
-{
 
-	detail::tvec3<T> Pi0 = floor(P); // Integer part for indexing
 
-	detail::tvec3<T> Pi1 = Pi0 + T(1); // Integer part + 1
 
-	Pi0 = mod(Pi0, T(289));
 
-	Pi1 = mod(Pi1, T(289));
 
-	detail::tvec3<T> Pf0 = fract(P); // Fractional part for interpolation
 
-	detail::tvec3<T> Pf1 = Pf0 - T(1); // Fractional part - 1.0
 
-	detail::tvec4<T> ix(Pi0.x, Pi1.x, Pi0.x, Pi1.x);
 
-	detail::tvec4<T> iy(Pi0.y, Pi0.y, Pi1.y, Pi1.y);
 
-	detail::tvec4<T> iz0(Pi0.z);
 
-	detail::tvec4<T> iz1(Pi1.z);
 
-
 
-	detail::tvec4<T> ixy = permute(permute(ix) + iy);
 
-	detail::tvec4<T> ixy0 = permute(ixy + iz0);
 
-	detail::tvec4<T> ixy1 = permute(ixy + iz1);
 
-
 
-	detail::tvec4<T> gx0 = ixy0 / T(7);
 
-	detail::tvec4<T> gy0 = fract(floor(gx0) / T(7)) - T(0.5);
 
-	gx0 = fract(gx0);
 
-	detail::tvec4<T> gz0 = detail::tvec4<T>(0.5) - abs(gx0) - abs(gy0);
 
-	detail::tvec4<T> sz0 = step(gz0, detail::tvec4<T>(0.0));
 
-	gx0 -= sz0 * (step(0.0, gx0) - T(0.5));
 
-	gy0 -= sz0 * (step(0.0, gy0) - T(0.5));
 
-
 
-	detail::tvec4<T> gx1 = ixy1 / T(7);
 
-	detail::tvec4<T> gy1 = fract(floor(gx1) / T(7)) - T(0.5);
 
-	gx1 = fract(gx1);
 
-	detail::tvec4<T> gz1 = detail::tvec4<T>(0.5) - abs(gx1) - abs(gy1);
 
-	detail::tvec4<T> sz1 = step(gz1, detail::tvec4<T>(0.0));
 
-	gx1 -= sz1 * (step(T(0), gx1) - T(0.5));
 
-	gy1 -= sz1 * (step(T(0), gy1) - T(0.5));
 
-
 
-	detail::tvec3<T> g000(gx0.x, gy0.x, gz0.x);
 
-	detail::tvec3<T> g100(gx0.y, gy0.y, gz0.y);
 
-	detail::tvec3<T> g010(gx0.z, gy0.z, gz0.z);
 
-	detail::tvec3<T> g110(gx0.w, gy0.w, gz0.w);
 
-	detail::tvec3<T> g001(gx1.x, gy1.x, gz1.x);
 
-	detail::tvec3<T> g101(gx1.y, gy1.y, gz1.y);
 
-	detail::tvec3<T> g011(gx1.z, gy1.z, gz1.z);
 
-	detail::tvec3<T> g111(gx1.w, gy1.w, gz1.w);
 
-
 
-	detail::tvec4<T> norm0 = taylorInvSqrt(detail::tvec4<T>(dot(g000, g000), dot(g010, g010), dot(g100, g100), dot(g110, g110)));
 
-	g000 *= norm0.x;
 
-	g010 *= norm0.y;
 
-	g100 *= norm0.z;
 
-	g110 *= norm0.w;
 
-	detail::tvec4<T> norm1 = taylorInvSqrt(detail::tvec4<T>(dot(g001, g001), dot(g011, g011), dot(g101, g101), dot(g111, g111)));
 
-	g001 *= norm1.x;
 
-	g011 *= norm1.y;
 
-	g101 *= norm1.z;
 
-	g111 *= norm1.w;
 
-
 
-	T n000 = dot(g000, Pf0);
 
-	T n100 = dot(g100, detail::tvec3<T>(Pf1.x, Pf0.y, Pf0.z));
 
-	T n010 = dot(g010, detail::tvec3<T>(Pf0.x, Pf1.y, Pf0.z));
 
-	T n110 = dot(g110, detail::tvec3<T>(Pf1.x, Pf1.y, Pf0.z));
 
-	T n001 = dot(g001, detail::tvec3<T>(Pf0.x, Pf0.y, Pf1.z));
 
-	T n101 = dot(g101, detail::tvec3<T>(Pf1.x, Pf0.y, Pf1.z));
 
-	T n011 = dot(g011, detail::tvec3<T>(Pf0.x, Pf1.y, Pf1.z));
 
-	T n111 = dot(g111, Pf1);
 
-
 
-	detail::tvec3<T> fade_xyz = fade(Pf0);
 
-	detail::tvec4<T> n_z = mix(detail::tvec4<T>(n000, n100, n010, n110), detail::tvec4<T>(n001, n101, n011, n111), fade_xyz.z);
 
-	detail::tvec2<T> n_yz = mix(
 
-        detail::tvec2<T>(n_z.x, n_z.y), 
-        detail::tvec2<T>(n_z.z, n_z.w), fade_xyz.y);
 
-	T n_xyz = mix(n_yz.x, n_yz.y, fade_xyz.x); 
-	return T(2.2) * n_xyz;
 
-}
 
-*/
 
-// Classic Perlin noise
 
-template <typename T>
 
-GLM_FUNC_QUALIFIER T perlin(detail::tvec4<T> const & P)
 
-{
 
-	detail::tvec4<T> Pi0 = floor(P); // Integer part for indexing
 
-	detail::tvec4<T> Pi1 = Pi0 + T(1); // Integer part + 1
 
-	Pi0 = mod(Pi0, T(289));
 
-	Pi1 = mod(Pi1, T(289));
 
-	detail::tvec4<T> Pf0 = fract(P); // Fractional part for interpolation
 
-	detail::tvec4<T> Pf1 = Pf0 - T(1); // Fractional part - 1.0
 
-	detail::tvec4<T> ix(Pi0.x, Pi1.x, Pi0.x, Pi1.x);
 
-	detail::tvec4<T> iy(Pi0.y, Pi0.y, Pi1.y, Pi1.y);
 
-	detail::tvec4<T> iz0(Pi0.z);
 
-	detail::tvec4<T> iz1(Pi1.z);
 
-	detail::tvec4<T> iw0(Pi0.w);
 
-	detail::tvec4<T> iw1(Pi1.w);
 
-
 
-	detail::tvec4<T> ixy = permute(permute(ix) + iy);
 
-	detail::tvec4<T> ixy0 = permute(ixy + iz0);
 
-	detail::tvec4<T> ixy1 = permute(ixy + iz1);
 
-	detail::tvec4<T> ixy00 = permute(ixy0 + iw0);
 
-	detail::tvec4<T> ixy01 = permute(ixy0 + iw1);
 
-	detail::tvec4<T> ixy10 = permute(ixy1 + iw0);
 
-	detail::tvec4<T> ixy11 = permute(ixy1 + iw1);
 
-
 
-	detail::tvec4<T> gx00 = ixy00 / T(7);
 
-	detail::tvec4<T> gy00 = floor(gx00) / T(7);
 
-	detail::tvec4<T> gz00 = floor(gy00) / T(6);
 
-	gx00 = fract(gx00) - T(0.5);
 
-	gy00 = fract(gy00) - T(0.5);
 
-	gz00 = fract(gz00) - T(0.5);
 
-	detail::tvec4<T> gw00 = detail::tvec4<T>(0.75) - abs(gx00) - abs(gy00) - abs(gz00);
 
-	detail::tvec4<T> sw00 = step(gw00, detail::tvec4<T>(0.0));
 
-	gx00 -= sw00 * (step(T(0), gx00) - T(0.5));
 
-	gy00 -= sw00 * (step(T(0), gy00) - T(0.5));
 
-
 
-	detail::tvec4<T> gx01 = ixy01 / T(7);
 
-	detail::tvec4<T> gy01 = floor(gx01) / T(7);
 
-	detail::tvec4<T> gz01 = floor(gy01) / T(6);
 
-	gx01 = fract(gx01) - T(0.5);
 
-	gy01 = fract(gy01) - T(0.5);
 
-	gz01 = fract(gz01) - T(0.5);
 
-	detail::tvec4<T> gw01 = detail::tvec4<T>(0.75) - abs(gx01) - abs(gy01) - abs(gz01);
 
-	detail::tvec4<T> sw01 = step(gw01, detail::tvec4<T>(0.0));
 
-	gx01 -= sw01 * (step(T(0), gx01) - T(0.5));
 
-	gy01 -= sw01 * (step(T(0), gy01) - T(0.5));
 
-
 
-	detail::tvec4<T> gx10 = ixy10 / T(7);
 
-	detail::tvec4<T> gy10 = floor(gx10) / T(7);
 
-	detail::tvec4<T> gz10 = floor(gy10) / T(6);
 
-	gx10 = fract(gx10) - T(0.5);
 
-	gy10 = fract(gy10) - T(0.5);
 
-	gz10 = fract(gz10) - T(0.5);
 
-	detail::tvec4<T> gw10 = detail::tvec4<T>(0.75) - abs(gx10) - abs(gy10) - abs(gz10);
 
-	detail::tvec4<T> sw10 = step(gw10, detail::tvec4<T>(0));
 
-	gx10 -= sw10 * (step(T(0), gx10) - T(0.5));
 
-	gy10 -= sw10 * (step(T(0), gy10) - T(0.5));
 
-
 
-	detail::tvec4<T> gx11 = ixy11 / T(7);
 
-	detail::tvec4<T> gy11 = floor(gx11) / T(7);
 
-	detail::tvec4<T> gz11 = floor(gy11) / T(6);
 
-	gx11 = fract(gx11) - T(0.5);
 
-	gy11 = fract(gy11) - T(0.5);
 
-	gz11 = fract(gz11) - T(0.5);
 
-	detail::tvec4<T> gw11 = detail::tvec4<T>(0.75) - abs(gx11) - abs(gy11) - abs(gz11);
 
-	detail::tvec4<T> sw11 = step(gw11, detail::tvec4<T>(0.0));
 
-	gx11 -= sw11 * (step(T(0), gx11) - T(0.5));
 
-	gy11 -= sw11 * (step(T(0), gy11) - T(0.5));
 
-
 
-	detail::tvec4<T> g0000(gx00.x, gy00.x, gz00.x, gw00.x);
 
-	detail::tvec4<T> g1000(gx00.y, gy00.y, gz00.y, gw00.y);
 
-	detail::tvec4<T> g0100(gx00.z, gy00.z, gz00.z, gw00.z);
 
-	detail::tvec4<T> g1100(gx00.w, gy00.w, gz00.w, gw00.w);
 
-	detail::tvec4<T> g0010(gx10.x, gy10.x, gz10.x, gw10.x);
 
-	detail::tvec4<T> g1010(gx10.y, gy10.y, gz10.y, gw10.y);
 
-	detail::tvec4<T> g0110(gx10.z, gy10.z, gz10.z, gw10.z);
 
-	detail::tvec4<T> g1110(gx10.w, gy10.w, gz10.w, gw10.w);
 
-	detail::tvec4<T> g0001(gx01.x, gy01.x, gz01.x, gw01.x);
 
-	detail::tvec4<T> g1001(gx01.y, gy01.y, gz01.y, gw01.y);
 
-	detail::tvec4<T> g0101(gx01.z, gy01.z, gz01.z, gw01.z);
 
-	detail::tvec4<T> g1101(gx01.w, gy01.w, gz01.w, gw01.w);
 
-	detail::tvec4<T> g0011(gx11.x, gy11.x, gz11.x, gw11.x);
 
-	detail::tvec4<T> g1011(gx11.y, gy11.y, gz11.y, gw11.y);
 
-	detail::tvec4<T> g0111(gx11.z, gy11.z, gz11.z, gw11.z);
 
-	detail::tvec4<T> g1111(gx11.w, gy11.w, gz11.w, gw11.w);
 
-
 
-	detail::tvec4<T> norm00 = taylorInvSqrt(detail::tvec4<T>(dot(g0000, g0000), dot(g0100, g0100), dot(g1000, g1000), dot(g1100, g1100)));
 
-	g0000 *= norm00.x;
 
-	g0100 *= norm00.y;
 
-	g1000 *= norm00.z;
 
-	g1100 *= norm00.w;
 
-
 
-	detail::tvec4<T> norm01 = taylorInvSqrt(detail::tvec4<T>(dot(g0001, g0001), dot(g0101, g0101), dot(g1001, g1001), dot(g1101, g1101)));
 
-	g0001 *= norm01.x;
 
-	g0101 *= norm01.y;
 
-	g1001 *= norm01.z;
 
-	g1101 *= norm01.w;
 
-
 
-	detail::tvec4<T> norm10 = taylorInvSqrt(detail::tvec4<T>(dot(g0010, g0010), dot(g0110, g0110), dot(g1010, g1010), dot(g1110, g1110)));
 
-	g0010 *= norm10.x;
 
-	g0110 *= norm10.y;
 
-	g1010 *= norm10.z;
 
-	g1110 *= norm10.w;
 
-
 
-	detail::tvec4<T> norm11 = taylorInvSqrt(detail::tvec4<T>(dot(g0011, g0011), dot(g0111, g0111), dot(g1011, g1011), dot(g1111, g1111)));
 
-	g0011 *= norm11.x;
 
-	g0111 *= norm11.y;
 
-	g1011 *= norm11.z;
 
-	g1111 *= norm11.w;
 
-
 
-	T n0000 = dot(g0000, Pf0);
 
-	T n1000 = dot(g1000, detail::tvec4<T>(Pf1.x, Pf0.y, Pf0.z, Pf0.w));
 
-	T n0100 = dot(g0100, detail::tvec4<T>(Pf0.x, Pf1.y, Pf0.z, Pf0.w));
 
-	T n1100 = dot(g1100, detail::tvec4<T>(Pf1.x, Pf1.y, Pf0.z, Pf0.w));
 
-	T n0010 = dot(g0010, detail::tvec4<T>(Pf0.x, Pf0.y, Pf1.z, Pf0.w));
 
-	T n1010 = dot(g1010, detail::tvec4<T>(Pf1.x, Pf0.y, Pf1.z, Pf0.w));
 
-	T n0110 = dot(g0110, detail::tvec4<T>(Pf0.x, Pf1.y, Pf1.z, Pf0.w));
 
-	T n1110 = dot(g1110, detail::tvec4<T>(Pf1.x, Pf1.y, Pf1.z, Pf0.w));
 
-	T n0001 = dot(g0001, detail::tvec4<T>(Pf0.x, Pf0.y, Pf0.z, Pf1.w));
 
-	T n1001 = dot(g1001, detail::tvec4<T>(Pf1.x, Pf0.y, Pf0.z, Pf1.w));
 
-	T n0101 = dot(g0101, detail::tvec4<T>(Pf0.x, Pf1.y, Pf0.z, Pf1.w));
 
-	T n1101 = dot(g1101, detail::tvec4<T>(Pf1.x, Pf1.y, Pf0.z, Pf1.w));
 
-	T n0011 = dot(g0011, detail::tvec4<T>(Pf0.x, Pf0.y, Pf1.z, Pf1.w));
 
-	T n1011 = dot(g1011, detail::tvec4<T>(Pf1.x, Pf0.y, Pf1.z, Pf1.w));
 
-	T n0111 = dot(g0111, detail::tvec4<T>(Pf0.x, Pf1.y, Pf1.z, Pf1.w));
 
-	T n1111 = dot(g1111, Pf1);
 
-
 
-	detail::tvec4<T> fade_xyzw = fade(Pf0);
 
-	detail::tvec4<T> n_0w = mix(detail::tvec4<T>(n0000, n1000, n0100, n1100), detail::tvec4<T>(n0001, n1001, n0101, n1101), fade_xyzw.w);
 
-	detail::tvec4<T> n_1w = mix(detail::tvec4<T>(n0010, n1010, n0110, n1110), detail::tvec4<T>(n0011, n1011, n0111, n1111), fade_xyzw.w);
 
-	detail::tvec4<T> n_zw = mix(n_0w, n_1w, fade_xyzw.z);
 
-	detail::tvec2<T> n_yzw = mix(detail::tvec2<T>(n_zw.x, n_zw.y), detail::tvec2<T>(n_zw.z, n_zw.w), fade_xyzw.y);
 
-	T n_xyzw = mix(n_yzw.x, n_yzw.y, fade_xyzw.x);
 
-	return T(2.2) * n_xyzw;
 
-}
 
-
 
-// Classic Perlin noise, periodic variant
 
-template <typename T>
 
-GLM_FUNC_QUALIFIER T perlin(detail::tvec2<T> const & P, detail::tvec2<T> const & rep)
 
-{
 
-	detail::tvec4<T> Pi = floor(detail::tvec4<T>(P.x, P.y, P.x, P.y)) + detail::tvec4<T>(0.0, 0.0, 1.0, 1.0);
 
-	detail::tvec4<T> Pf = fract(detail::tvec4<T>(P.x, P.y, P.x, P.y)) - detail::tvec4<T>(0.0, 0.0, 1.0, 1.0);
 
-	Pi = mod(Pi, detail::tvec4<T>(rep.x, rep.y, rep.x, rep.y)); // To create noise with explicit period
 
-	Pi = mod(Pi, T(289)); // To avoid truncation effects in permutation
 
-	detail::tvec4<T> ix(Pi.x, Pi.z, Pi.x, Pi.z);
 
-	detail::tvec4<T> iy(Pi.y, Pi.y, Pi.w, Pi.w);
 
-	detail::tvec4<T> fx(Pf.x, Pf.z, Pf.x, Pf.z);
 
-	detail::tvec4<T> fy(Pf.y, Pf.y, Pf.w, Pf.w);
 
-
 
-	detail::tvec4<T> i = permute(permute(ix) + iy);
 
-
 
-	detail::tvec4<T> gx = T(2) * fract(i / T(41)) - T(1);
 
-	detail::tvec4<T> gy = abs(gx) - T(0.5);
 
-	detail::tvec4<T> tx = floor(gx + T(0.5));
 
-	gx = gx - tx;
 
-
 
-	detail::tvec2<T> g00(gx.x, gy.x);
 
-	detail::tvec2<T> g10(gx.y, gy.y);
 
-	detail::tvec2<T> g01(gx.z, gy.z);
 
-	detail::tvec2<T> g11(gx.w, gy.w);
 
-
 
-	detail::tvec4<T> norm = taylorInvSqrt(detail::tvec4<T>(dot(g00, g00), dot(g01, g01), dot(g10, g10), dot(g11, g11)));
 
-	g00 *= norm.x;  
-	g01 *= norm.y;  
-	g10 *= norm.z;  
-	g11 *= norm.w;  
-
 
-	T n00 = dot(g00, detail::tvec2<T>(fx.x, fy.x));
 
-	T n10 = dot(g10, detail::tvec2<T>(fx.y, fy.y));
 
-	T n01 = dot(g01, detail::tvec2<T>(fx.z, fy.z));
 
-	T n11 = dot(g11, detail::tvec2<T>(fx.w, fy.w));
 
-
 
-	detail::tvec2<T> fade_xy = fade(detail::tvec2<T>(Pf.x, Pf.y));
 
-	detail::tvec2<T> n_x = mix(detail::tvec2<T>(n00, n01), detail::tvec2<T>(n10, n11), fade_xy.x);
 
-	T n_xy = mix(n_x.x, n_x.y, fade_xy.y);
 
-	return T(2.3) * n_xy;
 
-}
 
-
 
-// Classic Perlin noise, periodic variant
 
-template <typename T>
 
-GLM_FUNC_QUALIFIER T perlin(detail::tvec3<T> const & P, detail::tvec3<T> const & rep)
 
-{
 
-	detail::tvec3<T> Pi0 = mod(floor(P), rep); // Integer part, modulo period
 
-	detail::tvec3<T> Pi1 = mod(Pi0 + detail::tvec3<T>(1.0), rep); // Integer part + 1, mod period
 
-	Pi0 = mod(Pi0, T(289));
 
-	Pi1 = mod(Pi1, T(289));
 
-	detail::tvec3<T> Pf0 = fract(P); // Fractional part for interpolation
 
-	detail::tvec3<T> Pf1 = Pf0 - detail::tvec3<T>(1.0); // Fractional part - 1.0
 
-	detail::tvec4<T> ix = detail::tvec4<T>(Pi0.x, Pi1.x, Pi0.x, Pi1.x);
 
-	detail::tvec4<T> iy = detail::tvec4<T>(Pi0.y, Pi0.y, Pi1.y, Pi1.y);
 
-	detail::tvec4<T> iz0(Pi0.z);
 
-	detail::tvec4<T> iz1(Pi1.z);
 
-
 
-	detail::tvec4<T> ixy = permute(permute(ix) + iy);
 
-	detail::tvec4<T> ixy0 = permute(ixy + iz0);
 
-	detail::tvec4<T> ixy1 = permute(ixy + iz1);
 
-
 
-	detail::tvec4<T> gx0 = ixy0 / T(7);
 
-	detail::tvec4<T> gy0 = fract(floor(gx0) / T(7)) - T(0.5);
 
-	gx0 = fract(gx0);
 
-	detail::tvec4<T> gz0 = detail::tvec4<T>(0.5) - abs(gx0) - abs(gy0);
 
-	detail::tvec4<T> sz0 = step(gz0, detail::tvec4<T>(0));
 
-	gx0 -= sz0 * (step(0.0, gx0) - T(0.5));
 
-	gy0 -= sz0 * (step(0.0, gy0) - T(0.5));
 
-
 
-	detail::tvec4<T> gx1 = ixy1 / T(7);
 
-	detail::tvec4<T> gy1 = fract(floor(gx1) / T(7)) - T(0.5);
 
-	gx1 = fract(gx1);
 
-	detail::tvec4<T> gz1 = detail::tvec4<T>(0.5) - abs(gx1) - abs(gy1);
 
-	detail::tvec4<T> sz1 = step(gz1, detail::tvec4<T>(0.0));
 
-	gx1 -= sz1 * (step(0.0, gx1) - T(0.5));
 
-	gy1 -= sz1 * (step(0.0, gy1) - T(0.5));
 
-
 
-	detail::tvec3<T> g000 = detail::tvec3<T>(gx0.x, gy0.x, gz0.x);
 
-	detail::tvec3<T> g100 = detail::tvec3<T>(gx0.y, gy0.y, gz0.y);
 
-	detail::tvec3<T> g010 = detail::tvec3<T>(gx0.z, gy0.z, gz0.z);
 
-	detail::tvec3<T> g110 = detail::tvec3<T>(gx0.w, gy0.w, gz0.w);
 
-	detail::tvec3<T> g001 = detail::tvec3<T>(gx1.x, gy1.x, gz1.x);
 
-	detail::tvec3<T> g101 = detail::tvec3<T>(gx1.y, gy1.y, gz1.y);
 
-	detail::tvec3<T> g011 = detail::tvec3<T>(gx1.z, gy1.z, gz1.z);
 
-	detail::tvec3<T> g111 = detail::tvec3<T>(gx1.w, gy1.w, gz1.w);
 
-
 
-	detail::tvec4<T> norm0 = taylorInvSqrt(detail::tvec4<T>(dot(g000, g000), dot(g010, g010), dot(g100, g100), dot(g110, g110)));
 
-	g000 *= norm0.x;
 
-	g010 *= norm0.y;
 
-	g100 *= norm0.z;
 
-	g110 *= norm0.w;
 
-	detail::tvec4<T> norm1 = taylorInvSqrt(detail::tvec4<T>(dot(g001, g001), dot(g011, g011), dot(g101, g101), dot(g111, g111)));
 
-	g001 *= norm1.x;
 
-	g011 *= norm1.y;
 
-	g101 *= norm1.z;
 
-	g111 *= norm1.w;
 
-
 
-	T n000 = dot(g000, Pf0);
 
-	T n100 = dot(g100, detail::tvec3<T>(Pf1.x, Pf0.y, Pf0.z));
 
-	T n010 = dot(g010, detail::tvec3<T>(Pf0.x, Pf1.y, Pf0.z));
 
-	T n110 = dot(g110, detail::tvec3<T>(Pf1.x, Pf1.y, Pf0.z));
 
-	T n001 = dot(g001, detail::tvec3<T>(Pf0.x, Pf0.y, Pf1.z));
 
-	T n101 = dot(g101, detail::tvec3<T>(Pf1.x, Pf0.y, Pf1.z));
 
-	T n011 = dot(g011, detail::tvec3<T>(Pf0.x, Pf1.y, Pf1.z));
 
-	T n111 = dot(g111, Pf1);
 
-
 
-	detail::tvec3<T> fade_xyz = fade(Pf0);
 
-	detail::tvec4<T> n_z = mix(detail::tvec4<T>(n000, n100, n010, n110), detail::tvec4<T>(n001, n101, n011, n111), fade_xyz.z);
 
-	detail::tvec2<T> n_yz = mix(detail::tvec2<T>(n_z.x, n_z.y), detail::tvec2<T>(n_z.z, n_z.w), fade_xyz.y);
 
-	T n_xyz = mix(n_yz.x, n_yz.y, fade_xyz.x); 
-	return T(2.2) * n_xyz;
 
-}
 
-
 
-// Classic Perlin noise, periodic version
 
-template <typename T>
 
-GLM_FUNC_QUALIFIER T perlin(detail::tvec4<T> const & P, detail::tvec4<T> const & rep)
 
-{
 
-	detail::tvec4<T> Pi0 = mod(floor(P), rep); // Integer part modulo rep
 
-	detail::tvec4<T> Pi1 = mod(Pi0 + T(1), rep); // Integer part + 1 mod rep
 
-	detail::tvec4<T> Pf0 = fract(P); // Fractional part for interpolation
 
-	detail::tvec4<T> Pf1 = Pf0 - T(1); // Fractional part - 1.0
 
-	detail::tvec4<T> ix = detail::tvec4<T>(Pi0.x, Pi1.x, Pi0.x, Pi1.x);
 
-	detail::tvec4<T> iy = detail::tvec4<T>(Pi0.y, Pi0.y, Pi1.y, Pi1.y);
 
-	detail::tvec4<T> iz0(Pi0.z);
 
-	detail::tvec4<T> iz1(Pi1.z);
 
-	detail::tvec4<T> iw0(Pi0.w);
 
-	detail::tvec4<T> iw1(Pi1.w);
 
-
 
-	detail::tvec4<T> ixy = permute(permute(ix) + iy);
 
-	detail::tvec4<T> ixy0 = permute(ixy + iz0);
 
-	detail::tvec4<T> ixy1 = permute(ixy + iz1);
 
-	detail::tvec4<T> ixy00 = permute(ixy0 + iw0);
 
-	detail::tvec4<T> ixy01 = permute(ixy0 + iw1);
 
-	detail::tvec4<T> ixy10 = permute(ixy1 + iw0);
 
-	detail::tvec4<T> ixy11 = permute(ixy1 + iw1);
 
-
 
-	detail::tvec4<T> gx00 = ixy00 / T(7);
 
-	detail::tvec4<T> gy00 = floor(gx00) / T(7);
 
-	detail::tvec4<T> gz00 = floor(gy00) / T(6);
 
-	gx00 = fract(gx00) - T(0.5);
 
-	gy00 = fract(gy00) - T(0.5);
 
-	gz00 = fract(gz00) - T(0.5);
 
-	detail::tvec4<T> gw00 = detail::tvec4<T>(0.75) - abs(gx00) - abs(gy00) - abs(gz00);
 
-	detail::tvec4<T> sw00 = step(gw00, detail::tvec4<T>(0));
 
-	gx00 -= sw00 * (step(0.0, gx00) - T(0.5));
 
-	gy00 -= sw00 * (step(0.0, gy00) - T(0.5));
 
-
 
-	detail::tvec4<T> gx01 = ixy01 / T(7);
 
-	detail::tvec4<T> gy01 = floor(gx01) / T(7);
 
-	detail::tvec4<T> gz01 = floor(gy01) / T(6);
 
-	gx01 = fract(gx01) - T(0.5);
 
-	gy01 = fract(gy01) - T(0.5);
 
-	gz01 = fract(gz01) - T(0.5);
 
-	detail::tvec4<T> gw01 = detail::tvec4<T>(0.75) - abs(gx01) - abs(gy01) - abs(gz01);
 
-	detail::tvec4<T> sw01 = step(gw01, detail::tvec4<T>(0.0));
 
-	gx01 -= sw01 * (step(0.0, gx01) - T(0.5));
 
-	gy01 -= sw01 * (step(0.0, gy01) - T(0.5));
 
-
 
-	detail::tvec4<T> gx10 = ixy10 / T(7);
 
-	detail::tvec4<T> gy10 = floor(gx10) / T(7);
 
-	detail::tvec4<T> gz10 = floor(gy10) / T(6);
 
-	gx10 = fract(gx10) - T(0.5);
 
-	gy10 = fract(gy10) - T(0.5);
 
-	gz10 = fract(gz10) - T(0.5);
 
-	detail::tvec4<T> gw10 = detail::tvec4<T>(0.75) - abs(gx10) - abs(gy10) - abs(gz10);
 
-	detail::tvec4<T> sw10 = step(gw10, detail::tvec4<T>(0.0));
 
-	gx10 -= sw10 * (step(0.0, gx10) - T(0.5));
 
-	gy10 -= sw10 * (step(0.0, gy10) - T(0.5));
 
-
 
-	detail::tvec4<T> gx11 = ixy11 / T(7);
 
-	detail::tvec4<T> gy11 = floor(gx11) / T(7);
 
-	detail::tvec4<T> gz11 = floor(gy11) / T(6);
 
-	gx11 = fract(gx11) - T(0.5);
 
-	gy11 = fract(gy11) - T(0.5);
 
-	gz11 = fract(gz11) - T(0.5);
 
-	detail::tvec4<T> gw11 = detail::tvec4<T>(0.75) - abs(gx11) - abs(gy11) - abs(gz11);
 
-	detail::tvec4<T> sw11 = step(gw11, detail::tvec4<T>(0.0));
 
-	gx11 -= sw11 * (step(0.0, gx11) - T(0.5));
 
-	gy11 -= sw11 * (step(0.0, gy11) - T(0.5));
 
-
 
-	detail::tvec4<T> g0000(gx00.x, gy00.x, gz00.x, gw00.x);
 
-	detail::tvec4<T> g1000(gx00.y, gy00.y, gz00.y, gw00.y);
 
-	detail::tvec4<T> g0100(gx00.z, gy00.z, gz00.z, gw00.z);
 
-	detail::tvec4<T> g1100(gx00.w, gy00.w, gz00.w, gw00.w);
 
-	detail::tvec4<T> g0010(gx10.x, gy10.x, gz10.x, gw10.x);
 
-	detail::tvec4<T> g1010(gx10.y, gy10.y, gz10.y, gw10.y);
 
-	detail::tvec4<T> g0110(gx10.z, gy10.z, gz10.z, gw10.z);
 
-	detail::tvec4<T> g1110(gx10.w, gy10.w, gz10.w, gw10.w);
 
-	detail::tvec4<T> g0001(gx01.x, gy01.x, gz01.x, gw01.x);
 
-	detail::tvec4<T> g1001(gx01.y, gy01.y, gz01.y, gw01.y);
 
-	detail::tvec4<T> g0101(gx01.z, gy01.z, gz01.z, gw01.z);
 
-	detail::tvec4<T> g1101(gx01.w, gy01.w, gz01.w, gw01.w);
 
-	detail::tvec4<T> g0011(gx11.x, gy11.x, gz11.x, gw11.x);
 
-	detail::tvec4<T> g1011(gx11.y, gy11.y, gz11.y, gw11.y);
 
-	detail::tvec4<T> g0111(gx11.z, gy11.z, gz11.z, gw11.z);
 
-	detail::tvec4<T> g1111(gx11.w, gy11.w, gz11.w, gw11.w);
 
-
 
-	detail::tvec4<T> norm00 = taylorInvSqrt(detail::tvec4<T>(dot(g0000, g0000), dot(g0100, g0100), dot(g1000, g1000), dot(g1100, g1100)));
 
-	g0000 *= norm00.x;
 
-	g0100 *= norm00.y;
 
-	g1000 *= norm00.z;
 
-	g1100 *= norm00.w;
 
-
 
-	detail::tvec4<T> norm01 = taylorInvSqrt(detail::tvec4<T>(dot(g0001, g0001), dot(g0101, g0101), dot(g1001, g1001), dot(g1101, g1101)));
 
-	g0001 *= norm01.x;
 
-	g0101 *= norm01.y;
 
-	g1001 *= norm01.z;
 
-	g1101 *= norm01.w;
 
-
 
-	detail::tvec4<T> norm10 = taylorInvSqrt(detail::tvec4<T>(dot(g0010, g0010), dot(g0110, g0110), dot(g1010, g1010), dot(g1110, g1110)));
 
-	g0010 *= norm10.x;
 
-	g0110 *= norm10.y;
 
-	g1010 *= norm10.z;
 
-	g1110 *= norm10.w;
 
-
 
-	detail::tvec4<T> norm11 = taylorInvSqrt(detail::tvec4<T>(dot(g0011, g0011), dot(g0111, g0111), dot(g1011, g1011), dot(g1111, g1111)));
 
-	g0011 *= norm11.x;
 
-	g0111 *= norm11.y;
 
-	g1011 *= norm11.z;
 
-	g1111 *= norm11.w;
 
-
 
-	T n0000 = dot(g0000, Pf0);
 
-	T n1000 = dot(g1000, detail::tvec4<T>(Pf1.x, Pf0.y, Pf0.z, Pf0.w));
 
-	T n0100 = dot(g0100, detail::tvec4<T>(Pf0.x, Pf1.y, Pf0.z, Pf0.w));
 
-	T n1100 = dot(g1100, detail::tvec4<T>(Pf1.x, Pf1.y, Pf0.z, Pf0.w));
 
-	T n0010 = dot(g0010, detail::tvec4<T>(Pf0.x, Pf0.y, Pf1.z, Pf0.w));
 
-	T n1010 = dot(g1010, detail::tvec4<T>(Pf1.x, Pf0.y, Pf1.z, Pf0.w));
 
-	T n0110 = dot(g0110, detail::tvec4<T>(Pf0.x, Pf1.y, Pf1.z, Pf0.w));
 
-	T n1110 = dot(g1110, detail::tvec4<T>(Pf1.x, Pf1.y, Pf1.z, Pf0.w));
 
-	T n0001 = dot(g0001, detail::tvec4<T>(Pf0.x, Pf0.y, Pf0.z, Pf1.w));
 
-	T n1001 = dot(g1001, detail::tvec4<T>(Pf1.x, Pf0.y, Pf0.z, Pf1.w));
 
-	T n0101 = dot(g0101, detail::tvec4<T>(Pf0.x, Pf1.y, Pf0.z, Pf1.w));
 
-	T n1101 = dot(g1101, detail::tvec4<T>(Pf1.x, Pf1.y, Pf0.z, Pf1.w));
 
-	T n0011 = dot(g0011, detail::tvec4<T>(Pf0.x, Pf0.y, Pf1.z, Pf1.w));
 
-	T n1011 = dot(g1011, detail::tvec4<T>(Pf1.x, Pf0.y, Pf1.z, Pf1.w));
 
-	T n0111 = dot(g0111, detail::tvec4<T>(Pf0.x, Pf1.y, Pf1.z, Pf1.w));
 
-	T n1111 = dot(g1111, Pf1);
 
-
 
-	detail::tvec4<T> fade_xyzw = fade(Pf0);
 
-	detail::tvec4<T> n_0w = mix(detail::tvec4<T>(n0000, n1000, n0100, n1100), detail::tvec4<T>(n0001, n1001, n0101, n1101), fade_xyzw.w);
 
-	detail::tvec4<T> n_1w = mix(detail::tvec4<T>(n0010, n1010, n0110, n1110), detail::tvec4<T>(n0011, n1011, n0111, n1111), fade_xyzw.w);
 
-	detail::tvec4<T> n_zw = mix(n_0w, n_1w, fade_xyzw.z);
 
-	detail::tvec2<T> n_yzw = mix(detail::tvec2<T>(n_zw.x, n_zw.y), detail::tvec2<T>(n_zw.z, n_zw.w), fade_xyzw.y);
 
-	T n_xyzw = mix(n_yzw.x, n_yzw.y, fade_xyzw.x);
 
-	return T(2.2) * n_xyzw;
 
-}
 
-
 
-template <typename T>
 
-GLM_FUNC_QUALIFIER T simplex(glm::detail::tvec2<T> const & v)
 
-{
 
-	detail::tvec4<T> const C = detail::tvec4<T>(
 
-		T( 0.211324865405187),  // (3.0 -  sqrt(3.0)) / 6.0
 
-		T( 0.366025403784439),  //  0.5 * (sqrt(3.0)  - 1.0)
 
-		T(-0.577350269189626),	// -1.0 + 2.0 * C.x
 
-		T( 0.024390243902439)); //  1.0 / 41.0
 
-
 
-	// First corner
 
-	detail::tvec2<T> i  = floor(v + dot(v, detail::tvec2<T>(C[1])));
 
-	detail::tvec2<T> x0 = v -   i + dot(i, detail::tvec2<T>(C[0]));
 
-
 
-	// Other corners
 
-	//i1.x = step( x0.y, x0.x ); // x0.x > x0.y ? 1.0 : 0.0
 
-	//i1.y = 1.0 - i1.x;
 
-	detail::tvec2<T> i1 = (x0.x > x0.y) ? detail::tvec2<T>(1, 0) : detail::tvec2<T>(0, 1);
 
-	// x0 = x0 - 0.0 + 0.0 * C.xx ;
 
-	// x1 = x0 - i1 + 1.0 * C.xx ;
 
-	// x2 = x0 - 1.0 + 2.0 * C.xx ;
 
-	detail::tvec4<T> x12 = detail::tvec4<T>(x0.x, x0.y, x0.x, x0.y) + detail::tvec4<T>(C.x, C.x, C.z, C.z);
 
-	x12 = detail::tvec4<T>(detail::tvec2<T>(x12) - i1, x12.z, x12.w);
 
-
 
-	// Permutations
 
-	i = mod(i, T(289)); // Avoid truncation effects in permutation
 
-	detail::tvec3<T> p = permute(
 
-		permute(i.y + detail::tvec3<T>(T(0), i1.y, T(1)))
 
-		+ i.x + detail::tvec3<T>(T(0), i1.x, T(1)));
 
-
 
-	detail::tvec3<T> m = max(T(0.5) - detail::tvec3<T>(
 
-		dot(x0, x0), 
-		dot(detail::tvec2<T>(x12.x, x12.y), detail::tvec2<T>(x12.x, x12.y)), 
-		dot(detail::tvec2<T>(x12.z, x12.w), detail::tvec2<T>(x12.z, x12.w))), T(0));
 
-	m = m * m ;
 
-	m = m * m ;
 
-
 
-	// Gradients: 41 points uniformly over a line, mapped onto a diamond.
 
-	// The ring size 17*17 = 289 is close to a multiple of 41 (41*7 = 287)
 
-
 
-	detail::tvec3<T> x = T(2) * fract(p * C.w) - T(1);
 
-	detail::tvec3<T> h = abs(x) - T(0.5);
 
-	detail::tvec3<T> ox = floor(x + T(0.5));
 
-	detail::tvec3<T> a0 = x - ox;
 
-
 
-	// Normalise gradients implicitly by scaling m
 
-	// Inlined for speed: m *= taylorInvSqrt( a0*a0 + h*h );
 
-	m *= T(1.79284291400159) - T(0.85373472095314) * (a0 * a0 + h * h);
 
-
 
-	// Compute final noise value at P
 
-	detail::tvec3<T> g;
 
-	g.x  = a0.x  * x0.x  + h.x  * x0.y;
 
-	//g.yz = a0.yz * x12.xz + h.yz * x12.yw;
 
-	g.y = a0.y * x12.x + h.y * x12.y;
 
-	g.z = a0.z * x12.z + h.z * x12.w;
 
-	return T(130) * dot(m, g);
 
-}
 
-
 
-template <typename T>
 
-GLM_FUNC_QUALIFIER T simplex(detail::tvec3<T> const & v)
 
-{ 
-	detail::tvec2<T> const C(1.0 / 6.0, 1.0 / 3.0);
 
-	detail::tvec4<T> const D(0.0, 0.5, 1.0, 2.0);
 
-
 
-	// First corner
 
-	detail::tvec3<T> i(floor(v + dot(v, detail::tvec3<T>(C.y))));
 
-	detail::tvec3<T> x0(v - i + dot(i, detail::tvec3<T>(C.x)));
 
-
 
-	// Other corners
 
-	detail::tvec3<T> g(step(detail::tvec3<T>(x0.y, x0.z, x0.x), x0));
 
-	detail::tvec3<T> l(T(1) - g);
 
-	detail::tvec3<T> i1(min(g, detail::tvec3<T>(l.z, l.x, l.y)));
 
-	detail::tvec3<T> i2(max(g, detail::tvec3<T>(l.z, l.x, l.y)));
 
-
 
-	//   x0 = x0 - 0.0 + 0.0 * C.xxx;
 
-	//   x1 = x0 - i1  + 1.0 * C.xxx;
 
-	//   x2 = x0 - i2  + 2.0 * C.xxx;
 
-	//   x3 = x0 - 1.0 + 3.0 * C.xxx;
 
-	detail::tvec3<T> x1(x0 - i1 + C.x);
 
-	detail::tvec3<T> x2(x0 - i2 + C.y); // 2.0*C.x = 1/3 = C.y
 
-	detail::tvec3<T> x3(x0 - D.y);      // -1.0+3.0*C.x = -0.5 = -D.y
 
-
 
-	// Permutations
 
-	i = mod289(i); 
-	detail::tvec4<T> p(permute(permute(permute( 
-		i.z + detail::tvec4<T>(T(0), i1.z, i2.z, T(1))) + 
-		i.y + detail::tvec4<T>(T(0), i1.y, i2.y, T(1))) + 
-		i.x + detail::tvec4<T>(T(0), i1.x, i2.x, T(1))));
 
-
 
-	// Gradients: 7x7 points over a square, mapped onto an octahedron.
 
-	// The ring size 17*17 = 289 is close to a multiple of 49 (49*6 = 294)
 
-	T n_ = T(0.142857142857); // 1.0/7.0
 
-	detail::tvec3<T> ns(n_ * detail::tvec3<T>(D.w, D.y, D.z) - detail::tvec3<T>(D.x, D.z, D.x));
 
-
 
-	detail::tvec4<T> j(p - T(49) * floor(p * ns.z * ns.z));  //  mod(p,7*7)
 
-
 
-	detail::tvec4<T> x_(floor(j * ns.z));
 
-	detail::tvec4<T> y_(floor(j - T(7) * x_));    // mod(j,N)
 
-
 
-	detail::tvec4<T> x(x_ * ns.x + ns.y);
 
-	detail::tvec4<T> y(y_ * ns.x + ns.y);
 
-	detail::tvec4<T> h(T(1) - abs(x) - abs(y));
 
-
 
-	detail::tvec4<T> b0(x.x, x.y, y.x, y.y);
 
-	detail::tvec4<T> b1(x.z, x.w, y.z, y.w);
 
-
 
-	// vec4 s0 = vec4(lessThan(b0,0.0))*2.0 - 1.0;
 
-	// vec4 s1 = vec4(lessThan(b1,0.0))*2.0 - 1.0;
 
-	detail::tvec4<T> s0(floor(b0) * T(2) + T(1));
 
-	detail::tvec4<T> s1(floor(b1) * T(2) + T(1));
 
-	detail::tvec4<T> sh(-step(h, detail::tvec4<T>(0.0)));
 
-
 
-	detail::tvec4<T> a0 = detail::tvec4<T>(b0.x, b0.z, b0.y, b0.w) + detail::tvec4<T>(s0.x, s0.z, s0.y, s0.w) * detail::tvec4<T>(sh.x, sh.x, sh.y, sh.y);
 
-	detail::tvec4<T> a1 = detail::tvec4<T>(b1.x, b1.z, b1.y, b1.w) + detail::tvec4<T>(s1.x, s1.z, s1.y, s1.w) * detail::tvec4<T>(sh.z, sh.z, sh.w, sh.w);
 
-
 
-	detail::tvec3<T> p0(a0.x, a0.y, h.x);
 
-	detail::tvec3<T> p1(a0.z, a0.w, h.y);
 
-	detail::tvec3<T> p2(a1.x, a1.y, h.z);
 
-	detail::tvec3<T> p3(a1.z, a1.w, h.w);
 
-
 
-	// Normalise gradients
 
-	detail::tvec4<T> norm = taylorInvSqrt(detail::tvec4<T>(dot(p0, p0), dot(p1, p1), dot(p2, p2), dot(p3, p3)));
 
-	p0 *= norm.x;
 
-	p1 *= norm.y;
 
-	p2 *= norm.z;
 
-	p3 *= norm.w;
 
-
 
-	// Mix final noise value
 
-	detail::tvec4<T> m = max(T(0.6) - detail::tvec4<T>(dot(x0, x0), dot(x1, x1), dot(x2, x2), dot(x3, x3)), T(0));
 
-	m = m * m;
 
-	return T(42) * dot(m * m, vec4(dot(p0, x0), dot(p1, x1), dot(p2, x2), dot(p3, x3)));
 
-}
 
-
 
-template <typename T>
 
-GLM_FUNC_QUALIFIER T simplex(detail::tvec4<T> const & v)
 
-{
 
-	detail::tvec4<T> const C(
 
-		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
 
-	T const F4 = T(0.309016994374947451);
 
-
 
-	// First corner
 
-	detail::tvec4<T> i  = floor(v + dot(v, vec4(F4)));
 
-	detail::tvec4<T> x0 = v -   i + dot(i, vec4(C.x));
 
-
 
-	// Other corners
 
-
 
-	// Rank sorting originally contributed by Bill Licea-Kane, AMD (formerly ATI)
 
-	detail::tvec4<T> i0;
 
-	detail::tvec3<T> isX = step(detail::tvec3<T>(x0.y, x0.z, x0.w), detail::tvec3<T>(x0.x));
 
-	detail::tvec3<T> isYZ = step(detail::tvec3<T>(x0.z, x0.w, x0.w), detail::tvec3<T>(x0.y, x0.y, x0.z));
 
-	//  i0.x = dot(isX, vec3(1.0));
 
-	//i0.x = isX.x + isX.y + isX.z;
 
-	//i0.yzw = T(1) - isX;
 
-    i0 = detail::tvec4<T>(isX.x + isX.y + isX.z, T(1) - isX);
 
-	//  i0.y += dot(isYZ.xy, vec2(1.0));
 
-	i0.y += isYZ.x + isYZ.y;
 
-	//i0.zw += 1.0 - detail::tvec2<T>(isYZ.x, isYZ.y);
 
-    i0.z += T(1) - isYZ.x;
 
-    i0.w += T(1) - isYZ.y;
 
-	i0.z += isYZ.z;
 
-	i0.w += T(1) - isYZ.z;
 
-
 
-	// i0 now contains the unique values 0,1,2,3 in each channel
 
-	detail::tvec4<T> i3 = clamp(i0, 0.0, 1.0);
 
-	detail::tvec4<T> i2 = clamp(i0 - 1.0, 0.0, 1.0);
 
-	detail::tvec4<T> i1 = clamp(i0 - 2.0, 0.0, 1.0);
 
-
 
-	//  x0 = x0 - 0.0 + 0.0 * C.xxxx
 
-	//  x1 = x0 - i1  + 0.0 * C.xxxx
 
-	//  x2 = x0 - i2  + 0.0 * C.xxxx
 
-	//  x3 = x0 - i3  + 0.0 * C.xxxx
 
-	//  x4 = x0 - 1.0 + 4.0 * C.xxxx
 
-	detail::tvec4<T> x1 = x0 - i1 + C.x;
 
-	detail::tvec4<T> x2 = x0 - i2 + C.y;
 
-	detail::tvec4<T> x3 = x0 - i3 + C.z;
 
-	detail::tvec4<T> x4 = x0 + C.w;
 
-
 
-	// Permutations
 
-	i = mod(i, T(289)); 
-	T j0 = permute(permute(permute(permute(i.w) + i.z) + i.y) + i.x);
 
-	detail::tvec4<T> j1 = permute(permute(permute(permute(
 
-				i.w + detail::tvec4<T>(i1.w, i2.w, i3.w, T(1)))
 
-			+ i.z + detail::tvec4<T>(i1.z, i2.z, i3.z, T(1)))
 
-			+ i.y + detail::tvec4<T>(i1.y, i2.y, i3.y, T(1)))
 
-			+ i.x + detail::tvec4<T>(i1.x, i2.x, i3.x, T(1)));
 
-
 
-	// 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.
 
-	detail::tvec4<T> ip = detail::tvec4<T>(T(1) / T(294), T(1) / T(49), T(1) / T(7), T(0));
 
-
 
-	detail::tvec4<T> p0 = grad4(j0,   ip);
 
-	detail::tvec4<T> p1 = grad4(j1.x, ip);
 
-	detail::tvec4<T> p2 = grad4(j1.y, ip);
 
-	detail::tvec4<T> p3 = grad4(j1.z, ip);
 
-	detail::tvec4<T> p4 = grad4(j1.w, ip);
 
-
 
-	// Normalise gradients
 
-	detail::tvec4<T> norm = taylorInvSqrt(detail::tvec4<T>(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
 
-	detail::tvec3<T> m0 = max(T(0.6) - detail::tvec3<T>(dot(x0, x0), dot(x1, x1), dot(x2, x2)), T(0));
 
-	detail::tvec2<T> m1 = max(T(0.6) - detail::tvec2<T>(dot(x3, x3), dot(x4, x4)             ), T(0));
 
-	m0 = m0 * m0;
 
-	m1 = m1 * m1;
 
-	return T(49) * 
-		(dot(m0 * m0, detail::tvec3<T>(dot(p0, x0), dot(p1, x1), dot(p2, x2))) + 
-		dot(m1 * m1, detail::tvec2<T>(dot(p3, x3), dot(p4, x4))));
 
-}
 
-
 
 }//namespace glm
 
 }//namespace glm

+ 7 - 2
glm/gtx/ulp.inl
View File 

@@ -21,6 +21,9 @@
 
  * ====================================================
 
  * ====================================================
 
  */
 
  */
 
 
 
+#pragma warning(push)
 
+#pragma warning(disable : 4127)
 
+
 
 typedef union
 
 typedef union
 
 {
 
 {
 
 	float value;
 
 	float value;
 
@@ -76,8 +79,8 @@ namespace detail
 
 		volatile float t;
 
 		volatile float t;
 
 		glm::detail::int32 hx, hy, ix, iy;
 
 		glm::detail::int32 hx, hy, ix, iy;
 
 
 
-		GLM_GET_FLOAT_WORD(hx,x);
 
-		GLM_GET_FLOAT_WORD(hy,y);
 
+		GLM_GET_FLOAT_WORD(hx, x);
 
+		GLM_GET_FLOAT_WORD(hy, y);
 
 		ix = hx&0x7fffffff;             // |x|
 
 		ix = hx&0x7fffffff;             // |x|
 
 		iy = hy&0x7fffffff;             // |y|
 
 		iy = hy&0x7fffffff;             // |y|
 
 
 
@@ -168,6 +171,8 @@ namespace detail
 
 }//namespace detail
 
 }//namespace detail
 
 }//namespace glm
 
 }//namespace glm
 
 
 
+#pragma warning(pop)
 
+
 
 #if(GLM_COMPILER & GLM_COMPILER_VC)
 
 #if(GLM_COMPILER & GLM_COMPILER_VC)
 
 #	define GLM_NEXT_AFTER_FLT(x, toward) glm::detail::nextafterf((x), (toward))
 
 #	define GLM_NEXT_AFTER_FLT(x, toward) glm::detail::nextafterf((x), (toward))
 
 #   define GLM_NEXT_AFTER_DBL(x, toward) _nextafter((x), (toward))
 
 #   define GLM_NEXT_AFTER_DBL(x, toward) _nextafter((x), (toward))

+ 2 - 52
glm/gtx/unsigned_int.hpp
View File 

@@ -19,58 +19,8 @@
 
 /// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 
 /// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 
 /// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 
 /// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 
 /// THE SOFTWARE.
 
 /// THE SOFTWARE.
 
-///
 
-/// @ref gtx_unsigned_int
 
-/// @file glm/gtx/unsigned_int.hpp
 
-/// @date 2005-12-24 / 2011-06-07
 
-/// @author Christophe Riccio
 
-///
 
-/// @see core (dependence)
 
-/// @see gtx_integer (dependence)
 
-///
 
-/// @defgroup gtx_unsigned_int GLM_GTX_unsigned_int: Unsigned int
 
-/// @ingroup gtx
 
-/// 
-/// @brief Add support for unsigned integer for core functions
 
-/// 
-/// <glm/gtx/unsigned_int.hpp> need to be included to use these functionalities.
 
 ///////////////////////////////////////////////////////////////////////////////////
 
 ///////////////////////////////////////////////////////////////////////////////////
 
 
 
-#ifndef GLM_GTX_unsigned_int
 
-#define GLM_GTX_unsigned_int GLM_VERSION
 
-
 
-// Dependency:
 
-#include "../glm.hpp"
 
-#include "../gtx/integer.hpp"
 
-
 
-#if(defined(GLM_MESSAGES) && !defined(glm_ext))
 
-#	pragma message("GLM: GLM_GTX_unsigned_int extension included")
 
+#if(defined(GLM_MESSAGES))
 
+#	pragma message("GLM: GLM_GTX_unsigned_int extension is deprecated, include GLM_GTX_integer instead")
 
 #endif
 
 #endif
 
-
 
-namespace glm
 
-{
 
-	/// @addtogroup gtx_unsigned_int
 
-	/// @{
 
-
 
-	//! 32bit signed integer. 
-	//! From GLM_GTX_unsigned_int extension.
 
-	typedef signed int					sint;
 
-
 
-	//! Returns x raised to the y power.
 
-	//! From GLM_GTX_unsigned_int extension.
 
-	uint pow(uint x, uint y);
 
-
 
-	//! Returns the positive square root of x. 
-	//! From GLM_GTX_unsigned_int extension.
 
-	uint sqrt(uint x);
 
-
 
-	//! Modulus. Returns x - y * floor(x / y) for each component in x using the floating point value y.
 
-	//! From GLM_GTX_unsigned_int extension.
 
-	uint mod(uint x, uint y);
 
-
 
-	/// @}
 
-}//namespace glm
 
-
 
-#include "unsigned_int.inl"
 
-
 
-#endif//GLM_GTX_unsigned_int

+ 0 - 28
glm/gtx/unsigned_int.inl
View File 

@@ -9,33 +9,5 @@
 
 
 
 namespace glm{
 
 namespace glm{
 
 
 
-GLM_FUNC_QUALIFIER uint pow(uint x, uint y)
 
-{
 
-    uint result = x;
 
-    for(uint i = 1; i < y; ++i)
 
-        result *= x;
 
-    return result;
 
-}
 
-
 
-GLM_FUNC_QUALIFIER uint sqrt(uint x)
 
-{
 
-    if(x <= 1) return x;
 
-
 
-    uint NextTrial = x >> 1;
 
-    uint CurrentAnswer;
 
-
 
-    do
 
-    {
 
-        CurrentAnswer = NextTrial;
 
-        NextTrial = (NextTrial + x / NextTrial) >> 1;
 
-    } while(NextTrial < CurrentAnswer);
 
-
 
-    return CurrentAnswer;
 
-}
 
-
 
-GLM_FUNC_QUALIFIER uint mod(uint x, uint y)
 
-{
 
-	return x - y * (x / y);
 
-}
 
 
 
 }//namespace glm
 
 }//namespace glm

+ 16 - 0
readme.txt
View File 

@@ -40,10 +40,26 @@ http://glm.g-truc.net/glm-0.9.3.pdf
 
 GLM 0.9.3.0: 2011-XX-XX
 
 GLM 0.9.3.0: 2011-XX-XX
 
 --------------------------------------------------------------------------------
 
 --------------------------------------------------------------------------------
 
 - Improved doxygen documentation
 
 - Improved doxygen documentation
 
+- Promoted GLM_GTC_noise extension: simplex, perlin, periodic noise functions
 
+- Promoted GLM_GTC_random extension: linear, gaussian and various random number 
+generation distribution.
 
+- Added GLM_GTX_constants: provides usefull constants
 
 - Added extension versioning
 
 - Added extension versioning
 
 - Removed many unused namespaces
 
 - Removed many unused namespaces
 
 - Fixed half based type contructors
 
 - Fixed half based type contructors
 
 
 
+================================================================================
 
+GLM 0.9.2.7: 2011-1X-XX
 
+--------------------------------------------------------------------------------
 
+- Added more swizzling constructors
 
+
 
+================================================================================
 
+GLM 0.9.2.6: 2011-10-01
 
+--------------------------------------------------------------------------------
 
+- Fixed half based type build on old GCC
 
+- Fixed /W4 warnings on Visual C++
 
+- Fixed some missing l-value swizzle operators
 
+
 
 ================================================================================
 
 ================================================================================
 
 GLM 0.9.2.5: 2011-09-20
 
 GLM 0.9.2.5: 2011-09-20
 
 --------------------------------------------------------------------------------
 
 --------------------------------------------------------------------------------

+ 112 - 0
test/core/core_type_vec2.cpp
View File 

@@ -71,6 +71,118 @@ int test_vec2_operators()
 
         Error += A.x == C.x && A.y == C.y ? 0 : 1;
 
         Error += A.x == C.x && A.y == C.y ? 0 : 1;
 
     }    
     }    
     
     
+	{
 
+		glm::vec2 A(1.0f, 2.0f);
 
+		glm::vec2 B(4.0f, 5.0f);
 
+		
+		glm::vec2 C = A + B;
 
+		Error += C == glm::vec2(5, 7) ? 0 : 1;
 
+		
+		glm::vec2 D = B - A;
 
+		Error += D == glm::vec2(3, 3) ? 0 : 1;
 
+		
+		glm::vec2 E = A * B;
 
+		Error += E == glm::vec2(4, 10) ? 0 : 1;
 
+		
+		glm::vec2 F = B / A;
 
+		Error += F == glm::vec2(4, 2.5) ? 0 : 1;
 
+		
+		glm::vec2 G = A + 1.0f;
 
+		Error += G == glm::vec2(2, 3) ? 0 : 1;
 
+		
+		glm::vec2 H = B - 1.0f;
 
+		Error += H == glm::vec2(3, 4) ? 0 : 1;
 
+		
+		glm::vec2 I = A * 2.0f;
 
+		Error += I == glm::vec2(2, 4) ? 0 : 1;
 
+		
+		glm::vec2 J = B / 2.0f;
 
+		Error += J == glm::vec2(2, 2.5) ? 0 : 1;
 
+		
+		glm::vec2 K = 1.0f + A;
 
+		Error += K == glm::vec2(2, 3) ? 0 : 1;
 
+		
+		glm::vec2 L = 1.0f - B;
 
+		Error += L == glm::vec2(-3, -4) ? 0 : 1;
 
+		
+		glm::vec2 M = 2.0f * A;
 
+		Error += M == glm::vec2(2, 4) ? 0 : 1;
 
+		
+		glm::vec2 N = 2.0f / B;
 
+		Error += N == glm::vec2(0.5, 2.0 / 5.0) ? 0 : 1;
 
+	}
 
+	
+	{
 
+		glm::vec2 A(1.0f, 2.0f);
 
+		glm::vec2 B(4.0f, 5.0f);
 
+		
+		A += B;
 
+		Error += A == glm::vec2(5, 7) ? 0 : 1;
 
+		
+		A += 1.0f;
 
+		Error += A == glm::vec2(6, 8) ? 0 : 1;
 
+	}
 
+	{
 
+		glm::vec2 A(1.0f, 2.0f);
 
+		glm::vec2 B(4.0f, 5.0f);
 
+		
+		B -= A;
 
+		Error += B == glm::vec2(3, 3) ? 0 : 1;
 
+		
+		B -= 1.0f;
 
+		Error += B == glm::vec2(2, 2) ? 0 : 1;
 
+	}
 
+	{
 
+		glm::vec2 A(1.0f, 2.0f);
 
+		glm::vec2 B(4.0f, 5.0f);
 
+		
+		A *= B;
 
+		Error += A == glm::vec2(4, 10) ? 0 : 1;
 
+		
+		A *= 2.0f;
 
+		Error += A == glm::vec2(8, 20) ? 0 : 1;
 
+	}
 
+	{
 
+		glm::vec2 A(1.0f, 2.0f);
 
+		glm::vec2 B(4.0f, 5.0f);
 
+		
+		B /= A;
 
+		Error += B == glm::vec2(4, 2.5) ? 0 : 1;
 
+		
+		B /= 2.0f;
 
+		Error += B == glm::vec2(2, 1.25) ? 0 : 1;
 
+	}
 
+	
+	{
 
+		glm::vec2 A(1.0f, 2.0f);
 
+		glm::vec2 B = -A;
 
+		Error += B == glm::vec2(-1.0f, -2.0f) ? 0 : 1;
 
+	}
 
+	
+	{
 
+		glm::vec2 A(1.0f, 2.0f);
 
+		glm::vec2 B = --A;
 
+		Error += B == glm::vec2(0.0f, 1.0f) ? 0 : 1;
 
+	}
 
+	
+	{
 
+		glm::vec2 A(1.0f, 2.0f);
 
+		glm::vec2 B = A--;
 
+		Error += B == glm::vec2(0.0f, 1.0f) ? 0 : 1;
 
+	}
 
+	
+	{
 
+		glm::vec2 A(1.0f, 2.0f);
 
+		glm::vec2 B = ++A;
 
+		Error += B == glm::vec2(2.0f, 3.0f) ? 0 : 1;
 
+	}
 
+	
+	{
 
+		glm::vec2 A(1.0f, 2.0f);
 
+		glm::vec2 B = A++;
 
+		Error += B == glm::vec2(2.0f, 3.0f) ? 0 : 1;
 
+	}
 
+	
 	return Error;
 
 	return Error;
 
 }
 
 }

+ 148 - 1
test/core/core_type_vec3.cpp
View File 

@@ -10,8 +10,34 @@
 
 #include <glm/glm.hpp>
 
 #include <glm/glm.hpp>
 
 #include <glm/gtc/half_float.hpp>
 
 #include <glm/gtc/half_float.hpp>
 
 #include <cstdio>
 
 #include <cstdio>
 
+#include <vector>
 
 
 
-static int test_vec3_operators()
 
+int test_vec3_ctor()
 
+{
 
+	int Error = 0;
 
+	
+	{
 
+		glm::vec3 A(1);
 
+		glm::vec3 B(1, 1, 1);
 
+		
+		Error += A == B ? 0 : 1;
 
+	}
 
+	
+	{
 
+		std::vector<glm::vec3> Tests;
 
+		Tests.push_back(glm::vec3(glm::vec2(1, 2), 3));
 
+		Tests.push_back(glm::vec3(1, glm::vec2(2, 3)));
 
+		Tests.push_back(glm::vec3(1, 2, 3));
 
+		Tests.push_back(glm::vec3(glm::vec4(1, 2, 3, 4)));
 
+
 
+		for(std::size_t i = 0; i < Tests.size(); ++i)
 
+			Error += Tests[i] == glm::vec3(1, 2, 3) ? 0 : 1;
 
+	}
 
+		
+	return Error;
 
+}
 
+
 
+int test_vec3_operators()
 
 {
 
 {
 
 	int Error = 0;
 
 	int Error = 0;
 
 	
 	
@@ -39,6 +65,101 @@ static int test_vec3_operators()
 
 
 
 		glm::vec3 F = B / A;
 
 		glm::vec3 F = B / A;
 
 		Error += F == glm::vec3(4, 2.5, 2) ? 0 : 1;
 
 		Error += F == glm::vec3(4, 2.5, 2) ? 0 : 1;
 
+
 
+		glm::vec3 G = A + 1.0f;
 
+		Error += G == glm::vec3(2, 3, 4) ? 0 : 1;
 
+
 
+		glm::vec3 H = B - 1.0f;
 
+		Error += H == glm::vec3(3, 4, 5) ? 0 : 1;
 
+
 
+		glm::vec3 I = A * 2.0f;
 
+		Error += I == glm::vec3(2, 4, 6) ? 0 : 1;
 
+
 
+		glm::vec3 J = B / 2.0f;
 
+		Error += J == glm::vec3(2, 2.5, 3) ? 0 : 1;
 
+
 
+		glm::vec3 K = 1.0f + A;
 
+		Error += K == glm::vec3(2, 3, 4) ? 0 : 1;
 
+
 
+		glm::vec3 L = 1.0f - B;
 
+		Error += L == glm::vec3(-3, -4, -5) ? 0 : 1;
 
+
 
+		glm::vec3 M = 2.0f * A;
 
+		Error += M == glm::vec3(2, 4, 6) ? 0 : 1;
 
+
 
+		glm::vec3 N = 2.0f / B;
 
+		Error += N == glm::vec3(0.5, 2.0 / 5.0, 2.0 / 6.0) ? 0 : 1;
 
+	}
 
+
 
+	{
 
+		glm::vec3 A(1.0f, 2.0f, 3.0f);
 
+		glm::vec3 B(4.0f, 5.0f, 6.0f);
 
+
 
+		A += B;
 
+		Error += A == glm::vec3(5, 7, 9) ? 0 : 1;
 
+
 
+		A += 1.0f;
 
+		Error += A == glm::vec3(6, 8, 10) ? 0 : 1;
 
+	}
 
+	{
 
+		glm::vec3 A(1.0f, 2.0f, 3.0f);
 
+		glm::vec3 B(4.0f, 5.0f, 6.0f);
 
+
 
+		B -= A;
 
+		Error += B == glm::vec3(3, 3, 3) ? 0 : 1;
 
+
 
+		B -= 1.0f;
 
+		Error += B == glm::vec3(2, 2, 2) ? 0 : 1;
 
+	}
 
+	{
 
+		glm::vec3 A(1.0f, 2.0f, 3.0f);
 
+		glm::vec3 B(4.0f, 5.0f, 6.0f);
 
+
 
+		A *= B;
 
+		Error += A == glm::vec3(4, 10, 18) ? 0 : 1;
 
+
 
+		A *= 2.0f;
 
+		Error += A == glm::vec3(8, 20, 36) ? 0 : 1;
 
+	}
 
+	{
 
+		glm::vec3 A(1.0f, 2.0f, 3.0f);
 
+		glm::vec3 B(4.0f, 5.0f, 6.0f);
 
+
 
+		B /= A;
 
+		Error += B == glm::vec3(4, 2.5, 2) ? 0 : 1;
 
+
 
+		B /= 2.0f;
 
+		Error += B == glm::vec3(2, 1.25, 1) ? 0 : 1;
 
+	}
 
+
 
+	{
 
+		glm::vec3 A(1.0f, 2.0f, 3.0f);
 
+		glm::vec3 B = -A;
 
+		Error += B == glm::vec3(-1.0f, -2.0f, -3.0f) ? 0 : 1;
 
+	}
 
+
 
+	{
 
+		glm::vec3 A(1.0f, 2.0f, 3.0f);
 
+		glm::vec3 B = --A;
 
+		Error += B == glm::vec3(0.0f, 1.0f, 2.0f) ? 0 : 1;
 
+	}
 
+
 
+	{
 
+		glm::vec3 A(1.0f, 2.0f, 3.0f);
 
+		glm::vec3 B = A--;
 
+		Error += B == glm::vec3(0.0f, 1.0f, 2.0f) ? 0 : 1;
 
+	}
 
+
 
+	{
 
+		glm::vec3 A(1.0f, 2.0f, 3.0f);
 
+		glm::vec3 B = ++A;
 
+		Error += B == glm::vec3(2.0f, 3.0f, 4.0f) ? 0 : 1;
 
+	}
 
+
 
+	{
 
+		glm::vec3 A(1.0f, 2.0f, 3.0f);
 
+		glm::vec3 B = A++;
 
+		Error += B == glm::vec3(2.0f, 3.0f, 4.0f) ? 0 : 1;
 
 	}
 
 	}
 
 
 
 	return Error;
 
 	return Error;
 
@@ -263,15 +384,41 @@ int test_vec3_swizzle_functions()
 
     return Error;
 
     return Error;
 
 }
 
 }
 
 
 
+int test_vec3_swizzle_partial()
 
+{
 
+	int Error = 0;
 
+
 
+	glm::vec3 A(1, 2, 3);
 
+
 
+	{
 
+		glm::vec3 B(A.xy, 3.0f);
 
+		Error += A == B ? 0 : 1;
 
+	}
 
+
 
+	{
 
+		glm::vec3 B(1.0f, A.yz);
 
+		Error += A == B ? 0 : 1;
 
+	}
 
+
 
+	{
 
+		glm::vec3 B(A.xyz);
 
+		Error += A == B ? 0 : 1;
 
+	}
 
+
 
+	return Error;
 
+}
 
+
 
 int main()
 
 int main()
 
 {
 
 {
 
 	int Error = 0;
 
 	int Error = 0;
 
 
 
+	Error += test_vec3_ctor();
 
 	Error += test_vec3_operators();
 
 	Error += test_vec3_operators();
 
 	Error += test_vec3_size();
 
 	Error += test_vec3_size();
 
     Error += test_vec3_swizzle3_2();
 
     Error += test_vec3_swizzle3_2();
 
     Error += test_vec3_swizzle3_3();
 
     Error += test_vec3_swizzle3_3();
 
     Error += test_vec3_swizzle_half();
 
     Error += test_vec3_swizzle_half();
 
+	Error += test_vec3_swizzle_partial();
 
     Error += test_vec3_swizzle_operators();
 
     Error += test_vec3_swizzle_operators();
 
     Error += test_vec3_swizzle_functions();
 
     Error += test_vec3_swizzle_functions();

+ 190 - 5
test/core/core_type_vec4.cpp
View File 

@@ -9,6 +9,7 @@
 
 
 
 #include <glm/glm.hpp>
 
 #include <glm/glm.hpp>
 
 #include <glm/gtc/half_float.hpp>
 
 #include <glm/gtc/half_float.hpp>
 
+#include <vector>
 
 
 
 template <int Value>
 
 template <int Value>
 
 struct mask
 
 struct mask
 
@@ -41,14 +42,161 @@ int test_hvec4()
 
 	return 0;
 
 	return 0;
 
 }
 
 }
 
 
 
+int test_vec4_ctor()
 
+{
 
+	int Error = 0;
 
+	
+	{
 
+		glm::vec4 A(1);
 
+		glm::vec4 B(1, 1, 1, 1);
 
+		
+		Error += A == B ? 0 : 1;
 
+	}
 
+	
+	{
 
+		std::vector<glm::vec4> Tests;
 
+		Tests.push_back(glm::vec4(glm::vec2(1, 2), 3, 4));
 
+		Tests.push_back(glm::vec4(1, glm::vec2(2, 3), 4));
 
+		Tests.push_back(glm::vec4(1, 2, glm::vec2(3, 4)));
 
+		Tests.push_back(glm::vec4(glm::vec3(1, 2, 3), 4));
 
+		Tests.push_back(glm::vec4(1, glm::vec3(2, 3, 4)));
 
+		Tests.push_back(glm::vec4(glm::vec2(1, 2), glm::vec2(3, 4)));
 
+		Tests.push_back(glm::vec4(1, 2, 3, 4));
 
+		Tests.push_back(glm::vec4(glm::vec4(1, 2, 3, 4)));
 
+		
+		for(std::size_t i = 0; i < Tests.size(); ++i)
 
+			Error += Tests[i] == glm::vec4(1, 2, 3, 4) ? 0 : 1;
 
+	}
 
+	
+	return Error;
 
+}
 
+
 
 int test_vec4_operators()
 
 int test_vec4_operators()
 
 {
 
 {
 
-	glm::vec4 A(1.0f);
 
-	glm::vec4 B(1.0f);
 
-	bool R = A != B;
 
-	bool S = A == B;
 
+	int Error = 0;
 
+	
+	{
 
+		glm::vec4 A(1.0f);
 
+		glm::vec4 B(1.0f);
 
+		bool R = A != B;
 
+		bool S = A == B;
 
+
 
+		Error += (S && !R) ? 0 : 1;
 
+	}
 
+
 
+	{
 
+		glm::vec4 A(1.0f, 2.0f, 3.0f, 4.0f);
 
+		glm::vec4 B(4.0f, 5.0f, 6.0f, 7.0f);
 
+
 
+		glm::vec4 C = A + B;
 
+		Error += C == glm::vec4(5, 7, 9, 11) ? 0 : 1;
 
+
 
+		glm::vec4 D = B - A;
 
+		Error += D == glm::vec4(3, 3, 3, 3) ? 0 : 1;
 
+
 
+		glm::vec4 E = A * B;
 
+		Error += E == glm::vec4(4, 10, 18, 28) ? 0 : 1;
 
+
 
+		glm::vec4 F = B / A;
 
+		Error += F == glm::vec4(4, 2.5, 2, 7.0f / 4.0f) ? 0 : 1;
 
+
 
+		glm::vec4 G = A + 1.0f;
 
+		Error += G == glm::vec4(2, 3, 4, 5) ? 0 : 1;
 
+
 
+		glm::vec4 H = B - 1.0f;
 
+		Error += H == glm::vec4(3, 4, 5, 6) ? 0 : 1;
 
+
 
+		glm::vec4 I = A * 2.0f;
 
+		Error += I == glm::vec4(2, 4, 6, 8) ? 0 : 1;
 
+
 
+		glm::vec4 J = B / 2.0f;
 
+		Error += J == glm::vec4(2, 2.5, 3, 3.5) ? 0 : 1;
 
+
 
+		glm::vec4 K = 1.0f + A;
 
+		Error += K == glm::vec4(2, 3, 4, 5) ? 0 : 1;
 
+
 
+		glm::vec4 L = 1.0f - B;
 
+		Error += L == glm::vec4(-3, -4, -5, -6) ? 0 : 1;
 
+
 
+		glm::vec4 M = 2.0f * A;
 
+		Error += M == glm::vec4(2, 4, 6, 8) ? 0 : 1;
 
+
 
+		glm::vec4 N = 2.0f / B;
 
+		Error += N == glm::vec4(0.5, 2.0 / 5.0, 2.0 / 6.0, 2.0 / 7.0) ? 0 : 1;
 
+	}
 
 
 
-	return (S && !R) ? 0 : 1;
 
+	{
 
+		glm::vec4 A(1.0f, 2.0f, 3.0f, 4.0f);
 
+		glm::vec4 B(4.0f, 5.0f, 6.0f, 7.0f);
 
+
 
+		A += B;
 
+		Error += A == glm::vec4(5, 7, 9, 11) ? 0 : 1;
 
+
 
+		A += 1.0f;
 
+		Error += A == glm::vec4(6, 8, 10, 12) ? 0 : 1;
 
+	}
 
+	{
 
+		glm::vec4 A(1.0f, 2.0f, 3.0f, 4.0f);
 
+		glm::vec4 B(4.0f, 5.0f, 6.0f, 7.0f);
 
+
 
+		B -= A;
 
+		Error += B == glm::vec4(3, 3, 3, 3) ? 0 : 1;
 
+
 
+		B -= 1.0f;
 
+		Error += B == glm::vec4(2, 2, 2, 2) ? 0 : 1;
 
+	}
 
+	{
 
+		glm::vec4 A(1.0f, 2.0f, 3.0f, 4.0f);
 
+		glm::vec4 B(4.0f, 5.0f, 6.0f, 7.0f);
 
+
 
+		A *= B;
 
+		Error += A == glm::vec4(4, 10, 18, 28) ? 0 : 1;
 
+
 
+		A *= 2.0f;
 
+		Error += A == glm::vec4(8, 20, 36, 56) ? 0 : 1;
 
+	}
 
+	{
 
+		glm::vec4 A(1.0f, 2.0f, 3.0f, 4.0f);
 
+		glm::vec4 B(4.0f, 5.0f, 6.0f, 7.0f);
 
+
 
+		B /= A;
 
+		Error += B == glm::vec4(4, 2.5, 2, 7.0f / 4.0f) ? 0 : 1;
 
+
 
+		B /= 2.0f;
 
+		Error += B == glm::vec4(2, 1.25, 1, 7.0f / 4.0f / 2.0f) ? 0 : 1;
 
+	}
 
+
 
+	{
 
+		glm::vec4 A(1.0f, 2.0f, 3.0f, 4.0f);
 
+		glm::vec4 B = -A;
 
+		Error += B == glm::vec4(-1.0f, -2.0f, -3.0f, -4.0f) ? 0 : 1;
 
+	}
 
+
 
+	{
 
+		glm::vec4 A(1.0f, 2.0f, 3.0f, 4.0f);
 
+		glm::vec4 B = --A;
 
+		Error += B == glm::vec4(0.0f, 1.0f, 2.0f, 3.0f) ? 0 : 1;
 
+	}
 
+
 
+	{
 
+		glm::vec4 A(1.0f, 2.0f, 3.0f, 4.0f);
 
+		glm::vec4 B = A--;
 
+		Error += B == glm::vec4(0.0f, 1.0f, 2.0f, 3.0f) ? 0 : 1;
 
+	}
 
+
 
+	{
 
+		glm::vec4 A(1.0f, 2.0f, 3.0f, 4.0f);
 
+		glm::vec4 B = ++A;
 
+		Error += B == glm::vec4(2.0f, 3.0f, 4.0f, 5.0f) ? 0 : 1;
 
+	}
 
+
 
+	{
 
+		glm::vec4 A(1.0f, 2.0f, 3.0f, 4.0f);
 
+		glm::vec4 B = A++;
 
+		Error += B == glm::vec4(2.0f, 3.0f, 4.0f, 5.0f) ? 0 : 1;
 
+	}
 
+
 
+	return Error;
 
 }
 
 }
 
 
 
 int test_vec4_size()
 
 int test_vec4_size()
 
@@ -65,15 +213,52 @@ int test_vec4_size()
 
 	return Error;
 
 	return Error;
 
 }
 
 }
 
 
 
+int test_vec4_swizzle_partial()
 
+{
 
+	int Error = 0;
 
+
 
+	glm::vec4 A(1, 2, 3, 4);
 
+
 
+	{
 
+		glm::vec4 B(A.xy, A.zw);
 
+		Error += A == B ? 0 : 1;
 
+	}
 
+	{
 
+		glm::vec4 B(A.xy, 3.0f, 4.0f);
 
+		Error += A == B ? 0 : 1;
 
+	}
 
+	{
 
+		glm::vec4 B(1.0f, A.yz, 4.0f);
 
+		Error += A == B ? 0 : 1;
 
+	}
 
+	{
 
+		glm::vec4 B(1.0f, 2.0f, A.zw);
 
+		Error += A == B ? 0 : 1;
 
+	}
 
+
 
+	{
 
+		glm::vec4 B(A.xyz, 4.0f);
 
+		Error += A == B ? 0 : 1;
 
+	}
 
+	{
 
+		glm::vec4 B(1.0f, A.yzw);
 
+		Error += A == B ? 0 : 1;
 
+	}
 
+
 
+	return Error;
 
+}
 
+
 
 int main()
 
 int main()
 
 {
 
 {
 
 	//__m128 DataA = swizzle<X, Y, Z, W>(glm::vec4(1.0f, 2.0f, 3.0f, 4.0f));
 
 	//__m128 DataA = swizzle<X, Y, Z, W>(glm::vec4(1.0f, 2.0f, 3.0f, 4.0f));
 
 	//__m128 DataB = swizzle<W, Z, Y, X>(glm::vec4(1.0f, 2.0f, 3.0f, 4.0f));
 
 	//__m128 DataB = swizzle<W, Z, Y, X>(glm::vec4(1.0f, 2.0f, 3.0f, 4.0f));
 
 
 
 	int Error = 0;
 
 	int Error = 0;
 
+	Error += test_vec4_ctor();
 
 	Error += test_vec4_size();
 
 	Error += test_vec4_size();
 
 	Error += test_vec4_operators();
 
 	Error += test_vec4_operators();
 
 	Error += test_hvec4();
 
 	Error += test_hvec4();
 
+    Error += test_vec4_swizzle_partial();
 
 	return Error;
 
 	return Error;
 
 }
 
 }

+ 1 - 0
test/gtc/CMakeLists.txt
View File 

@@ -3,6 +3,7 @@ glmCreateTestGTC(gtc_matrix_access)
 
 glmCreateTestGTC(gtc_matrix_integer)
 
 glmCreateTestGTC(gtc_matrix_integer)
 
 glmCreateTestGTC(gtc_matrix_inverse)
 
 glmCreateTestGTC(gtc_matrix_inverse)
 
 glmCreateTestGTC(gtc_matrix_transform)
 
 glmCreateTestGTC(gtc_matrix_transform)
 
+glmCreateTestGTC(gtc_noise)
 
 glmCreateTestGTC(gtc_quaternion)
 
 glmCreateTestGTC(gtc_quaternion)
 
 glmCreateTestGTC(gtc_random)
 
 glmCreateTestGTC(gtc_random)
 
 glmCreateTestGTC(gtc_swizzle)
 
 glmCreateTestGTC(gtc_swizzle)

+ 199 - 0
test/gtc/gtc_noise.cpp
View File 

@@ -0,0 +1,199 @@
 
+///////////////////////////////////////////////////////////////////////////////////////////////////
 
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
 
+///////////////////////////////////////////////////////////////////////////////////////////////////
 
+// Created : 2011-04-21
 
+// Updated : 2011-04-26
 
+// Licence : This source is under MIT licence
 
+// File    : test/gtx/noise.cpp
 
+///////////////////////////////////////////////////////////////////////////////////////////////////
 
+
 
+#include <glm/glm.hpp>
 
+#include <glm/gtx/noise.hpp>
 
+#include <gli/gli.hpp>
 
+#include <gli/gtx/loader.hpp>
 
+#include <iostream>
 
+
 
+int test_simplex()
 
+{
 
+	std::size_t const Size = 256;
 
+
 
+	{
 
+		std::vector<glm::byte> ImageData(Size * Size * 3);
 
+		
+		for(std::size_t y = 0; y < Size; ++y)
 
+		for(std::size_t x = 0; x < Size; ++x)
 
+		{
 
+			ImageData[(x + y * Size) * 3 + 0] = glm::byte(glm::simplex(glm::vec2(x / 64.f, y / 64.f)) * 128.f + 127.f);
 
+			ImageData[(x + y * Size) * 3 + 1] = ImageData[(x + y * Size) * 3 + 0];
 
+			ImageData[(x + y * Size) * 3 + 2] = ImageData[(x + y * Size) * 3 + 0];
 
+		}
 
+
 
+		gli::texture2D Texture(1);
 
+		Texture[0] = gli::image2D(glm::uvec2(Size), gli::RGB8U);
 
+		memcpy(Texture[0].data(), &ImageData[0], ImageData.size());
 
+		gli::saveDDS9(Texture, "texture_simplex2d_256.dds");
 
+	}
 
+
 
+	{
 
+		std::vector<glm::byte> ImageData(Size * Size * 3);
 
+		
+		for(std::size_t y = 0; y < Size; ++y)
 
+		for(std::size_t x = 0; x < Size; ++x)
 
+		{
 
+			ImageData[(x + y * Size) * 3 + 0] = glm::byte(glm::simplex(glm::vec3(x / 64.f, y / 64.f, 0.5f)) * 128.f + 127.f);
 
+			ImageData[(x + y * Size) * 3 + 1] = ImageData[(x + y * Size) * 3 + 0];
 
+			ImageData[(x + y * Size) * 3 + 2] = ImageData[(x + y * Size) * 3 + 0];
 
+		}
 
+
 
+		gli::texture2D Texture(1);
 
+		Texture[0] = gli::image2D(glm::uvec2(Size), gli::RGB8U);
 
+		memcpy(Texture[0].data(), &ImageData[0], ImageData.size());
 
+		gli::saveDDS9(Texture, "texture_simplex3d_256.dds");
 
+	}
 
+	
+	{
 
+		std::vector<glm::byte> ImageData(Size * Size * 3);
 
+		
+		for(std::size_t y = 0; y < Size; ++y)
 
+		for(std::size_t x = 0; x < Size; ++x)
 
+		{
 
+			ImageData[(x + y * Size) * 3 + 0] = glm::byte(glm::simplex(glm::vec4(x / 64.f, y / 64.f, 0.5f, 0.5f)) * 128.f + 127.f);
 
+			ImageData[(x + y * Size) * 3 + 1] = ImageData[(x + y * Size) * 3 + 0];
 
+			ImageData[(x + y * Size) * 3 + 2] = ImageData[(x + y * Size) * 3 + 0];
 
+		}
 
+
 
+		gli::texture2D Texture(1);
 
+		Texture[0] = gli::image2D(glm::uvec2(Size), gli::RGB8U);
 
+		memcpy(Texture[0].data(), &ImageData[0], ImageData.size());
 
+		gli::saveDDS9(Texture, "texture_simplex4d_256.dds");
 
+	}
 
+
 
+	return 0;
 
+}
 
+
 
+int test_perlin()
 
+{
 
+	std::size_t const Size = 256;
 
+
 
+	{
 
+		std::vector<glm::byte> ImageData(Size * Size * 3);
 
+		
+		for(std::size_t y = 0; y < Size; ++y)
 
+		for(std::size_t x = 0; x < Size; ++x)
 
+		{
 
+			ImageData[(x + y * Size) * 3 + 0] = glm::byte(glm::perlin(glm::vec2(x / 64.f, y / 64.f)) * 128.f + 127.f);
 
+			ImageData[(x + y * Size) * 3 + 1] = ImageData[(x + y * Size) * 3 + 0];
 
+			ImageData[(x + y * Size) * 3 + 2] = ImageData[(x + y * Size) * 3 + 0];
 
+		}
 
+
 
+		gli::texture2D Texture(1);
 
+		Texture[0] = gli::image2D(glm::uvec2(Size), gli::RGB8U);
 
+		memcpy(Texture[0].data(), &ImageData[0], ImageData.size());
 
+		gli::saveDDS9(Texture, "texture_perlin2d_256.dds");
 
+	}
 
+
 
+	{
 
+		std::vector<glm::byte> ImageData(Size * Size * 3);
 
+		
+		for(std::size_t y = 0; y < Size; ++y)
 
+		for(std::size_t x = 0; x < Size; ++x)
 
+		{
 
+			ImageData[(x + y * Size) * 3 + 0] = glm::byte(glm::perlin(glm::vec3(x / 64.f, y / 64.f, 0.5f)) * 128.f + 127.f);
 
+			ImageData[(x + y * Size) * 3 + 1] = ImageData[(x + y * Size) * 3 + 0];
 
+			ImageData[(x + y * Size) * 3 + 2] = ImageData[(x + y * Size) * 3 + 0];
 
+		}
 
+
 
+		gli::texture2D Texture(1);
 
+		Texture[0] = gli::image2D(glm::uvec2(Size), gli::RGB8U);
 
+		memcpy(Texture[0].data(), &ImageData[0], ImageData.size());
 
+		gli::saveDDS9(Texture, "texture_perlin3d_256.dds");
 
+	}
 
+	
+	{
 
+		std::vector<glm::byte> ImageData(Size * Size * 3);
 
+		
+		for(std::size_t y = 0; y < Size; ++y)
 
+		for(std::size_t x = 0; x < Size; ++x)
 
+		{
 
+			ImageData[(x + y * Size) * 3 + 0] = glm::byte(glm::perlin(glm::vec4(x / 64.f, y / 64.f, 0.5f, 0.5f)) * 128.f + 127.f);
 
+			ImageData[(x + y * Size) * 3 + 1] = ImageData[(x + y * Size) * 3 + 0];
 
+			ImageData[(x + y * Size) * 3 + 2] = ImageData[(x + y * Size) * 3 + 0];
 
+		}
 
+
 
+		gli::texture2D Texture(1);
 
+		Texture[0] = gli::image2D(glm::uvec2(Size), gli::RGB8U);
 
+		memcpy(Texture[0].data(), &ImageData[0], ImageData.size());
 
+		gli::saveDDS9(Texture, "texture_perlin4d_256.dds");
 
+	}
 
+
 
+	return 0;
 
+}
 
+
 
+int test_perlin_pedioric()
 
+{
 
+	std::size_t const Size = 256;
 
+
 
+	{
 
+		std::vector<glm::byte> ImageData(Size * Size * 3);
 
+		
+		for(std::size_t y = 0; y < Size; ++y)
 
+		for(std::size_t x = 0; x < Size; ++x)
 
+		{
 
+			ImageData[(x + y * Size) * 3 + 0] = glm::byte(glm::perlin(glm::vec2(x / 64.f, y / 64.f), glm::vec2(2.0f)) * 128.f + 127.f);
 
+			ImageData[(x + y * Size) * 3 + 1] = ImageData[(x + y * Size) * 3 + 0];
 
+			ImageData[(x + y * Size) * 3 + 2] = ImageData[(x + y * Size) * 3 + 0];
 
+		}
 
+
 
+		gli::texture2D Texture(1);
 
+		Texture[0] = gli::image2D(glm::uvec2(Size), gli::RGB8U);
 
+		memcpy(Texture[0].data(), &ImageData[0], ImageData.size());
 
+		gli::saveDDS9(Texture, "texture_perlin_pedioric_2d_256.dds");
 
+	}
 
+
 
+	{
 
+		std::vector<glm::byte> ImageData(Size * Size * 3);
 
+		
+		for(std::size_t y = 0; y < Size; ++y)
 
+		for(std::size_t x = 0; x < Size; ++x)
 
+		{
 
+			ImageData[(x + y * Size) * 3 + 0] = glm::byte(glm::perlin(glm::vec3(x / 64.f, y / 64.f, 0.5f), glm::vec3(2.0f)) * 128.f + 127.f);
 
+			ImageData[(x + y * Size) * 3 + 1] = ImageData[(x + y * Size) * 3 + 0];
 
+			ImageData[(x + y * Size) * 3 + 2] = ImageData[(x + y * Size) * 3 + 0];
 
+		}
 
+
 
+		gli::texture2D Texture(1);
 
+		Texture[0] = gli::image2D(glm::uvec2(Size), gli::RGB8U);
 
+		memcpy(Texture[0].data(), &ImageData[0], ImageData.size());
 
+		gli::saveDDS9(Texture, "texture_perlin_pedioric_3d_256.dds");
 
+	}
 
+	
+	{
 
+		std::vector<glm::byte> ImageData(Size * Size * 3);
 
+		
+		for(std::size_t y = 0; y < Size; ++y)
 
+		for(std::size_t x = 0; x < Size; ++x)
 
+		{
 
+			ImageData[(x + y * Size) * 3 + 0] = glm::byte(glm::perlin(glm::vec4(x / 64.f, y / 64.f, 0.5f, 0.5f), glm::vec4(2.0f)) * 128.f + 127.f);
 
+			ImageData[(x + y * Size) * 3 + 1] = ImageData[(x + y * Size) * 3 + 0];
 
+			ImageData[(x + y * Size) * 3 + 2] = ImageData[(x + y * Size) * 3 + 0];
 
+		}
 
+
 
+		gli::texture2D Texture(1);
 
+		Texture[0] = gli::image2D(glm::uvec2(Size), gli::RGB8U);
 
+		memcpy(Texture[0].data(), &ImageData[0], ImageData.size());
 
+		gli::saveDDS9(Texture, "texture_perlin_pedioric_4d_256.dds");
 
+	}
 
+
 
+	return 0;
 
+}
 
+
 
+int main()
 
+{
 
+	int Error = 0;
 
+
 
+	Error += test_simplex();
 
+	Error += test_perlin();
 
+	Error += test_perlin_pedioric();
 
+
 
+	return Error;
 
+}

+ 70 - 0
test/gtc/gtc_swizzle.cpp
View File 

@@ -121,13 +121,83 @@ int test_swizzle_vec4_const_static()
 
 	return Error;
 
 	return Error;
 
 }
 
 }
 
 
 
+int test_swizzle_vec3_partial()
 
+{
 
+	int Error = 0;
 
+
 
+	glm::ivec3 A(0, 1, 2);
 
+
 
+	{
 
+		glm::ivec3 B(A.swizzle(glm::R, glm::G, glm::B));	
+		Error += (A == B) ? 0 : 1;
 
+	}
 
+
 
+	{
 
+		glm::ivec3 B(A.swizzle(glm::R, glm::G), 2);	
+		Error += (A == B) ? 0 : 1;
 
+	}
 
+
 
+	{
 
+		glm::ivec3 B(0, A.swizzle(glm::G, glm::B));	
+		Error += (A == B) ? 0 : 1;
 
+	}
 
+
 
+	return Error;
 
+}
 
+
 
+int test_swizzle_vec4_partial()
 
+{
 
+	int Error = 0;
 
+
 
+	glm::ivec4 A(0, 1, 2, 3);
 
+
 
+	{
 
+		glm::ivec4 B(A.swizzle(glm::R, glm::G, glm::B), 3);	
+		Error += (A == B) ? 0 : 1;
 
+	}
 
+
 
+	{
 
+		glm::ivec4 B(A.swizzle(glm::R, glm::G), 2, 3);	
+		Error += (A == B) ? 0 : 1;
 
+	}
 
+
 
+	{
 
+		glm::ivec4 B(0, A.swizzle(glm::G, glm::B), 3);	
+		Error += (A == B) ? 0 : 1;
 
+	}
 
+
 
+	{
 
+		glm::ivec4 B(0, 1, A.swizzle(glm::B, glm::A));	
+		Error += (A == B) ? 0 : 1;
 
+	}
 
+
 
+	{
 
+		glm::ivec4 B(A.swizzle(glm::X, glm::Y), A.swizzle(glm::Z, glm::W));	
+		Error += (A == B) ? 0 : 1;
 
+	}
 
+
 
+	{
 
+		glm::ivec4 B(A.swizzle(glm::X, glm::Y), glm::vec2(2, 3));	
+		Error += (A == B) ? 0 : 1;
 
+	}
 
+
 
+	{
 
+		glm::ivec4 B(glm::vec2(0, 1), A.swizzle(glm::Z, glm::W));	
+		Error += (A == B) ? 0 : 1;
 
+	}
 
+
 
+	return Error;
 
+}
 
+
 
 int main()
 
 int main()
 
 {
 
 {
 
 	int Error = 0;
 
 	int Error = 0;
 
+	Error += test_swizzle_vec3_partial();
 
 	Error += test_swizzle_vec4_ref_dynamic();
 
 	Error += test_swizzle_vec4_ref_dynamic();
 
 	Error += test_swizzle_vec4_ref_static();
 
 	Error += test_swizzle_vec4_ref_static();
 
 	Error += test_swizzle_vec4_const_dynamic();
 
 	Error += test_swizzle_vec4_const_dynamic();
 
 	Error += test_swizzle_vec4_const_static();
 
 	Error += test_swizzle_vec4_const_static();
 
+	Error += test_swizzle_vec4_partial();
 
 
 
 	return Error;
 
 	return Error;
 
 }
 
 }

+ 2 - 0
test/gtx/CMakeLists.txt
View File 

@@ -1,4 +1,6 @@
 
 glmCreateTestGTC(gtx_bit)
 
 glmCreateTestGTC(gtx_bit)
 
+glmCreateTestGTC(gtx_gradient_paint)
 
+glmCreateTestGTC(gtx_integer)
 
 glmCreateTestGTC(gtx_noise)
 
 glmCreateTestGTC(gtx_noise)
 
 glmCreateTestGTC(gtx_quaternion)
 
 glmCreateTestGTC(gtx_quaternion)
 
 glmCreateTestGTC(gtx_random)
 
 glmCreateTestGTC(gtx_random)

+ 41 - 0
test/gtx/gtx_gradient_paint.cpp
View File 

@@ -0,0 +1,41 @@
 
+///////////////////////////////////////////////////////////////////////////////////////////////////
 
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
 
+///////////////////////////////////////////////////////////////////////////////////////////////////
 
+// Created : 2011-10-13
 
+// Updated : 2011-10-13
 
+// Licence : This source is under MIT licence
 
+// File    : test/gtx/gradient_paint.cpp
 
+///////////////////////////////////////////////////////////////////////////////////////////////////
 
+
 
+#include <glm/glm.hpp>
 
+#include <glm/gtx/gradient_paint.hpp>
 
+
 
+int test_radialGradient()
 
+{
 
+	int Error = 0;
 
+	
+	float Gradient = glm::radialGradient(glm::vec2(0), 1.0f, glm::vec2(1), glm::vec2(0.5));
 
+	
+	return Error;
 
+}
 
+
 
+int test_linearGradient()
 
+{
 
+	int Error = 0;
 
+
 
+	float Gradient = glm::linearGradient(glm::vec2(0), glm::vec2(1), glm::vec2(0.5));
 
+
 
+	return Error;
 
+}
 
+
 
+int main()
 
+{
 
+	int Error = 0;
 
+
 
+    Error += test_radialGradient();
 
+    Error += test_linearGradient();
 
+    
+	return Error;
 
+}
 
+
 
+

+ 66 - 0
test/gtx/gtx_integer.cpp
View File 

@@ -0,0 +1,66 @@
 
+///////////////////////////////////////////////////////////////////////////////////////////////////
 
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
 
+///////////////////////////////////////////////////////////////////////////////////////////////////
 
+// Created : 2011-10-11
 
+// Updated : 2011-10-11
 
+// Licence : This source is under MIT licence
 
+// File    : test/gtx/gtx_integer.cpp
 
+///////////////////////////////////////////////////////////////////////////////////////////////////
 
+
 
+#include <glm/glm.hpp>
 
+#include <glm/gtx/integer.hpp>
 
+#include <glm/gtx/epsilon.hpp>
 
+#include <iostream>
 
+
 
+int test_floor_log2()
 
+{
 
+	int Error = 0;
 
+
 
+	for(std::size_t i = 1; i < 1000000; ++i)
 
+	{
 
+		glm::uint A = glm::floor_log2(glm::uint(i));
 
+		glm::uint B = glm::uint(glm::log2(double(i))); // Will fail with float, lack of accuracy
 
+
 
+		Error += A == B ? 0 : 1;
 
+		assert(!Error);
 
+	}
 
+
 
+	return Error;
 
+}
 
+
 
+int test_log2()
 
+{
 
+	int Error = 0;
 
+
 
+	for(std::size_t i = 1; i < 1000000; ++i)
 
+	{
 
+		glm::uint A = glm::log2(glm::uint(i));
 
+		double B = glm::log2(double(i));
 
+
 
+		Error += glm::equalEpsilon(double(A), B, 1.0) ? 0 : 1;
 
+		//assert(!Error);
 
+	}
 
+
 
+	return Error;
 
+}
 
+
 
+int test_nlz()
 
+{
 
+	int Error = 0;
 
+
 
+	for(std::size_t i = 1; i < 33; ++i)
 
+		printf("%d, %d\n", glm::nlz(i), 31u - glm::findMSB(i));
 
+
 
+	return Error;
 
+}
 
+
 
+int main()
 
+{
 
+	int Error = 0;
 
+
 
+	Error += test_nlz();
 
+	Error += test_floor_log2();
 
+	Error += test_log2();
 
+
 
+	return Error;
 
+}

+ 9 - 9
test/gtx/gtx_noise.cpp
View File 

@@ -23,7 +23,7 @@ int test_simplex()
 
 		for(std::size_t y = 0; y < Size; ++y)
 
 		for(std::size_t y = 0; y < Size; ++y)
 
 		for(std::size_t x = 0; x < Size; ++x)
 
 		for(std::size_t x = 0; x < Size; ++x)
 
 		{
 
 		{
 
-			ImageData[(x + y * Size) * 3 + 0] = glm::byte(glm::simplex(glm::vec2(x / 16.f, y / 16.f)) * 128.f + 127.f);
 
+			ImageData[(x + y * Size) * 3 + 0] = glm::byte(glm::simplex(glm::vec2(x / 64.f, y / 64.f)) * 128.f + 127.f);
 
 			ImageData[(x + y * Size) * 3 + 1] = ImageData[(x + y * Size) * 3 + 0];
 
 			ImageData[(x + y * Size) * 3 + 1] = ImageData[(x + y * Size) * 3 + 0];
 
 			ImageData[(x + y * Size) * 3 + 2] = ImageData[(x + y * Size) * 3 + 0];
 
 			ImageData[(x + y * Size) * 3 + 2] = ImageData[(x + y * Size) * 3 + 0];
 
 		}
 
 		}
 
@@ -40,7 +40,7 @@ int test_simplex()
 
 		for(std::size_t y = 0; y < Size; ++y)
 
 		for(std::size_t y = 0; y < Size; ++y)
 
 		for(std::size_t x = 0; x < Size; ++x)
 
 		for(std::size_t x = 0; x < Size; ++x)
 
 		{
 
 		{
 
-			ImageData[(x + y * Size) * 3 + 0] = glm::byte(glm::simplex(glm::vec3(x / 16.f, y / 16.f, 0.5f)) * 128.f + 127.f);
 
+			ImageData[(x + y * Size) * 3 + 0] = glm::byte(glm::simplex(glm::vec3(x / 64.f, y / 64.f, 0.5f)) * 128.f + 127.f);
 
 			ImageData[(x + y * Size) * 3 + 1] = ImageData[(x + y * Size) * 3 + 0];
 
 			ImageData[(x + y * Size) * 3 + 1] = ImageData[(x + y * Size) * 3 + 0];
 
 			ImageData[(x + y * Size) * 3 + 2] = ImageData[(x + y * Size) * 3 + 0];
 
 			ImageData[(x + y * Size) * 3 + 2] = ImageData[(x + y * Size) * 3 + 0];
 
 		}
 
 		}
 
@@ -57,7 +57,7 @@ int test_simplex()
 
 		for(std::size_t y = 0; y < Size; ++y)
 
 		for(std::size_t y = 0; y < Size; ++y)
 
 		for(std::size_t x = 0; x < Size; ++x)
 
 		for(std::size_t x = 0; x < Size; ++x)
 
 		{
 
 		{
 
-			ImageData[(x + y * Size) * 3 + 0] = glm::byte(glm::simplex(glm::vec4(x / 16.f, y / 16.f, 0.5f, 0.5f)) * 128.f + 127.f);
 
+			ImageData[(x + y * Size) * 3 + 0] = glm::byte(glm::simplex(glm::vec4(x / 64.f, y / 64.f, 0.5f, 0.5f)) * 128.f + 127.f);
 
 			ImageData[(x + y * Size) * 3 + 1] = ImageData[(x + y * Size) * 3 + 0];
 
 			ImageData[(x + y * Size) * 3 + 1] = ImageData[(x + y * Size) * 3 + 0];
 
 			ImageData[(x + y * Size) * 3 + 2] = ImageData[(x + y * Size) * 3 + 0];
 
 			ImageData[(x + y * Size) * 3 + 2] = ImageData[(x + y * Size) * 3 + 0];
 
 		}
 
 		}
 
@@ -81,7 +81,7 @@ int test_perlin()
 
 		for(std::size_t y = 0; y < Size; ++y)
 
 		for(std::size_t y = 0; y < Size; ++y)
 
 		for(std::size_t x = 0; x < Size; ++x)
 
 		for(std::size_t x = 0; x < Size; ++x)
 
 		{
 
 		{
 
-			ImageData[(x + y * Size) * 3 + 0] = glm::byte(glm::perlin(glm::vec2(x / 16.f, y / 16.f)) * 128.f + 127.f);
 
+			ImageData[(x + y * Size) * 3 + 0] = glm::byte(glm::perlin(glm::vec2(x / 64.f, y / 64.f)) * 128.f + 127.f);
 
 			ImageData[(x + y * Size) * 3 + 1] = ImageData[(x + y * Size) * 3 + 0];
 
 			ImageData[(x + y * Size) * 3 + 1] = ImageData[(x + y * Size) * 3 + 0];
 
 			ImageData[(x + y * Size) * 3 + 2] = ImageData[(x + y * Size) * 3 + 0];
 
 			ImageData[(x + y * Size) * 3 + 2] = ImageData[(x + y * Size) * 3 + 0];
 
 		}
 
 		}
 
@@ -98,7 +98,7 @@ int test_perlin()
 
 		for(std::size_t y = 0; y < Size; ++y)
 
 		for(std::size_t y = 0; y < Size; ++y)
 
 		for(std::size_t x = 0; x < Size; ++x)
 
 		for(std::size_t x = 0; x < Size; ++x)
 
 		{
 
 		{
 
-			ImageData[(x + y * Size) * 3 + 0] = glm::byte(glm::perlin(glm::vec3(x / 16.f, y / 16.f, 0.5f)) * 128.f + 127.f);
 
+			ImageData[(x + y * Size) * 3 + 0] = glm::byte(glm::perlin(glm::vec3(x / 64.f, y / 64.f, 0.5f)) * 128.f + 127.f);
 
 			ImageData[(x + y * Size) * 3 + 1] = ImageData[(x + y * Size) * 3 + 0];
 
 			ImageData[(x + y * Size) * 3 + 1] = ImageData[(x + y * Size) * 3 + 0];
 
 			ImageData[(x + y * Size) * 3 + 2] = ImageData[(x + y * Size) * 3 + 0];
 
 			ImageData[(x + y * Size) * 3 + 2] = ImageData[(x + y * Size) * 3 + 0];
 
 		}
 
 		}
 
@@ -115,7 +115,7 @@ int test_perlin()
 
 		for(std::size_t y = 0; y < Size; ++y)
 
 		for(std::size_t y = 0; y < Size; ++y)
 
 		for(std::size_t x = 0; x < Size; ++x)
 
 		for(std::size_t x = 0; x < Size; ++x)
 
 		{
 
 		{
 
-			ImageData[(x + y * Size) * 3 + 0] = glm::byte(glm::perlin(glm::vec4(x / 16.f, y / 16.f, 0.5f, 0.5f)) * 128.f + 127.f);
 
+			ImageData[(x + y * Size) * 3 + 0] = glm::byte(glm::perlin(glm::vec4(x / 64.f, y / 64.f, 0.5f, 0.5f)) * 128.f + 127.f);
 
 			ImageData[(x + y * Size) * 3 + 1] = ImageData[(x + y * Size) * 3 + 0];
 
 			ImageData[(x + y * Size) * 3 + 1] = ImageData[(x + y * Size) * 3 + 0];
 
 			ImageData[(x + y * Size) * 3 + 2] = ImageData[(x + y * Size) * 3 + 0];
 
 			ImageData[(x + y * Size) * 3 + 2] = ImageData[(x + y * Size) * 3 + 0];
 
 		}
 
 		}
 
@@ -139,7 +139,7 @@ int test_perlin_pedioric()
 
 		for(std::size_t y = 0; y < Size; ++y)
 
 		for(std::size_t y = 0; y < Size; ++y)
 
 		for(std::size_t x = 0; x < Size; ++x)
 
 		for(std::size_t x = 0; x < Size; ++x)
 
 		{
 
 		{
 
-			ImageData[(x + y * Size) * 3 + 0] = glm::byte(glm::perlin(glm::vec2(x / 16.f, y / 16.f), glm::vec2(2.0f)) * 128.f + 127.f);
 
+			ImageData[(x + y * Size) * 3 + 0] = glm::byte(glm::perlin(glm::vec2(x / 64.f, y / 64.f), glm::vec2(2.0f)) * 128.f + 127.f);
 
 			ImageData[(x + y * Size) * 3 + 1] = ImageData[(x + y * Size) * 3 + 0];
 
 			ImageData[(x + y * Size) * 3 + 1] = ImageData[(x + y * Size) * 3 + 0];
 
 			ImageData[(x + y * Size) * 3 + 2] = ImageData[(x + y * Size) * 3 + 0];
 
 			ImageData[(x + y * Size) * 3 + 2] = ImageData[(x + y * Size) * 3 + 0];
 
 		}
 
 		}
 
@@ -156,7 +156,7 @@ int test_perlin_pedioric()
 
 		for(std::size_t y = 0; y < Size; ++y)
 
 		for(std::size_t y = 0; y < Size; ++y)
 
 		for(std::size_t x = 0; x < Size; ++x)
 
 		for(std::size_t x = 0; x < Size; ++x)
 
 		{
 
 		{
 
-			ImageData[(x + y * Size) * 3 + 0] = glm::byte(glm::perlin(glm::vec3(x / 16.f, y / 16.f, 0.5f), glm::vec3(2.0f)) * 128.f + 127.f);
 
+			ImageData[(x + y * Size) * 3 + 0] = glm::byte(glm::perlin(glm::vec3(x / 64.f, y / 64.f, 0.5f), glm::vec3(2.0f)) * 128.f + 127.f);
 
 			ImageData[(x + y * Size) * 3 + 1] = ImageData[(x + y * Size) * 3 + 0];
 
 			ImageData[(x + y * Size) * 3 + 1] = ImageData[(x + y * Size) * 3 + 0];
 
 			ImageData[(x + y * Size) * 3 + 2] = ImageData[(x + y * Size) * 3 + 0];
 
 			ImageData[(x + y * Size) * 3 + 2] = ImageData[(x + y * Size) * 3 + 0];
 
 		}
 
 		}
 
@@ -173,7 +173,7 @@ int test_perlin_pedioric()
 
 		for(std::size_t y = 0; y < Size; ++y)
 
 		for(std::size_t y = 0; y < Size; ++y)
 
 		for(std::size_t x = 0; x < Size; ++x)
 
 		for(std::size_t x = 0; x < Size; ++x)
 
 		{
 
 		{
 
-			ImageData[(x + y * Size) * 3 + 0] = glm::byte(glm::perlin(glm::vec4(x / 16.f, y / 16.f, 0.5f, 0.5f), glm::vec4(2.0f)) * 128.f + 127.f);
 
+			ImageData[(x + y * Size) * 3 + 0] = glm::byte(glm::perlin(glm::vec4(x / 64.f, y / 64.f, 0.5f, 0.5f), glm::vec4(2.0f)) * 128.f + 127.f);
 
 			ImageData[(x + y * Size) * 3 + 1] = ImageData[(x + y * Size) * 3 + 0];
 
 			ImageData[(x + y * Size) * 3 + 1] = ImageData[(x + y * Size) * 3 + 0];
 
 			ImageData[(x + y * Size) * 3 + 2] = ImageData[(x + y * Size) * 3 + 0];
 
 			ImageData[(x + y * Size) * 3 + 2] = ImageData[(x + y * Size) * 3 + 0];
 
 		}
 
 		}

Some files were not shown because too many files changed in this diff