Initial commit based on GLM 0.9.B.1 code

CMakeLists.txt

@@ -0,0 +1,14 @@
+cmake_minimum_required(VERSION 2.6 FATAL_ERROR)
+cmake_policy(VERSION 2.6)
+
+project(glm)
+
+add_definitions(-D_CRT_SECURE_NO_WARNINGS)
+#add_definitions(-mfpmath=sse)
+#add_definitions(-msse3)
+#add_definitions(-Wextra)
+
+add_subdirectory(glm)
+add_subdirectory(doc)
+add_subdirectory(sample)
+add_subdirectory(test)

doc/CMakeLists.txt

@@ -0,0 +1,10 @@
+set(NAME glm-doc)
+
+file(GLOB ROOT_CPP src/*.cpp)
+file(GLOB ROOT_XML src/*.xml)
+file(GLOB ROOT_XSL src/*.xsl)
+
+source_group("XML Files" FILES ${ROOT_XML})
+source_group("XSL Files" FILES ${ROOT_XSL})
+
+add_executable(${NAME} ${ROOT_CPP} ${ROOT_XML} ${ROOT_XSL})

doc/build/build.bat

@@ -0,0 +1,9 @@
+xalan -m -o ..\index.html     ..\src\data.xml   ..\src\news.xsl
+xalan -m -o ..\download.html  ..\src\data.xml	..\src\download.xsl
+xalan -m -o ..\changelog.html ..\src\data.xml 	..\src\changelog.xsl
+xalan -m -o ..\issue.html     ..\src\data.xml   ..\src\issue.xsl
+xalan -m -o ..\link.html      ..\src\data.xml   ..\src\link.xsl
+xalan -m -o ..\goodies.html   ..\src\data.xml   ..\src\goodies.xsl
+xalan -m -o ..\about.html     ..\src\data.xml   ..\src\about.xsl
+xalan -m -o ..\code.html      ..\src\data.xml   ..\src\code.xsl
+pause

doc/common/doxygen/doxygen.css

@@ -0,0 +1,475 @@
+BODY,H1,H2,H3,H4,H5,H6,P,CENTER,TD,TH,UL,DL,DIV {
+	font-family: Geneva, Arial, Helvetica, sans-serif;
+}
+BODY,TD {
+	font-size: 90%;
+}
+H1 {
+	text-align: center;
+	font-size: 160%;
+}
+H2 {
+	font-size: 120%;
+}
+H3 {
+	font-size: 100%;
+}
+CAPTION { 
+	font-weight: bold 
+}
+DIV.qindex {
+	width: 100%;
+	background-color: #ff8000;/*#e8eef2;*/
+	border: 1px solid #ff8000;
+	text-align: center;
+	margin: 2px;
+	padding: 2px;
+	line-height: 140%;
+}
+DIV.navpath {
+	width: 100%;
+	background-color: #ff8000;/*e8eef2*/
+	border: 1px solid #ff8000;
+	text-align: center;
+	margin: 2px;
+	padding: 2px;
+	line-height: 140%;
+}
+DIV.navtab {
+       background-color: #ff8000;/*#e8eef2;*/
+       border: 1px solid #ff8000;
+       text-align: center;
+       margin: 2px;
+       margin-right: 15px;
+       padding: 2px;
+}
+TD.navtab {
+       font-size: 70%;
+}
+A.qindex {
+       text-decoration: none;
+       font-weight: bold;
+       color: #ff8000;
+}
+A.qindex:visited {
+       text-decoration: none;
+       font-weight: bold;
+       color: #ff8000
+}
+A.qindex:hover {
+	text-decoration: none;
+	background-color: #ffe0c0;
+}
+A.qindexHL {
+	text-decoration: none;
+	font-weight: bold;
+	background-color: #ffe0c0;
+	color: #ffffff;
+	border: 1px double #ffe0c0;
+}
+A.qindexHL:hover {
+	text-decoration: none;
+	background-color: #ffe0c0;
+	color: #ffffff;
+}
+A.qindexHL:visited { 
+	text-decoration: none; 
+	background-color: #ffe0c0; 
+	color: #ffffff 
+}
+A.el { 
+	text-decoration: none; 
+	font-weight: bold 
+}
+A.elRef { 
+	font-weight: bold 
+}
+A.code:link { 
+	text-decoration: none; 
+	font-weight: normal; 
+	color: #ff8000
+}
+A.code:visited { 
+	text-decoration: none; 
+	font-weight: normal; 
+	color: #ff8000
+}
+A.codeRef:link { 
+	font-weight: normal; 
+	color: #ff8000
+}
+A.codeRef:visited { 
+	font-weight: normal; 
+	color: #ff8000
+}
+A:hover { 
+	text-decoration: none; 	
+	background-color: #f2f2ff 
+}
+DL.el { 
+	margin-left: -1cm 
+}
+.fragment {
+       font-family: monospace, fixed;
+       font-size: 95%;
+}
+PRE.fragment {
+	border: 1px solid #CCCCCC;
+	background-color: #f5f5f5;
+	margin-top: 4px;
+	margin-bottom: 4px;
+	margin-left: 2px;
+	margin-right: 8px;
+	padding-left: 6px;
+	padding-right: 6px;
+	padding-top: 4px;
+	padding-bottom: 4px;
+}
+DIV.ah { 
+	background-color: black; 
+	font-weight: bold; 
+	color: #ffffff; 
+	margin-bottom: 3px; 
+	margin-top: 3px 
+}
+
+DIV.groupHeader {
+       margin-left: 16px;
+       margin-top: 12px;
+       margin-bottom: 6px;
+       font-weight: bold;
+}
+DIV.groupText { 
+	margin-left: 16px; 
+	font-style: italic; 
+	font-size: 90% 
+}
+BODY {
+	background: white;
+	color: black;
+	margin-right: 20px;
+	margin-left: 20px;
+}
+TD.indexkey {
+	background-color: #fff0e0;/*#e8eef2;*/
+	font-weight	   : normal;
+	padding-right  : 10px;
+	padding-top    : 8px;
+	padding-left   : 10px;
+	padding-bottom : 8px;
+	margin-left    : 0px;
+	margin-right   : 0px;
+	margin-top     : 2px;
+	margin-bottom  : 2px;
+	border: 0px solid #CCCCCC;
+	-moz-border-radius: 8px 8px 8px 8px;
+}
+TD.indexvalue {
+	background-color: #fff0e0;/*#e8eef2;*/
+	font-style: italic;
+	padding-right  : 10px;
+	padding-top    : 8px;
+	padding-left   : 10px;
+	padding-bottom : 8px;
+	margin-left    : 0px;
+	margin-right   : 0px;
+	margin-top     : 2px;
+	margin-bottom  : 2px;
+	border: 0px solid #CCCCCC;
+	-moz-border-radius: 8px 8px 8px 8px;
+}
+TR.memlist {
+	background-color: #f0f0f0; 
+}
+P.formulaDsp { 
+	text-align: center; 
+}
+IMG.formulaDsp {
+}
+IMG.formulaInl { 
+	vertical-align: middle; 
+}
+SPAN.keyword       { color: #008000 }
+SPAN.keywordtype   { color: #604020 }
+SPAN.keywordflow   { color: #e08000 }
+SPAN.comment       { color: #800000 }
+SPAN.preprocessor  { color: #806020 }
+SPAN.stringliteral { color: #002080 }
+SPAN.charliteral   { color: #008080 }
+SPAN.vhdldigit     { color: #ff00ff }
+SPAN.vhdlchar      { color: #000000 }
+SPAN.vhdlkeyword   { color: #700070 }
+SPAN.vhdllogic     { color: #ff0000 }
+
+.mdescLeft {
+	padding: 0px 8px 4px 8px;
+	font-size: 80%;
+	font-style: italic;
+	background-color: #FAFAFA;
+	border-top: 1px none #E0E0E0;
+	border-right: 1px none #E0E0E0;
+	border-bottom: 1px none #E0E0E0;
+	border-left: 1px none #E0E0E0;
+	margin: 0px;
+}
+.mdescRight {
+        padding: 0px 8px 4px 8px;
+	font-size: 80%;
+	font-style: italic;
+	background-color: #FAFAFA;
+	border-top: 1px none #E0E0E0;
+	border-right: 1px none #E0E0E0;
+	border-bottom: 1px none #E0E0E0;
+	border-left: 1px none #E0E0E0;
+	margin: 0px;
+}
+.memItemLeft {
+	padding: 1px 0px 0px 8px;
+	margin: 4px;
+	border-top-width: 1px;
+	border-right-width: 1px;
+	border-bottom-width: 1px;
+	border-left-width: 1px;
+	border-top-color: #E0E0E0;
+	border-right-color: #E0E0E0;
+	border-bottom-color: #E0E0E0;
+	border-left-color: #E0E0E0;
+	border-top-style: solid;
+	border-right-style: none;
+	border-bottom-style: none;
+	border-left-style: none;
+	background-color: #FAFAFA;
+	font-size: 80%;
+}
+.memItemRight {
+	padding: 1px 8px 0px 8px;
+	margin: 4px;
+	border-top-width: 1px;
+	border-right-width: 1px;
+	border-bottom-width: 1px;
+	border-left-width: 1px;
+	border-top-color: #E0E0E0;
+	border-right-color: #E0E0E0;
+	border-bottom-color: #E0E0E0;
+	border-left-color: #E0E0E0;
+	border-top-style: solid;
+	border-right-style: none;
+	border-bottom-style: none;
+	border-left-style: none;
+	background-color: #FAFAFA;
+	font-size: 80%;
+}
+.memTemplItemLeft {
+	padding: 1px 0px 0px 8px;
+	margin: 4px;
+	border-top-width: 1px;
+	border-right-width: 1px;
+	border-bottom-width: 1px;
+	border-left-width: 1px;
+	border-top-color: #E0E0E0;
+	border-right-color: #E0E0E0;
+	border-bottom-color: #E0E0E0;
+	border-left-color: #E0E0E0;
+	border-top-style: none;
+	border-right-style: none;
+	border-bottom-style: none;
+	border-left-style: none;
+	background-color: #FAFAFA;
+	font-size: 80%;
+}
+.memTemplItemRight {
+	padding: 1px 8px 0px 8px;
+	margin: 4px;
+	border-top-width: 1px;
+	border-right-width: 1px;
+	border-bottom-width: 1px;
+	border-left-width: 1px;
+	border-top-color: #E0E0E0;
+	border-right-color: #E0E0E0;
+	border-bottom-color: #E0E0E0;
+	border-left-color: #E0E0E0;
+	border-top-style: none;
+	border-right-style: none;
+	border-bottom-style: none;
+	border-left-style: none;
+	background-color: #FAFAFA;
+	font-size: 80%;
+}
+.memTemplParams {
+	padding: 1px 0px 0px 8px;
+	margin: 4px;
+	border-top-width: 1px;
+	border-right-width: 1px;
+	border-bottom-width: 1px;
+	border-left-width: 1px;
+	border-top-color: #E0E0E0;
+	border-right-color: #E0E0E0;
+	border-bottom-color: #E0E0E0;
+	border-left-color: #E0E0E0;
+	border-top-style: solid;
+	border-right-style: none;
+	border-bottom-style: none;
+	border-left-style: none;
+	color: #606060;
+	background-color: #FAFAFA;
+	font-size: 80%;
+}
+.search { 
+	color: #003399;
+	font-weight: bold;
+}
+FORM.search {
+	margin-bottom: 0px;
+	margin-top: 0px;
+}
+INPUT.search { 
+	font-size: 75%;
+	color: #402000;
+	font-weight: normal;
+	background-color: #ffe0c0;
+}
+TD.tiny { 
+	font-size: 75%;
+}
+a {
+	color: #402000;
+}
+a:visited {
+	color: #804000;
+}
+.dirtab { 
+	padding: 4px;
+	border-collapse: collapse;
+	border: 1px solid #fff0e0;
+}
+TH.dirtab { 
+	background: #fff0e0;
+	font-weight: bold;
+}
+HR { 
+	height: 1px;
+	border: none;
+	border-top: 1px solid black;
+}
+
+/* Style for detailed member documentation */
+.memtemplate {
+	font-size: 80%;
+	color: #606060;
+	font-weight: normal;
+	margin-left: 3px;
+} 
+.memnav { 
+	background-color: #ffe0c0;
+	border: 1px solid #ffe0c0;
+	text-align: center;
+	margin: 2px;
+	margin-right: 15px;
+	padding: 2px;
+}
+.memitem {
+	padding: 4px;
+	background-color: #fff0e0;
+	border-width: 1px;
+	border-style: solid;
+	border-color: #fff0e0;
+	-moz-border-radius: 8px 8px 8px 8px;
+}
+.memname {
+	white-space: nowrap;
+	font-weight: bold;
+}
+.memdoc{
+	padding-left: 10px;
+}
+.memproto {
+	background-color: #ffe0c0;
+	width: 100%;
+	border-width: 1px;
+	border-style: solid;
+	border-color: #ffe0c0;
+	font-weight: bold;
+	-moz-border-radius: 8px 8px 8px 8px;
+}
+.paramkey {
+	text-align: right;
+}
+.paramtype {
+	white-space: nowrap;
+}
+.paramname {
+	color: #602020;
+	font-style: italic;
+	white-space: nowrap;
+}
+/* End Styling for detailed member documentation */
+
+/* for the tree view */
+.ftvtree {
+	font-family: sans-serif;
+	margin:0.5em;
+}
+/* these are for tree view when used as main index */
+.directory { 
+	font-size: 9pt; 
+	font-weight: bold; 
+}
+.directory h3 { 
+	margin: 0px; 
+	margin-top: 1em; 
+	font-size: 11pt; 
+}
+
+/* The following two styles can be used to replace the root node title */
+/* with an image of your choice.  Simply uncomment the next two styles, */
+/* specify the name of your image and be sure to set 'height' to the */
+/* proper pixel height of your image. */
+
+/* .directory h3.swap { */
+/* 	height: 61px; */
+/* 	background-repeat: no-repeat; */
+/* 	background-image: url("yourimage.gif"); */
+/* } */
+/* .directory h3.swap span { */
+/* 	display: none; */
+/* } */
+
+.directory > h3 { 
+	margin-top: 0; 
+}
+.directory p { 
+	margin: 0px; 
+	white-space: nowrap; 
+}
+.directory div { 
+	display: none; 
+	margin: 0px; 
+}
+.directory img { 
+	vertical-align: -30%; 
+}
+/* these are for tree view when not used as main index */
+.directory-alt { 
+	font-size: 100%; 
+	font-weight: bold; 
+}
+.directory-alt h3 { 
+	margin: 0px; 
+	margin-top: 1em; 
+	font-size: 11pt; 
+}
+.directory-alt > h3 { 
+	margin-top: 0; 
+}
+.directory-alt p { 
+	margin: 0px; 
+	white-space: nowrap; 
+}
+.directory-alt div { 
+	display: none; 
+	margin: 0px; 
+}
+.directory-alt img { 
+	vertical-align: -30%; 
+}
+

doc/common/doxygen/tabs.css

@@ -0,0 +1,102 @@
+/* tabs styles, based on http://www.alistapart.com/articles/slidingdoors */
+
+DIV.tabs
+{
+   float            : left;
+   width            : 100%;
+   background       : url("tab_b.gif") repeat-x bottom;
+   margin-bottom    : 4px;
+}
+
+DIV.tabs UL
+{
+   margin           : 0px;
+   padding-left     : 10px;
+   list-style       : none;
+}
+
+DIV.tabs LI, DIV.tabs FORM
+{
+   display          : inline;
+   margin           : 0px;
+   padding          : 0px;
+}
+
+DIV.tabs FORM
+{
+   float            : right;
+}
+
+DIV.tabs A
+{
+   float            : left;
+   background       : url("tab_r.gif") no-repeat right top;
+   border-bottom    : 1px solid #FF8000;
+   font-size        : x-small;
+   font-weight      : bold;
+   text-decoration  : none;
+}
+
+DIV.tabs A:hover
+{
+   background-position: 100% -150px;
+}
+
+DIV.tabs A:link, DIV.tabs A:visited,
+DIV.tabs A:active, DIV.tabs A:hover
+{
+       color: #000000;/*#1A419D;*/
+}
+
+DIV.tabs SPAN
+{
+   float            : left;
+   display          : block;
+   background       : url("tab_l.gif") no-repeat left top;
+   padding          : 5px 9px;
+   white-space      : nowrap;
+}
+
+DIV.tabs INPUT
+{
+   float            : right;
+   display          : inline;
+   font-size        : 1em;
+}
+
+DIV.tabs TD
+{
+   font-size        : x-small;
+   font-weight      : bold;
+   text-decoration  : none;
+}
+
+
+
+/* Commented Backslash Hack hides rule from IE5-Mac \*/
+DIV.tabs SPAN {float : none;}
+/* End IE5-Mac hack */
+
+DIV.tabs A:hover SPAN
+{
+   background-position: 0% -150px;
+}
+
+DIV.tabs LI.current A
+{
+   background-position: 100% -150px;
+   border-width     : 0px;
+}
+
+DIV.tabs LI.current SPAN
+{
+   background-position: 0% -150px;
+   padding-bottom   : 6px;
+}
+
+DIV.navpath
+{
+   background       : none;
+   border           : none;
+   border-bottom    : 1px solid #FF8000;
+}

doc/common/style.css

@@ -0,0 +1,202 @@
+body
+{
+	background-color:#fff8f0;
+	width:100%;
+}
+
+table
+{
+	background-color:#ffffff;
+	width:800px;
+	margin-left:auto;
+	margin-right:auto;
+}
+
+table.principale
+{
+	background-color:#ff8000;
+	border-style:none;
+	border-width:0px;
+	border-spacing:0px;
+	margin-top: 0px;
+	margin-bottom: 0px;
+	margin-right: 0px;
+	margin-left: 0px;
+	padding-right: 0px;
+	padding-left: 0px;
+	padding-bottom: 0px;
+	padding-top: 0px;
+	width:100%;
+}
+
+tr.principale
+{
+	background-color:#ff8000;
+	border-style:none;
+	border-width:0px;
+	border-spacing:0px;
+	margin-top: 0px;
+	margin-bottom: 0px;
+	margin-right: 0px;
+	margin-left: 0px;
+	padding-right: 0px;
+	padding-left: 0px;
+	padding-bottom: 0px;
+	padding-top: 0px;	
+}
+
+div.title1
+{
+    text-align:center;
+    font-size:48px;
+    border-style:solid;
+    border-width:0px;
+    color:#000000;
+}
+
+div.title2
+{
+    text-align:left;
+    font-size:20px;
+    font-weight:bold;
+    color:#000000;
+}
+
+div.title3
+{
+    text-align:center;
+    font-size:16px;
+    border-style:none;
+    border-width:1px;
+}
+
+div.title4
+{
+    text-align:left;
+    font-size:16px;
+    font-weight:bolder;
+    color:#FF8000;
+}
+
+div.title-date
+{
+    text-align:right;
+    font-size:16px;
+    font-weight:bolder;
+    color:#FF8000;
+}
+
+div.menu1
+{
+    text-align:center;
+    font-size:16px;
+    font-weight:bolder;
+}
+
+div.menu2
+{
+    text-align:center;
+    font-size:16px;
+}
+
+div.news-separator
+{
+	text-align:center;
+	color:#FF8000;
+}
+
+div.email
+{
+	text-align:center;
+}
+
+div.image
+{
+	text-align:right;
+}
+
+img.menu-img
+{
+    text-align:center;
+    font-size:16px;
+    border-color:#000000;
+    border-style:solid;
+    border-width:0px;    
+}
+
+div.paragraph
+{
+    /*text-indent:32px;   */
+    text-align:justify;
+}
+
+div.block
+{
+	padding-right: 16px;
+	padding-left: 16px;
+}
+
+div.include
+{
+	color:#0000FF;
+}
+
+spam.key
+{
+	color:#0000FF;
+}
+
+div.comment
+{
+	color:#008000;
+}
+
+td.page
+{
+    vertical-align:top;
+	padding-right: 32px;
+	padding-left: 32px;
+	padding-bottom: 0px;
+	padding-top: 0px;
+	width:100%;
+}
+
+td.menu
+{
+    vertical-align:top;
+    text-align:right;
+    border-width:0px;
+    border-right-style:solid;
+    border-color:#000000;
+    width:160px;
+	padding-right: 32px;
+	padding-left: 0px;
+	padding-bottom: 0px;
+	padding-top: 0px;
+}
+/*
+a.menu
+{
+    color:#FF8000;
+    font-weight:bolder;   
+}
+*/
+a.menu
+{
+    color:#008000;    
+}
+
+a
+{
+    color:#008000;    
+}
+
+div.issue-content
+{
+    text-indent:32px;   
+}
+
+div.issue-title
+{
+    font-weight:bold;    
+}

doc/readme.txt

@@ -0,0 +1,248 @@
+=============================
+GLM 0.9.A.1 final: 2010-02-09
+-----------------------------
+- Removed deprecated features
+- Internal redesign
+
+=============================
+GLM 0.8.4.4 final: 2010-01-25
+-----------------------------
+- Fixed warnings
+
+=============================
+GLM 0.8.4.3 final: 2009-11-16
+-----------------------------
+- Fixed Half float arithmetic
+- Fixed setup defines
+
+=============================
+GLM 0.8.4.2 final: 2009-10-19
+-----------------------------
+- Fixed Half float adds
+
+=============================
+GLM 0.8.4.1 final: 2009-10-05
+-----------------------------
+- Updated documentation
+- Fixed MacOS X build
+
+=============================
+GLM 0.8.4.0 final: 2009-09-16
+-----------------------------
+- Added GCC 4.4 and VC2010 support
+- Added matrix optimizations
+
+=============================
+GLM 0.8.3.5 final: 2009-08-11
+-----------------------------
+- Fixed bugs
+
+=============================
+GLM 0.8.3.4 final: 2009-08-10
+-----------------------------
+- Updated GLM according GLSL 1.5 spec
+- Fixed bugs
+
+=============================
+GLM 0.8.3.3 final: 2009-06-25
+-----------------------------
+- Fixed bugs
+
+=============================
+GLM 0.8.3.2 final: 2009-06-04
+-----------------------------
+- Added GLM_GTC_quaternion
+- Added GLM_GTC_type_precision
+
+=============================
+GLM 0.8.3.1 final: 2009-05-21
+-----------------------------
+- Fixed old extension system.
+
+=============================
+GLM 0.8.3.0 final: 2009-05-06
+-----------------------------
+- Added stable extensions.
+- Added new extension system.
+
+=============================
+GLM 0.8.2.3 final: 2009-04-01
+-----------------------------
+- Fixed bugs.
+
+=============================
+GLM 0.8.2.2 final: 2009-02-24
+-----------------------------
+- Fixed bugs.
+
+=============================
+GLM 0.8.2.1 final: 2009-02-13
+-----------------------------
+- Fixed bugs.
+
+=============================
+GLM 0.8.2 final: 2009-01-21
+-----------------------------
+- Fixed bugs.
+
+=============================
+GLM 0.8.1 final: 2008-10-30
+-----------------------------
+- Fixed bugs.
+
+=============================
+GLM 0.8.0 final: 2008-10-23
+-----------------------------
+- New method to use extension.
+
+=============================
+GLM 0.8.0 beta3: 2008-10-10
+-----------------------------
+- Added CMake support for GLM tests.
+
+=============================
+GLM 0.8.0 beta2: 2008-10-04
+-----------------------------
+- Improved half scalars and vectors support.
+
+=============================
+GLM 0.8.0 beta1: 2008-09-26
+-----------------------------
+- Improved GLSL conformance
+- Added GLSL 1.30 support
+- Improved API documentation
+
+=============================
+GLM 0.7.6 final: 2008-08-08
+---------------------------
+- Improved C++ standard comformance
+- Added Static assert for types checking
+
+===========================
+GLM 0.7.5 final: 2008-07-05
+---------------------------
+- Added build message system with Visual Studio
+- Pedantic build with GCC
+
+===========================
+GLM 0.7.4 final: 2008-06-01
+---------------------------
+- Added external dependencies system.
+
+===========================
+GLM 0.7.3 final: 2008-05-24
+---------------------------
+- Fixed bugs
+- Added new extension group
+
+===========================
+GLM 0.7.2 final: 2008-04-27
+---------------------------
+- Updated documentation
+- Added preprocessor options
+
+===========================
+GLM 0.7.1 final: 2008-03-24
+---------------------------
+- Disabled half on GCC
+- Fixed extensions
+
+===========================
+GLM 0.7.0 final: 2008-03-22
+---------------------------
+- Changed to MIT license
+- Added new documentation
+
+===========================
+GLM 0.6.4 : 2007-12-10
+---------------------------
+- Fixed swizzle operators
+
+===========================
+GLM 0.6.3 : 2007-11-05
+---------------------------
+- Fixed type data accesses
+- Fixed 3DSMax sdk conflict
+
+===========================
+GLM 0.6.2 : 2007-10-08
+---------------------------
+- Fixed extension
+
+===========================
+GLM 0.6.1 : 2007-10-07
+---------------------------
+- Fixed a namespace error
+- Added extensions
+
+===========================
+GLM 0.6.0 : 2007-09-16
+---------------------------
+- Added new extension namespace mecanium
+- Added Automatic compiler detection
+
+===========================
+GLM 0.5.1 : 2007-02-19
+---------------------------
+- Fixed swizzle operators
+
+===========================
+GLM 0.5.0 : 2007-01-06
+---------------------------
+- Upgrated to GLSL 1.2
+- Added swizzle operators
+- Added setup settings
+
+===========================
+GLM 0.4.1 : 2006-05-22
+---------------------------
+- Added OpenGL examples
+
+===========================
+GLM 0.4.0 : 2006-05-17
+---------------------------
+- Added missing operators to vec* and mat*
+- Added first GLSL 1.2 features
+- Fixed windows.h before glm.h when windows.h required
+
+===========================
+GLM 0.3.2 : 2006-04-21
+---------------------------
+- Fixed texcoord components access.
+- Fixed mat4 and imat4 division operators.
+
+===========================
+GLM 0.3.1 : 2006-03-28
+---------------------------
+- Added GCC 4.0 support under MacOS X.
+- Added GCC 4.0 and 4.1 support under Linux.
+- Added code optimisations.
+
+===========================
+GLM 0.3 : 2006-02-19
+---------------------------
+- Improved GLSL type conversion and construction compliance.
+- Added experimental extensions.
+- Added Doxygen Documentation.
+- Added code optimisations.
+- Fixed bugs.
+
+===========================
+GLM 0.2: 2005-05-05
+---------------------------
+- Improve adaptative from GLSL.
+- Add experimental extensions based on OpenGL extension process.
+- Fixe bugs.
+
+===========================
+GLM 0.1: 2005-02-21
+---------------------------
+- Add vec2, vec3, vec4 GLSL types
+- Add ivec2, ivec3, ivec4 GLSL types
+- Add bvec2, bvec3, bvec4 GLSL types
+- Add mat2, mat3, mat4 GLSL types
+- Add almost all functions
+
+===========================
+Christophe [Groove] Riccio, glm|AT|g-truc|DOT|net
+

doc/src/about.xsl

@@ -0,0 +1,68 @@
+<?xml version="1.0" encoding="iso-8859-1"?>
+<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
+  <xsl:output method="html" media-type="text/html; charset=ISO-8859-1" />
+
+  <xsl:include href="./util.xsl" />
+
+  <xsl:template match="/">
+    <html>
+      <head>
+        <title>OpenGL Mathematics : About</title>
+        <meta http-equiv="Content-Language" content="en" />
+        <meta http-equiv="Content-Type" content="application/xhtml+xml; charset=iso-8859-1" />
+        <meta name="copyright" content="G-Truc Creation" />
+        <link href="./common/style.css" rel="stylesheet" media="screen, print, embossed" type="text/css" />
+      </head>
+      <body>
+        <table>
+          <tr>
+            <td class="menu">
+              <xsl:apply-templates select="./glm/menu" />
+            </td>
+            <td class="page">
+              <div class="title1">
+                <img src="./common/title.png" alt="OpenGL Mathematics" />
+              </div>
+              <xsl:apply-templates select="./glm/about-short" />
+              <br />
+              <xsl:apply-templates select="./glm/about-long" />
+
+              <div class="email">
+                <img src="./common/email.png" alt="email not available as text" />
+              </div>
+              <div class="news-separator">_________________</div>
+              <br />
+              <div class="title3">
+                <xsl:value-of select="./glm/@copyright" />
+                <a href="http://www.g-truc.net">G-Truc Creation</a>
+              </div>
+            </td>
+          </tr>
+        </table>
+      </body>
+    </html>
+  </xsl:template>
+
+  <xsl:template match="about-long">
+    <div>
+      <div class="title-date">
+        <xsl:value-of select="./@date" />
+      </div>
+      <div class="title4">
+        <xsl:value-of select="./@title" />
+      </div>
+      <div>
+        <xsl:if test="./paragraph">
+          <xsl:apply-templates select="./paragraph" />
+        </xsl:if>
+        <xsl:if test="./list">
+          <xsl:apply-templates select="./list" />
+        </xsl:if>
+        <xsl:apply-templates select="./source" />
+      </div>
+      <div class="news-separator">_________________</div>
+      <br />
+    </div>
+  </xsl:template>
+
+</xsl:stylesheet>

doc/src/bug.xsl

@@ -0,0 +1,116 @@
+<?xml version="1.0" encoding="iso-8859-1"?>
+<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
+  <xsl:output method="html" media-type="text/html; charset=ISO-8859-1" />
+
+  <xsl:include href="./util.xsl" />
+
+  <xsl:template match="/">
+    <html>
+      <head>
+        <title>OpenGL Mathematics : Bugs</title>
+        <meta http-equiv="Content-Language" content="en" />
+        <meta http-equiv="Content-Type" content="application/xhtml+xml; charset=iso-8859-1" />
+        <meta name="copyright" content="&#65533; 2005 C-Truc Creation" />
+        <link href="./common/style.css" rel="stylesheet" media="screen, print, embossed" type="text/css" />
+      </head>
+      <body>
+        <div class="title1">
+          <img src="./common/title.png" alt="OpenGL Mathematics" />
+        </div>
+        <table>
+          <tr>
+            <td class="menu">
+              <div class="menu1">
+                <a class="menu" href="./glm/downloads/section/download/@link">
+                  Download <xsl:value-of select="./glm/downloads/section/download/@name" />
+                </a>
+              </div>
+              <hr />
+              <div class="menu2">
+                <a class="menu" href="./index.html">News</a>
+              </div>
+              <div class="menu2">
+                <a class="menu" href="./download.html">Downloads</a>
+              </div>
+              <div class="menu2">
+                <a class="menu" href="./changelog.html">Changelog</a>
+              </div>
+              <div class="menu2">
+                <a class="menu" href="./html/index.html">Documentation</a>
+              </div>
+              <div class="menu2">
+                <a class="menu" href="http://glf.svn.sourceforge.net/viewvc/glf">SVN Browse</a>
+              </div>
+              <div class="menu2">
+                <a class="menu" href="https://sourceforge.net/tracker/?group_id=129808&amp;atid=901445">Bug tracker</a>
+              </div>
+              <div class="menu2">
+                <a class="menu" href="https://sourceforge.net/tracker/?group_id=129808&amp;atid=715891">Feature requests</a>
+              </div>
+              <div class="menu2">
+                <a class="menu" href="./link.html">Links</a>
+              </div>
+              <hr />
+              <div class="menu2">
+                <a href="http://validator.w3.org/check/referer">
+                  <img class="menu-img" src="http://www.w3.org/Icons/valid-xhtml11" alt="Valid XHTML 1.1!" />
+                </a>
+              </div>
+              <div class="menu2">
+                <a href="http://www.opengl.org">
+                  <img class="menu-img" src="./common/opengl.jpg" alt="OpenGL"/>
+                </a>
+              </div>
+              <div class="menu2">
+                <a href="http://www.sourceforge.net">
+                  <img class="menu-img" src="./common/sourceforge.gif" alt="SourceForge"/>
+                </a>
+              </div>
+              <div class="menu2">
+                <a href="http://www.g-truc.net">
+                  <img class="menu-img" src="./common/g-truc.jpg" alt="G-Truc"/>
+                </a>
+              </div>
+              <hr />
+            </td>
+            <td class="page">
+              <xsl:apply-templates select="./glm/bugs" />
+            </td>
+          </tr>
+        </table>
+        <xsl:value-of select="./glm/@copyright" />
+        <a href="http://www.g-truc.net">G-Truc Creation</a>
+        </div>
+      </body>
+    </html>
+  </xsl:template>
+
+  <xsl:template match="bugs">
+    <div>
+      <div class="title2">Bugs</div>
+      <br />
+      <xsl:apply-templates select="./bug" />
+    </div>
+  </xsl:template>
+
+  <xsl:template match="bug">
+    <div class="issue-title">
+      <xsl:value-of select="./@number"/>) <xsl:value-of select="./@title"/><br />
+    </div>
+    <div>
+      <xsl:apply-templates select="./entry" />
+      <br />
+      <div class="issue-content">
+        STATUE : <xsl:value-of select="./@statue"/>, <xsl:value-of select="./@date"/>
+      </div>
+    </div>
+    <br />
+  </xsl:template>
+
+  <xsl:template match="entry">
+    <div class="issue-content">
+      <xsl:value-of select="./@title"/>: <xsl:value-of select="."/>
+    </div>
+  </xsl:template>
+
+</xsl:stylesheet>

doc/src/changelog.xsl

@@ -0,0 +1,55 @@
+<?xml version="1.0" encoding="iso-8859-1"?>
+<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
+  <xsl:output method="html" media-type="text/html; charset=ISO-8859-1" />
+
+  <xsl:include href="./util.xsl" />
+
+  <xsl:template match="/">
+    <html>
+      <head>
+        <title>OpenGL Mathematics : Changelog</title>
+        <meta http-equiv="Content-Language" content="en" />
+        <meta http-equiv="Content-Type" content="application/xhtml+xml; charset=iso-8859-1" />
+        <meta name="copyright" content="G-Truc Creation" />
+        <link href="./common/style.css" rel="stylesheet" media="screen, print, embossed" type="text/css" />
+      </head>
+      <body>
+        <table>
+          <tr>
+            <td class="menu">
+              <xsl:apply-templates select="./glm/menu" />
+            </td>
+            <td class="page">
+              <div class="title1">
+                <img src="./common/title.png" alt="OpenGL Mathematics" />
+              </div>
+              <xsl:apply-templates select="./glm/about-short" />
+              <br />
+              <xsl:apply-templates select="./glm/changelog/update" />
+              <div class="title3">
+                <xsl:value-of select="./glm/@copyright" />
+                <a href="http://www.g-truc.net">G-Truc Creation</a>
+              </div>
+            </td>
+          </tr>
+        </table>
+      </body>
+    </html>
+  </xsl:template>
+
+  <xsl:template match="update">
+    <div class="title4">
+      <xsl:value-of select="./@date"/>: <br />
+    </div>
+    <xsl:apply-templates select="./entry" />
+    <div class="news-separator">_________________</div>
+    <br />
+  </xsl:template>
+
+  <xsl:template match="entry">
+    <div class="issue-content">
+      - <xsl:value-of select="."/><br />
+    </div>
+  </xsl:template>
+
+</xsl:stylesheet>

doc/src/code.xsl

@@ -0,0 +1,111 @@
+<?xml version="1.0" encoding="iso-8859-1"?>
+<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
+  <xsl:output method="html" media-type="text/html; charset=ISO-8859-1" />
+
+  <xsl:include href="./util.xsl" />
+
+  <xsl:template match="/">
+	  <html>
+	  <head>
+		  <title>OpenGL Mathematics: Code</title>
+		  <meta http-equiv="Content-Language" content="en" />
+		  <meta http-equiv="Content-Type" content="application/xhtml+xml; charset=iso-8859-1" />
+		  <meta name="copyright" content="G-Truc Creation" />
+		  <link href="./common/style.css" rel="stylesheet" media="screen, print, embossed" type="text/css" />
+	  </head>
+	  <body>
+      <table>
+        <tr>
+          <td class="menu">
+            <xsl:apply-templates select="./glm/menu" />
+          </td>
+          <td class="page">
+            <!--div class="title1">OpenGL Mathematics</div-->
+            <div class="title1"><img src="./common/title.png" alt="OpenGL Mathematics" /></div>
+            <xsl:apply-templates select="./glm/about-short" />
+            <br />
+            <xsl:apply-templates select="./glm/codes/code" />
+            <div class="title3">
+              <xsl:value-of select="./glm/@copyright" /> <a href="http://www.g-truc.net">G-Truc Creation</a>
+            </div>
+          </td>
+        </tr>
+      </table>
+    </body>
+    </html>
+  </xsl:template>
+
+  <xsl:template match="code">
+    <div>
+      <div class="title4">
+        <xsl:value-of select="./@date" /> | <xsl:value-of select="./@title" />
+      </div>
+      <div>
+        <xsl:apply-templates />
+      </div>
+      <div class="news-separator">_________________</div>
+      <br />
+    </div>
+  </xsl:template>
+  
+<!--
+  <xsl:template match="code">
+    <div>
+      <xsl:apply-templates select="./include" />
+      <br />
+      <xsl:apply-templates select="./function" />
+    </div>
+  </xsl:template>
+
+  <xsl:template match="comment">
+    <div class="comment"><xsl:apply-templates select="." /></div>
+  </xsl:template>
+
+  <xsl:template match="include">
+    <div class="include">
+      <xsl:if test="contains(./@type, 'system')">
+        #include <![CDATA[<]]><xsl:value-of select="./@file" /><![CDATA[>]]>
+      </xsl:if>
+      <xsl:if test="contains(./@type, 'local')">
+        #include <![CDATA["]]><xsl:value-of select="./@file" /><![CDATA["]]>
+      </xsl:if>
+    </div>
+  </xsl:template>
+  
+  <xsl:template match="function">
+    <div>
+      <xsl:value-of select="./@return" /><xsl:text> </xsl:text>
+      <xsl:value-of select="./@name" />(<xsl:apply-templates select="./parameters" />)
+    </div>
+    <xsl:apply-templates select="./content" />
+    <br />
+  </xsl:template>
+
+  <xsl:template match="content">
+    <xsl:apply-templates select="./block" />
+  </xsl:template>
+  
+  <xsl:template match="parameter">
+    <xsl:value-of select="./@type" /> <xsl:value-of select="./@name" />
+    <xsl:text> </xsl:text>
+  </xsl:template>
+
+  <xsl:template match="block">
+    {
+      <div class="block">
+        <xsl:apply-templates />
+      </div>
+      }
+    </xsl:template>
+
+  <xsl:template match="line">
+    <div>
+      <xsl:apply-templates />
+    </div>
+  </xsl:template>
+
+  <xsl:template match="key">
+    <spam class="key"><xsl:apply-templates select="." /></spam>
+  </xsl:template>
+-->
+</xsl:stylesheet>

doc/src/download.xsl

@@ -0,0 +1,78 @@
+<?xml version="1.0" encoding="iso-8859-1"?>
+<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
+  <xsl:output method="html" media-type="text/html; charset=ISO-8859-1" />
+
+  <xsl:include href="./util.xsl" />
+
+  <xsl:template match="/">
+    <html>
+      <head>
+        <title>OpenGL Mathematics : Downloads</title>
+        <meta http-equiv="Content-Language" content="en" />
+        <meta http-equiv="Content-Type" content="application/xhtml+xml; charset=iso-8859-1" />
+        <meta name="copyright" content="G-Truc Creation" />
+        <link href="./common/style.css" rel="stylesheet" media="screen, print, embossed" type="text/css" />
+      </head>
+      <body>
+        <table>
+          <tr>
+            <td class="menu">
+              <xsl:apply-templates select="./glm/menu" />
+            </td>
+            <td class="page">
+              <div class="title1">
+                <img src="./common/title.png" alt="OpenGL Mathematics" />
+              </div>
+              <xsl:apply-templates select="./glm/about-short" />
+              <br />
+              <div>
+                <div class="title4">Current release</div>
+                <xsl:apply-templates select="./download" />
+              </div>
+              <div class="issue-content">
+                <xsl:value-of select="/glm/downloads/section/download/@date"/>:
+                <a href="{/glm/downloads/section/download/@link}">
+                  <xsl:value-of select="/glm/downloads/section/download/@name" />
+                </a>
+                (<xsl:value-of select="/glm/downloads/section/download/@size"/>)
+              </div>
+              <div class="news-separator">_________________</div>
+              <br />
+              <xsl:apply-templates select="./glm/downloads/section" />
+
+              <div class="email">
+                <img src="./common/email.png" alt="email not available as text" />
+              </div>
+              <div class="news-separator">_________________</div>
+              <br />
+              <div class="title3">
+                <xsl:value-of select="./glm/@copyright" />
+                <a href="http://www.g-truc.net">G-Truc Creation</a>
+              </div>
+            </td>
+          </tr>
+        </table>
+      </body>
+    </html>
+  </xsl:template>
+
+  <xsl:template match="section">
+    <div>
+      <div class="title4">
+        <xsl:value-of select="./@name"/>
+      </div>
+      <xsl:apply-templates select="./download" />
+    </div>
+    <div class="news-separator">_________________</div>
+    <br />
+  </xsl:template>
+
+  <xsl:template match="download">
+    <div class="issue-content">
+      <xsl:value-of select="./@date"/>: <a href="{./@link}">
+        <xsl:value-of select="./@name"/>
+      </a> (<xsl:value-of select="./@size"/>)
+    </div>
+  </xsl:template>
+
+</xsl:stylesheet>

doc/src/dummy.cpp

@@ -0,0 +1,4 @@
+int main()
+{
+
+}

doc/src/goodies.xsl

@@ -0,0 +1,79 @@
+<?xml version="1.0" encoding="iso-8859-1"?>
+<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
+  <xsl:output method="html" media-type="text/html; charset=ISO-8859-1" />
+
+  <xsl:include href="./util.xsl" />
+
+  <xsl:template match="/">
+    <html>
+      <head>
+        <title>OpenGL Mathematics: Goodies</title>
+        <meta http-equiv="Content-Language" content="en" />
+        <meta http-equiv="Content-Type" content="application/xhtml+xml; charset=iso-8859-1" />
+        <meta name="copyright" content="G-Truc Creation" />
+        <link href="./common/style.css" rel="stylesheet" media="screen, print, embossed" type="text/css" />
+      </head>
+      <body>
+        <table>
+          <tr>
+            <td class="menu">
+              <xsl:apply-templates select="./glm/menu" />
+            </td>
+            <td class="page">
+              <div class="title1">
+                <img src="./common/title.png" alt="OpenGL Mathematics" />
+              </div>
+              <xsl:apply-templates select="./glm/about-short" />
+              <br />
+              <xsl:apply-templates select="./glm/goodies/goodie" />
+
+              <div class="email">
+                <img src="./common/email.png" alt="email not available as text" />
+              </div>
+              <div class="news-separator">_________________</div>
+              <br />
+              <div class="title3">
+                <xsl:value-of select="./glm/@copyright" />
+                <a href="http://www.g-truc.net">G-Truc Creation</a>
+              </div>
+            </td>
+          </tr>
+        </table>
+      </body>
+    </html>
+  </xsl:template>
+
+  <xsl:template match="goodie">
+    <div>
+      <div class="title-date">
+        <xsl:value-of select="./@date" />
+      </div>
+      <div class="title4">
+        <xsl:value-of select="./@title" />
+      </div>
+      <div>
+        <table style="width:100%;">
+          <tr style="width:100%;">
+            <td>
+              <xsl:if test="./paragraph">
+                <xsl:apply-templates select="./paragraph" />
+              </xsl:if>
+              <xsl:if test="./list">
+                <xsl:apply-templates select="./list" />
+              </xsl:if>
+              <xsl:apply-templates select="./source" />
+            </td>
+            <td style="text-align:right;">
+              <a ref="{./@image}">
+                <img src="{./@image-mini}" alt=" " />
+              </a>
+            </td>
+          </tr>
+        </table>
+      </div>
+      <div class="news-separator">_________________</div>
+      <br />
+    </div>
+  </xsl:template>
+
+</xsl:stylesheet>

doc/src/issue.xsl

@@ -0,0 +1,120 @@
+<?xml version="1.0" encoding="iso-8859-1"?>
+<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
+  <xsl:output method="html" media-type="text/html; charset=ISO-8859-1" />
+
+  <xsl:include href="./util.xsl" />
+
+  <xsl:template match="/">
+    <html>
+      <head>
+        <title>OpenGL Mathematics : Issues</title>
+        <meta http-equiv="Content-Language" content="fr, be, ca, lu, ch" />
+        <meta http-equiv="Content-Type" content="application/xhtml+xml; charset=iso-8859-1" />
+        <meta name="copyright" content="&#65533; 2005 C-Truc Creation" />
+        <link href="./common/style.css" rel="stylesheet" media="screen, print, embossed" type="text/css" />
+      </head>
+      <body>
+        <div class="title1">
+          <img src="./common/title.png" alt="OpenGL Mathematics" />
+        </div>
+        <table>
+          <tr>
+            <td class="menu">
+              <div class="menu1">
+                <a class="menu" href="./glm/downloads/section/download/@link">
+                  Download <xsl:value-of select="./glm/downloads/section/download/@name" />
+                </a>
+              </div>
+              <hr />
+              <div class="menu2">
+                <a class="menu" href="./index.html">News</a>
+              </div>
+              <div class="menu2">
+                <a class="menu" href="./download.html">Downloads</a>
+              </div>
+              <div class="menu2">
+                <a class="menu" href="./changelog.html">Changelog</a>
+              </div>
+              <div class="menu2">
+                <a class="menu" href="./glm-manual.pdf">User manual</a>
+              </div>
+              <div class="menu2">
+                <a class="menu" href="./html/index.html">API Documentation</a>
+              </div>
+              <div class="menu2">
+                <a class="menu" href="http://glf.svn.sourceforge.net/viewvc/glf">SVN Browse</a>
+              </div>
+              <div class="menu2">
+                <a class="menu" href="https://sourceforge.net/tracker/?group_id=129808&amp;atid=901445">Bug tracker</a>
+              </div>
+              <div class="menu2">
+                <a class="menu" href="https://sourceforge.net/tracker/?group_id=129808&amp;atid=715891">Feature requests</a>
+              </div>
+              <div class="menu2">
+                <a class="menu" href="./link.html">Links</a>
+              </div>
+              <hr />
+              <div class="menu2">
+                <a href="http://validator.w3.org/check/referer">
+                  <img class="menu-img" src="http://www.w3.org/Icons/valid-xhtml11" alt="Valid XHTML 1.1!" />
+                </a>
+              </div>
+              <div class="menu2">
+                <a href="http://www.opengl.org">
+                  <img class="menu-img" src="./common/opengl.jpg" alt="OpenGL"/>
+                </a>
+              </div>
+              <div class="menu2">
+                <a href="http://www.sourceforge.net">
+                  <img class="menu-img" src="./common/sourceforge.gif" alt="SourceForge"/>
+                </a>
+              </div>
+              <div class="menu2">
+                <a href="http://www.g-truc.net">
+                  <img class="menu-img" src="./common/g-truc.jpg" alt="G-Truc"/>
+                </a>
+              </div>
+              <hr />
+            </td>
+            <td class="page">
+              <xsl:apply-templates select="./glm/issues" />
+            </td>
+          </tr>
+        </table>
+        <div class="title3">
+          <xsl:value-of select="./glm/@copyright" />
+          <a href="http://www.g-truc.net">G-Truc Creation</a>
+        </div>
+      </body>
+    </html>
+  </xsl:template>
+
+  <xsl:template match="issues">
+    <div>
+      <div class="title2">Problématiques</div>
+      <br />
+      <xsl:apply-templates select="./issue" />
+    </div>
+  </xsl:template>
+
+  <xsl:template match="issue">
+    <div class="issue-title">
+      <xsl:value-of select="./@number"/>) <xsl:value-of select="./@title"/><br />
+    </div>
+    <div>
+      <xsl:apply-templates select="./entry" />
+      <br />
+      <div class="issue-content">
+        STATUE : <xsl:value-of select="./@statue"/>, <xsl:value-of select="./@date"/>
+      </div>
+    </div>
+    <br />
+  </xsl:template>
+
+  <xsl:template match="entry">
+    <div class="issue-content">
+      <xsl:value-of select="./@title"/>: <xsl:value-of select="."/>
+    </div>
+  </xsl:template>
+
+</xsl:stylesheet>

doc/src/link.xsl

@@ -0,0 +1,115 @@
+<?xml version="1.0" encoding="iso-8859-1"?>
+<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
+  <xsl:output method="html" media-type="text/html; charset=ISO-8859-1" />
+
+  <xsl:include href="./util.xsl" />
+
+  <xsl:template match="/">
+    <html>
+      <head>
+        <title>OpenGL Mathematics : Links</title>
+        <meta http-equiv="Content-Language" content="fr, be, ca, lu, ch" />
+        <meta http-equiv="Content-Type" content="application/xhtml+xml; charset=iso-8859-1" />
+        <meta name="copyright" content="&#65533; 2005 C-Truc Creation" />
+        <link href="./common/style.css" rel="stylesheet" media="screen, print, embossed" type="text/css" />
+      </head>
+      <body>
+        <div class="title1">
+          <img src="./common/title.png" alt="OpenGL Mathematics" />
+        </div>
+        <table>
+          <tr>
+            <td class="menu">
+              <div class="menu1">
+                <a class="menu" href="./glm/downloads/section/download/@link">
+                  Download <xsl:value-of select="./glm/downloads/section/download/@name" />
+                </a>
+              </div>
+              <hr />
+              <div class="menu2">
+                <a class="menu" href="./index.html">News</a>
+              </div>
+              <div class="menu2">
+                <a class="menu" href="./download.html">Downloads</a>
+              </div>
+              <div class="menu2">
+                <a class="menu" href="./changelog.html">Changelog</a>
+              </div>
+              <div class="menu2">
+                <a class="menu" href="./glm-manual.pdf">User manual</a>
+              </div>
+              <div class="menu2">
+                <a class="menu" href="./html/index.html">API Documentation</a>
+              </div>
+              <div class="menu2">
+                <a class="menu" href="http://glf.svn.sourceforge.net/viewvc/glf">SVN Browse</a>
+              </div>
+              <div class="menu2">
+                <a class="menu" href="https://sourceforge.net/tracker/?group_id=129808&amp;atid=901445">Bug tracker</a>
+              </div>
+              <div class="menu2">
+                <a class="menu" href="https://sourceforge.net/tracker/?group_id=129808&amp;atid=715891">Feature requests</a>
+              </div>
+              <div class="menu2">
+                <a class="menu" href="./link.html">Links</a>
+              </div>
+              <hr />
+              <div class="menu2">
+                <a href="http://validator.w3.org/check/referer">
+                  <img class="menu-img" src="http://www.w3.org/Icons/valid-xhtml11" alt="Valid XHTML 1.1!" />
+                </a>
+              </div>
+              <div class="menu2">
+                <a href="http://www.opengl.org">
+                  <img class="menu-img" src="./common/opengl.jpg" alt="OpenGL"/>
+                </a>
+              </div>
+              <div class="menu2">
+                <a href="http://www.sourceforge.net">
+                  <img class="menu-img" src="./common/sourceforge.gif" alt="SourceForge"/>
+                </a>
+              </div>
+              <div class="menu2">
+                <a href="http://www.g-truc.net">
+                  <img class="menu-img" src="./common/g-truc.jpg" alt="G-Truc"/>
+                </a>
+              </div>
+              <hr />
+            </td>
+            <td class="page">
+              <xsl:apply-templates select="./glm/links" />
+            </td>
+          </tr>
+        </table>
+        <div class="title3">
+          <xsl:value-of select="./glm/@copyright" />
+          <a href="http://www.g-truc.net">G-Truc Creation</a>
+        </div>
+      </body>
+    </html>
+  </xsl:template>
+
+  <xsl:template match="links">
+    <div>
+      <div class="title2">Liens</div>
+      <div class="issue-content">
+        This page lists all the documents that helped to develop OpenGL Mathematics.
+      </div>
+      <br />
+      <xsl:apply-templates select="./link" />
+    </div>
+  </xsl:template>
+
+  <xsl:template match="link">
+    <div class="issue-title">
+      <a href="{./@link}">
+        <xsl:value-of select="./@name"/>
+      </a>
+    </div>
+    <div class="issue-content">
+      <xsl:value-of select="."/>
+    </div>
+    <br />
+  </xsl:template>
+
+</xsl:stylesheet>

doc/src/news.xsl

@@ -0,0 +1,81 @@
+<?xml version="1.0" encoding="iso-8859-1"?>
+<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
+  <xsl:output method="html" media-type="text/html; charset=ISO-8859-1" />
+
+  <xsl:include href="./util.xsl" />
+
+  <xsl:template match="/">
+    <html>
+      <head>
+        <title>OpenGL Mathematics: News</title>
+        <meta http-equiv="Content-Language" content="en" />
+        <meta http-equiv="Content-Type" content="application/xhtml+xml; charset=iso-8859-1" />
+        <meta name="copyright" content="G-Truc Creation" />
+        <link href="./common/style.css" rel="stylesheet" media="screen, print, embossed" type="text/css" />
+      </head>
+      <body>
+        <table>
+          <tr>
+            <td class="menu">
+              <xsl:apply-templates select="./glm/menu" />
+            </td>
+            <td class="page">
+              <!--div class="title1">OpenGL Mathematics</div-->
+              <div class="title1">
+                <img src="./common/title.png" alt="OpenGL Mathematics" />
+              </div>
+              <xsl:apply-templates select="./glm/about-short" />
+              <br />
+              <xsl:apply-templates select="./glm/page_news/news" />
+              <div class="title3">
+                <xsl:value-of select="./glm/@copyright" />
+                <a href="http://www.g-truc.net">G-Truc Creation</a>
+              </div>
+            </td>
+          </tr>
+        </table>
+      </body>
+    </html>
+  </xsl:template>
+
+  <xsl:template match="news">
+    <div>
+      <div class="title-date">
+        <xsl:value-of select="./@date" />
+      </div>
+      <div class="title4">
+        <xsl:value-of select="./@title" />
+      </div>
+      <div>
+        <xsl:if test="./paragraph">
+          <xsl:apply-templates select="./paragraph" />
+        </xsl:if>
+        <xsl:if test="./list">
+          <xsl:apply-templates select="./list" />
+        </xsl:if>
+        <xsl:apply-templates select="./source" />
+
+        <!--table style="width:100%;">
+        <tr style="width:100%;">
+          <td>
+            <xsl:if test="./paragraph">
+              <xsl:apply-templates select="./paragraph" />
+            </xsl:if>
+            <xsl:if test="./list">
+              <xsl:apply-templates select="./list" />
+            </xsl:if>
+            <xsl:apply-templates select="./source" />
+          </td>
+          <td style="text-align:right;">
+            <a ref="{./@image}"><img src="{./@image-mini}" alt=" " /></a>
+          </td>
+        </tr>
+      </table-->
+
+      </div>
+      <div class="news-separator">_________________</div>
+      <br />
+    </div>
+  </xsl:template>
+
+</xsl:stylesheet>

doc/src/util.xsl

@@ -0,0 +1,143 @@
+<?xml version="1.0" encoding="iso-8859-1"?>
+<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
+
+<xsl:strip-space elements="*" />
+
+<xsl:output 
+	method="xml"
+	media-type="application/xhtml+xml; charset=iso-8859-1"
+	version="1.0"
+	encoding="iso-8859-1"
+	standalone="no"
+	omit-xml-declaration="no"
+	doctype-public="-//W3C//DTD XHTML 1.1//EN" 
+	doctype-system="http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd"
+	indent="no" />
+
+<xsl:template match="link">
+	<a href="{./@href}"><xsl:value-of select="." /></a>
+</xsl:template>
+
+<xsl:template match="image">
+	<xsl:choose>
+		<xsl:when test="./@href">
+			<xsl:element name="a">
+				<xsl:attribute name="class">menu-titre2</xsl:attribute>
+				<xsl:attribute name="href"><xsl:value-of select="./@href" /></xsl:attribute>
+				<xsl:element name="img">
+					<xsl:attribute name="src"><xsl:value-of select="@file" /></xsl:attribute>
+					<xsl:attribute name="alt"><xsl:value-of select="@file" /></xsl:attribute>
+				</xsl:element>
+			</xsl:element>
+		</xsl:when>
+		<xsl:otherwise>
+			<xsl:element name="img">
+				<xsl:attribute name="src"><xsl:value-of select="@file" /></xsl:attribute>
+				<xsl:attribute name="alt"><xsl:value-of select="@file" /></xsl:attribute>
+			</xsl:element>
+		</xsl:otherwise>
+	</xsl:choose>
+</xsl:template>
+
+  <xsl:template match="image-list">
+    <div class="news-image">
+      <xsl:apply-templates select="./image-element" />
+    </div>
+  </xsl:template>
+
+  <xsl:template match="image-element">
+    <a href="{./@normal}">
+      <img src="{./@small}" alt="{./@title}" />
+    </a>
+  </xsl:template>
+
+<xsl:template match="list">
+	<xsl:value-of select="./@nom" /><br />
+	<xsl:apply-templates select="./element"/>
+	<br />
+</xsl:template>
+
+<xsl:template match="element">
+	<xsl:apply-templates /><br />
+</xsl:template>
+
+<xsl:template match="paragraph">
+	<div class="paragraph"><xsl:text /><xsl:apply-templates /><xsl:text /></div><br />
+</xsl:template>
+
+<xsl:template match="about-short">
+  <div class="title3">
+    <xsl:apply-templates select="./element" />
+  </div>
+  <br />
+</xsl:template>
+  
+<xsl:template match="source">
+	<xsl:value-of select="./@type"/>: <a href="{./@adresse}"><xsl:value-of select="."/></a><br />
+</xsl:template>
+
+<xsl:template match="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="{/glm/downloads/section/download/@link}">
+        Download <xsl:value-of select="/glm/downloads/section/download/@name" />
+      </a>
+    </div>
+  </div>
+  <br />
+  <xsl:apply-templates select="./menu-group"/>
+  <div class="menu1">
+    <img class="menu-img" src="./common/email.png" alt="contact"/>
+  </div>
+  <br />
+  <xsl:apply-templates select="./menu-link"/>
+  <br />
+  <!--div>
+    <script type="text/javascript" src="http://feedjit.com/map/?bc=FFFFFF&amp;tc=494949&amp;brd1=FFFFFF&amp;lnk=494949&amp;hc=FF8000&amp;dot=FF8000"></script>
+    <noscript>
+      <a href="http://feedjit.com/">Feedjit Live Blog Stats</a>
+    </noscript>
+  </div-->
+</xsl:template>
+
+<xsl:template match="menu-pic">
+  <div class="menu2">
+    <a href="{@href}">
+      <img class="menu-img" src="{@image}" alt="{@name}"/>
+    </a>
+  </div>
+</xsl:template>
+
+<xsl:template match="menu-link">
+  <xsl:apply-templates select="./menu-pic"/>
+</xsl:template>
+  
+<xsl:template match="menu-image">
+  <div class="menu2">
+    <a href="./common/glm.jpg">
+      <img class="menu-img" src="./common/logo.jpg" alt="G-Truc"/>
+    </a>
+  </div>
+</xsl:template>
+  
+<xsl:template match="menu-group">
+  <xsl:apply-templates select="./menu-entry"/>
+  <br />
+</xsl:template>
+
+<xsl:template match="menu-entry">
+  <div class="menu2">
+    <a href="{./@href}">
+      <xsl:value-of select="./@name"/>
+    </a>
+  </div>
+</xsl:template>
+
+</xsl:stylesheet>

doc/usertype.dat

@@ -0,0 +1,646 @@
+attribute 
+const 
+uniform
+varying
+break
+continue
+do
+for
+while
+if
+else
+in
+out
+inout
+float
+int
+void
+bool
+true
+false
+discard
+return
+mat2
+mat3
+mat4
+mat2x2
+mat3x3
+mat4x4
+mat2x3
+mat3x2
+mat2x4
+mat4x2
+mat3x4
+mat4x3
+vec2
+vec3
+vec4
+ivec2
+ivec3
+ivec4
+uvec2
+uvec3
+uvec4
+bvec2
+bvec3
+bvec4
+sampler1D
+sampler2D
+sampler3D
+samplerCube
+sampler1DShadow
+sampler2DShadow
+struct
+
+asm
+class
+union
+enum
+typedef
+template
+this
+packed
+goto
+switch
+default
+inline
+noinline
+volatile
+public
+static
+extern
+external
+interface
+long
+short
+double
+half
+fixed
+unsigned
+input
+output
+sampler2DRect
+sampler3DRect
+sampler2DRectShadow
+sizeof
+cast
+namespace
+using
+
+hvec2
+hvec3
+hvec4
+fvec2
+fvec3
+fvec4
+dvec2
+dvec3
+dvec4
+
+__uvec2GTX
+__uvec3GTX
+__uvec4GTX
+__ivec2GTX
+__ivec3GTX
+__ivec4GTX
+__hvec2GTX
+__hvec3GTX
+__hvec4GTX
+__fvec2GTX
+__fvec3GTX
+__fvec4GTX
+__dvec2GTX
+__dvec3GTX
+__dvec4GTX
+
+on
+
+final
+abstract
+limited
+access
+self
+
+uchar
+schar
+uint
+sint
+
+int8
+int16
+int32
+int64
+
+sint8
+sint16
+sint32
+sint64
+
+uint8
+uint16
+uint32
+uint64
+
+float16
+float32
+float64
+
+quat
+hquat
+fquat
+dquat
+
+__quatGTX
+__hquatGTX
+__fquatGTX
+__dquatGTX
+
+handle
+handle8
+handle16
+handle32
+handle64
+
+flag
+flag8
+flag16
+flag32
+flag64
+
+import
+export
+
+hmat2
+hmat3
+hmat4
+
+fmat2
+fmat3
+fmat4
+
+dmat2
+dmat3
+dmat4
+
+hmat2x3
+hmat3x2
+hmat2x4
+hmat4x2
+hmat3x4
+hmat4x3
+
+fmat2x3
+fmat3x2
+fmat2x4
+fmat4x2
+fmat3x4
+fmat4x3
+
+dmat2x3
+dmat3x2
+dmat2x4
+dmat4x2
+dmat3x4
+dmat4x3
+
+__halfGTX
+
+__hvec2GTX
+__hvec3GTX
+__hvec4GTX
+
+__hmat2GTX
+__hmat3GTX
+__hmat4GTX
+
+__fmat2GTX
+__fmat3GTX
+__fmat4GTX
+
+__dmat2GTX
+__dmat3GTX
+__dmat4GTX
+
+__hmat2x3GTX
+__hmat3x2GTX
+__hmat2x4GTX
+__hmat4x2GTX
+__hmat3x4GTX
+__hmat4x3GTX
+
+__fmat2x3GTX
+__fmat3x2GTX
+__fmat2x4GTX
+__fmat4x2GTX
+__fmat3x4GTX
+__fmat4x3GTX
+
+__dmat2x3GTX
+__dmat3x2GTX
+__dmat2x4GTX
+__dmat4x2GTX
+__dmat3x4GTX
+__dmat4x3GTX
+
+null
+pi
+epsilon
+infinite
+self
+
+byte
+word
+dword
+qword
+
+new_object
+new_array
+delete_object
+delete_array
+
+__int8GTX
+__int16GTX
+__int32GTX
+__int64GTX
+
+__i8GTX
+__i16GTX
+__i32GTX
+__i64GTX
+
+__i8vec2GTX
+__i8vec3GTX
+__i8vec4GTX
+
+__i16vec2GTX
+__i16vec3GTX
+__i16vec4GTX
+
+__i32vec2GTX
+__i32vec3GTX
+__i32vec4GTX
+
+__i64vec2GTX
+__i64vec3GTX
+__i64vec4GTX
+
+__uint8GTX
+__uint16GTX
+__uint32GTX
+__uint64GTX
+
+__u8GTX
+__u16GTX
+__u32GTX
+__u64GTX
+
+__u8vec2GTX
+__u8vec3GTX
+__u8vec4GTX
+
+__u16vec2GTX
+__u16vec3GTX
+__u16vec4GTX
+
+__u32vec2GTX
+__u32vec3GTX
+__u32vec4GTX
+
+__u64vec2GTX
+__u64vec3GTX
+__u64vec4GTX
+
+__float16GTX
+__float32GTX
+__float64GTX
+
+__f16GTX
+__f32GTX
+__f64GTX
+
+__f16vec2GTX
+__f16vec3GTX
+__f16vec4GTX
+
+__f32vec2GTX
+__f32vec3GTX
+__f32vec4GTX
+
+__f64vec2GTX
+__f64vec3GTX
+__f64vec4GTX
+
+__f16mat2GTX
+__f16mat3GTX
+__f16mat4GTX
+
+__f16mat2x3GTX
+__f16mat2x4GTX
+__f16mat3x2GTX
+__f16mat3x4GTX
+__f16mat4x2GTX
+__f16mat4x3GTX
+
+__f32mat2GTX
+__f32mat3GTX
+__f32mat4GTX
+
+__f32mat2x3GTX
+__f32mat2x4GTX
+__f32mat3x2GTX
+__f32mat3x4GTX
+__f32mat4x2GTX
+__f32mat4x3GTX
+
+__f64mat2GTX
+__f64mat3GTX
+__f64mat4GTX
+
+__f64mat2x3GTX
+__f64mat2x4GTX
+__f64mat3x2GTX
+__f64mat3x4GTX
+__f64mat4x2GTX
+__f64mat4x3GTX
+
+__f16quatGTX
+__f32quatGTX
+__f64quatGTX
+
+int8
+int16
+int32
+int64
+
+i8
+i16
+i32
+i64
+
+i8vec2
+i8vec3
+i8vec4
+
+i16vec2
+i16vec3
+i16vec4
+
+i32vec2
+i32vec3
+i32vec4
+
+i64vec2
+i64vec3
+i64vec4
+
+uint8
+uint16
+uint32
+uint64
+
+u8
+u16
+u32
+u64
+
+u8vec2
+u8vec3
+u8vec4
+
+u16vec2
+u16vec3
+u16vec4
+
+u32vec2
+u32vec3
+u32vec4
+
+u64vec2
+u64vec3
+u64vec4
+
+float16
+float32
+float64
+
+f16
+f32
+f64
+
+f16vec2
+f16vec3
+f16vec4
+
+f32vec2
+f32vec3
+f32vec4
+
+f64vec2
+f64vec3
+f64vec4
+
+f16mat2
+f16mat3
+f16mat4
+
+f16mat2x3
+f16mat2x4
+f16mat3x2
+f16mat3x4
+f16mat4x2
+f16mat4x3
+
+f32mat2
+f32mat3
+f32mat4
+
+f32mat2x3
+f32mat2x4
+f32mat3x2
+f32mat3x4
+f32mat4x2
+f32mat4x3
+
+f64mat2
+f64mat3
+f64mat4
+
+f64mat2x3
+f64mat2x4
+f64mat3x2
+f64mat3x4
+f64mat4x2
+f64mat4x3
+
+f16quat
+f32quat
+f64quat
+
+bool1
+bool2
+bool3
+bool4
+
+bool1x1
+bool2x2
+bool3x3
+bool4x4
+
+bool2x3
+bool2x4
+bool3x2
+bool3x4
+bool4x2
+bool4x3
+
+int1
+int2
+int3
+int4
+
+int1x1
+int2x2
+int3x3
+int4x4
+
+int2x3
+int2x4
+int3x2
+int3x4
+int4x2
+int4x3
+
+half1
+half2
+half3
+half4
+
+half2x2
+half3x3
+half4x4
+
+half2x3
+half2x4
+half3x2
+half3x4
+half4x2
+half4x3
+
+float1
+float2
+float3
+float4
+
+float1x1
+float2x2
+float3x3
+float4x4
+
+float2x3
+float2x4
+float3x2
+float3x4
+float4x2
+float4x3
+
+double1
+double2
+double3
+double4
+
+double1x1
+double2x2
+double3x3
+double4x4
+
+double2x3
+double2x4
+double3x2
+double3x4
+double4x2
+double4x3
+
+bool1GTX
+bool2GTX
+bool3GTX
+bool4GTX
+
+bool1x1GTX
+bool2x2GTX
+bool3x3GTX
+bool4x4GTX
+
+bool2x3GTX
+bool2x4GTX
+bool3x2GTX
+bool3x4GTX
+bool4x2GTX
+bool4x3GTX
+
+__int1GTX
+__int2GTX
+__int3GTX
+__int4GTX
+
+__int1x1GTX
+__int2x2GTX
+__int3x3GTX
+__int4x4GTX
+
+__int2x3GTX
+__int2x4GTX
+__int3x2GTX
+__int3x4GTX
+__int4x2GTX
+__int4x3GTX
+
+__half1GTX
+__half2GTX
+__half3GTX
+__half4GTX
+
+__half1x1GTX
+__half2x2GTX
+__half3x3GTX
+__half4x4GTX
+
+__half2x3GTX
+__half2x4GTX
+__half3x2GTX
+__half3x4GTX
+__half4x2GTX
+__half4x3GTX
+
+__float1GTX
+__float2GTX
+__float3GTX
+__float4GTX
+
+__float1x1GTX
+__float2x2GTX
+__float3x3GTX
+__float4x4GTX
+
+__float2x3GTX
+__float2x4GTX
+__float3x2GTX
+__float3x4GTX
+__float4x2GTX
+__float4x3GTX
+
+__double1GTX
+__double2GTX
+__double3GTX
+__double4GTX
+
+__double1x1GTX
+__double2x2GTX
+__double3x3GTX
+__double4x4GTX
+
+__double2x3GTX
+__double2x4GTX
+__double3x2GTX
+__double3x4GTX
+__double4x2GTX
+__double4x3GTX

glm/CMakeLists.txt

@@ -0,0 +1,51 @@
+set(NAME glm)
+
+file(GLOB ROOT_SOURCE *.cpp)
+file(GLOB ROOT_INLINE *.inl)
+file(GLOB ROOT_HEADER *.hpp)
+
+file(GLOB_RECURSE CORE_SOURCE ./core/*.cpp)
+file(GLOB_RECURSE CORE_INLINE ./core/*.inl)
+file(GLOB_RECURSE CORE_HEADER ./core/*.hpp)
+
+file(GLOB_RECURSE GTC_SOURCE ./gtc/*.cpp)
+file(GLOB_RECURSE GTC_INLINE ./gtc/*.inl)
+file(GLOB_RECURSE GTC_HEADER ./gtc/*.hpp)
+
+file(GLOB_RECURSE GTX_SOURCE ./gtx/*.cpp)
+file(GLOB_RECURSE GTX_INLINE ./gtx/*.inl)
+file(GLOB_RECURSE GTX_HEADER ./gtx/*.hpp)
+
+file(GLOB_RECURSE IMG_SOURCE ./img/*.cpp)
+file(GLOB_RECURSE IMG_INLINE ./img/*.inl)
+file(GLOB_RECURSE IMG_HEADER ./img/*.hpp)
+
+file(GLOB_RECURSE VIRTREV_SOURCE ./virtrev/*.cpp)
+file(GLOB_RECURSE VIRTREV_INLINE ./virtrev/*.inl)
+file(GLOB_RECURSE VIRTREV_HEADER ./virtrev/*.hpp)
+
+source_group("Core Files" FILES ${CORE_SOURCE})
+source_group("Core Files" FILES ${CORE_INLINE})
+source_group("Core Files" FILES ${CORE_HEADER})
+source_group("GTC Files" FILES ${GTC_SOURCE})
+source_group("GTC Files" FILES ${GTC_INLINE})
+source_group("GTC Files" FILES ${GTC_HEADER})
+source_group("GTX Files" FILES ${GTX_SOURCE})
+source_group("GTX Files" FILES ${GTX_INLINE})
+source_group("GTX Files" FILES ${GTX_HEADER})
+source_group("IMG Files" FILES ${IMG_SOURCE})
+source_group("IMG Files" FILES ${IMG_INLINE})
+source_group("IMG Files" FILES ${IMG_HEADER})
+source_group("VIRTREV Files" FILES ${VIRTREV_SOURCE})
+source_group("VIRTREV Files" FILES ${VIRTREV_INLINE})
+source_group("VIRTREV Files" FILES ${VIRTREV_HEADER})
+
+include_directories(..)
+
+add_executable(${NAME} 
+	${ROOT_SOURCE}    ${ROOT_INLINE}    ${ROOT_HEADER} 
+	${CORE_SOURCE}    ${CORE_INLINE}    ${CORE_HEADER}
+	${GTC_SOURCE}     ${GTC_INLINE}     ${GTC_HEADER} 
+	${GTX_SOURCE}     ${GTX_INLINE}     ${GTX_HEADER} 
+	${IMG_SOURCE}     ${IMG_INLINE}     ${IMG_HEADER}
+	${VIRTREV_SOURCE} ${VIRTREV_INLINE} ${VIRTREV_HEADER})

glm/core/_detail.hpp

@@ -0,0 +1,327 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2010 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2008-07-24
+// Updated : 2008-08-31
+// Licence : This source is under MIT License
+// File    : glm/core/_detail.hpp
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#ifndef glm_core_detail
+#define glm_core_detail
+
+#include "../setup.hpp"
+#include <cassert>
+
+//#define valType			typename genType::value_type
+//#define valType_cref	typename genType::value_type const &
+//#define genType_cref	typename genType const &
+
+namespace glm{
+namespace detail{
+
+	class thalf;
+
+#if(defined(GLM_COMPILER) && (GLM_COMPILER & GLM_COMPILER_VC))
+	typedef signed __int64						sint64;
+	typedef unsigned __int64					uint64;
+#elif(defined(GLM_COMPILER) && (GLM_COMPILER & GLM_COMPILER_GCC))
+	__extension__ typedef signed long long		sint64;
+	__extension__ typedef unsigned long long	uint64;
+#else//unknown compiler
+	typedef signed long							sint64;
+	typedef unsigned long						uint64;
+#endif//GLM_COMPILER
+
+	template<bool C>
+	struct If
+	{
+		template<typename F, typename T>
+		static inline T apply(F functor, const T& val)
+		{
+			return functor(val);
+		}
+	};
+
+	template<>
+	struct If<false>
+	{
+		template<typename F, typename T>
+		static inline T apply(F, const T& val)
+		{
+			return val;
+		}
+	};
+
+	//template <typename T>
+	//struct traits
+	//{
+	//	static const bool is_signed = false;
+	//	static const bool is_float = false;
+	//	static const bool is_vector = false;
+	//	static const bool is_matrix = false;
+	//	static const bool is_genType = false;
+	//	static const bool is_genIType = false;
+	//	static const bool is_genUType = false;
+	//};
+
+	//template <>
+	//struct traits<half>
+	//{
+	//	static const bool is_float = true;
+	//	static const bool is_genType = true;
+	//};
+
+	//template <>
+	//struct traits<float>
+	//{
+	//	static const bool is_float = true;
+	//	static const bool is_genType = true;
+	//};
+
+	//template <>
+	//struct traits<double>
+	//{
+	//	static const bool is_float = true;
+	//	static const bool is_genType = true;
+	//};
+
+	//template <typename genType>
+	//struct desc
+	//{
+	//	typedef genType							type;
+	//	typedef genType *						pointer;
+	//	typedef genType const*					const_pointer;
+	//	typedef genType const *const			const_pointer_const;
+	//	typedef genType *const					pointer_const;
+	//	typedef genType &						reference;
+	//	typedef genType const&					const_reference;
+	//	typedef genType const&					param_type;
+
+	//	typedef typename genType::value_type	value_type;
+	//	typedef typename genType::size_type		size_type;
+	//	static const typename size_type			value_size;
+	//};
+
+	//template <typename genType>
+	//const typename desc<genType>::size_type desc<genType>::value_size = genType::value_size();
+
+	union uif32
+	{
+		uif32() :
+			i(0)
+		{}
+
+		uif32(float f) :
+			f(f)
+		{}
+
+		uif32(unsigned int i) :
+			i(i)
+		{}
+
+		float f;
+		unsigned int i;
+	};
+
+	union uif64
+	{
+		uif64() :
+			i(0)
+		{}
+
+		uif64(double f) :
+			f(f)
+		{}
+
+		uif64(uint64 i) :
+			i(i)
+		{}
+
+		double f;
+		uint64 i;
+	};
+
+	typedef uif32 uif;
+
+	//////////////////
+	// int
+
+	template <typename T>
+	struct is_int
+	{
+		enum is_int_enum
+		{
+			YES = 0,
+			NO = 1
+		};
+	};
+
+#define GLM_DETAIL_IS_INT(T)	\
+	template <>					\
+	struct is_int<T>			\
+	{							\
+		enum is_int_enum		\
+		{						\
+			YES = 1,			\
+			NO = 0				\
+		};						\
+	}
+
+	//////////////////
+	// uint
+
+	template <typename T>
+	struct is_uint
+	{
+		enum is_uint_enum
+		{
+			YES = 0,
+			NO = 1
+		};
+	};
+
+#define GLM_DETAIL_IS_UINT(T)	\
+	template <>					\
+	struct is_uint<T>			\
+	{							\
+		enum is_uint_enum		\
+		{						\
+			YES = 1,			\
+			NO = 0				\
+		};						\
+	}
+
+	//GLM_DETAIL_IS_UINT(unsigned long long)
+
+	//////////////////
+	// float
+
+	template <typename T>
+	struct is_float
+	{
+		enum is_float_enum
+		{
+			YES = 0,
+			NO = 1
+		};
+	};
+
+#define GLM_DETAIL_IS_FLOAT(T)	\
+	template <>					\
+	struct is_float<T>			\
+	{							\
+		enum is_float_enum		\
+		{						\
+			YES = 1,			\
+			NO = 0				\
+		};						\
+	}
+
+	//////////////////
+	// bool
+
+	template <typename T>
+	struct is_bool
+	{
+		enum is_bool_enum
+		{
+			YES = 0,
+			NO = 1
+		};
+	};
+	
+	template <>
+	struct is_bool<bool>
+	{
+		enum is_bool_enum
+		{
+			YES = 1,
+			NO = 0
+		};
+	};
+	
+	//////////////////
+	// vector
+
+	template <typename T>
+	struct is_vector
+	{
+		enum is_vector_enum
+		{
+			YES = 0,
+			NO = 1
+		};
+	};
+
+#define GLM_DETAIL_IS_VECTOR(T)	\
+	template <>					\
+	struct is_vector			\
+	{							\
+		enum is_vector_enum		\
+		{						\
+			YES = 1,			\
+			NO = 0				\
+		};						\
+	}
+
+	//////////////////
+	// matrix
+
+	template <typename T>
+	struct is_matrix
+	{
+		enum is_matrix_enum
+		{
+			YES = 0,
+			NO = 1
+		};
+	};
+
+#define GLM_DETAIL_IS_MATRIX(T)	\
+	template <>					\
+	struct is_matrix			\
+	{							\
+		enum is_matrix_enum		\
+		{						\
+			YES = 1,			\
+			NO = 0				\
+		};						\
+	}
+
+	//////////////////
+	// type
+
+	template <typename T>
+	struct type
+	{
+		enum type_enum
+		{
+			is_float = is_float<T>::YES,
+			is_int = is_int<T>::YES,
+			is_uint = is_uint<T>::YES,
+			is_bool = is_bool<T>::YES
+		};
+	};
+
+	//////////////////
+	// type
+
+	typedef signed char							int8;
+	typedef signed short						int16;
+	typedef signed int							int32;
+	typedef detail::sint64						int64;
+
+	typedef unsigned char						uint8;
+	typedef unsigned short						uint16;
+	typedef unsigned int						uint32;
+	typedef detail::uint64						uint64;
+
+	typedef detail::thalf						float16;
+	typedef float								float32;
+	typedef double								float64;
+
+}//namespace detail
+}//namespace glm
+
+#endif//glm_core_detail

glm/core/_swizzle.inl

@@ -0,0 +1,20 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2010 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2006-04-27
+// Updated : 2006-04-27
+// Licence : This source is under MIT License
+// File    : _swizzle.inl
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#ifndef __swizzle_inl__
+#define __swizzle_inl__
+
+#include "./_swizzle.h"
+
+namespace glm
+{
+
+}
+
+#endif//__swizzle_inl__

glm/core/dummy.cpp

@@ -0,0 +1,4 @@
+int main()
+{
+
+}

glm/core/func_common.hpp

@@ -0,0 +1,274 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2010 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2008-03-08
+// Updated : 2010-01-26
+// Licence : This source is under MIT License
+// File    : glm/core/func_common.hpp
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#ifndef glm_core_func_common
+#define glm_core_func_common
+
+namespace glm
+{
+	namespace test{
+		void main_core_func_common();
+	}//namespace test
+
+	namespace core{
+	namespace function{
+	//! Define common functions from Section 8.3 of GLSL 1.30.8 specification. Included in glm namespace.
+	namespace common{
+
+	//! Returns x if x >= 0; otherwise, it returns -x. 
+	//! (From GLSL 1.30.08 specification, section 8.3)
+	template <typename genFIType> 
+	genFIType abs(genFIType const & x);
+
+	//! Returns 1.0 if x > 0, 0.0 if x = 0, or -1.0 if x < 0. 
+	//! (From GLSL 1.30.08 specification, section 8.3)
+	template <typename genFIType> 
+	genFIType sign(genFIType const & x);
+
+    //! Returns a value equal to the nearest integer that is less then or equal to x. 
+	//! (From GLSL 1.30.08 specification, section 8.3)
+	template <typename genType> 
+	genType floor(genType const & x);
+
+	//! Returns a value equal to the nearest integer to x 
+	//! whose absolute value is not larger than the absolute value of x. 
+	//! (From GLSL 1.30.08 specification, section 8.3)
+	template <typename genType> 
+	genType trunc(genType const & x);
+
+	//! Returns a value equal to the nearest integer to x. 
+	//! The fraction 0.5 will round in a direction chosen by the 
+	//! implementation, presumably the direction that is fastest. 
+	//! This includes the possibility that round(x) returns the 
+	//! same value as roundEven(x) for all values of x. 
+	//! (From GLSL 1.30.08 specification, section 8.3)
+	template <typename genType> 
+	genType round(genType const & x);
+
+	//! Returns a value equal to the nearest integer to x.
+	//! A fractional part of 0.5 will round toward the nearest even
+	//! integer. (Both 3.5 and 4.5 for x will return 4.0.) 
+	//! (From GLSL 1.30.08 specification, section 8.3)
+	template <typename genType> 
+	genType roundEven(genType const & x);
+
+	//! Returns a value equal to the nearest integer 
+	//! that is greater than or equal to x. 
+	//! (From GLSL 1.30.08 specification, section 8.3)
+    template <typename genType> 
+	genType ceil(genType const & x);
+
+	//! Return x - floor(x).
+	//! (From GLSL 1.30.08 specification, section 8.3)
+    template <typename genType> 
+	genType fract(genType const & x);
+
+	//! Modulus. Returns x - y * floor(x / y) 
+	//! for each component in x using the floating point value y.
+	//! (From GLSL 1.30.08 specification, section 8.3)
+    template <typename genType> 
+	genType mod(
+		genType const & x, 
+		genType const & y);
+
+	//! Modulus. Returns x - y * floor(x / y) 
+	//! for each component in x using the floating point value y.
+	//! (From GLSL 1.30.08 specification, section 8.3)
+    template <typename genType> 
+	genType mod(
+		genType const & x, 
+		typename genType::value_type const & y);
+
+	//! Returns the fractional part of x and sets i to the integer
+	//! part (as a whole number floating point value). Both the
+	//! return value and the output parameter will have the same
+	//! sign as x.
+	//! (From GLSL 1.30.08 specification, section 8.3)
+	template <typename genType> 
+	genType modf(
+		genType const & x, 
+		genType & i);
+
+    //! Returns y if y < x; otherwise, it returns x.
+	//! (From GLSL 1.30.08 specification, section 8.3)
+	template <typename genType> 
+	genType min(
+		genType const & x, 
+		genType const & y);
+
+	template <typename genType> 
+	genType min(
+		genType const & x, 
+		typename genType::value_type const & y);
+
+    //! Returns y if x < y; otherwise, it returns x.
+	//! (From GLSL 1.30.08 specification, section 8.3)
+	template <typename genType> 
+	genType max(
+		genType const & x, 
+		genType const & y);
+
+	template <typename genType> 
+	genType max(
+		genType const & x, 
+		typename genType::value_type const & y);
+
+    //! Returns min(max(x, minVal), maxVal) for each component in x 
+	//! using the floating-point values minVal and maxVal.
+	//! (From GLSL 1.30.08 specification, section 8.3)
+	template <typename genType> 
+	genType clamp(
+		genType const & x, 
+		genType const & minVal, 
+		genType const & maxVal); 
+
+	template <typename genType> 
+	genType clamp(
+		genType const & x, 
+		typename genType::value_type const & minVal, 
+		typename genType::value_type const & maxVal); 
+
+	//! \return If genTypeU is a floating scalar or vector: 
+	//! Returns x * (1.0 - a) + y * a, i.e., the linear blend of 
+	//! x and y using the floating-point value a. 
+	//! The value for a is not restricted to the range [0, 1].
+	//!
+	//! \return If genTypeU is a boolean scalar or vector: 
+	//! Selects which vector each returned component comes
+	//! from. For a component of a that is false, the
+	//! corresponding component of x is returned. For a
+	//! component of a that is true, the corresponding
+	//! component of y is returned. Components of x and y that
+	//! are not selected are allowed to be invalid floating point
+	//! values and will have no effect on the results. Thus, this
+	//! provides different functionality than
+	//! genType mix(genType x, genType y, genType(a))
+	//! where a is a Boolean vector.
+	//! 
+	//! From GLSL 1.30.08 specification, section 8.3
+	//! 
+	//! \param[in]  x Floating point scalar or vector.
+	//! \param[in]  y Floating point scalar or vector.
+	//! \param[in]  a Floating point or boolean scalar or vector.
+	//!
+	// \todo Test when 'a' is a boolean.
+	template <typename genTypeT, typename genTypeU> 
+	genTypeT mix(genTypeT const & x, genTypeT const & y, genTypeU const & a);
+
+	//! Returns 0.0 if x < edge, otherwise it returns 1.0.
+	//! (From GLSL 1.30.08 specification, section 8.3)
+	template <typename genType> 
+	genType step(
+		genType const & edge, 
+		genType const & x);
+
+	template <typename genType> 
+	genType step(
+		typename genType::value_type const & edge, 
+		genType const & x);
+
+	//! Returns 0.0 if x <= edge0 and 1.0 if x >= edge1 and
+	//! performs smooth Hermite interpolation between 0 and 1
+	//! when edge0 < x < edge1. This is useful in cases where
+	//! you would want a threshold function with a smooth
+	//! transition. This is equivalent to:
+	//! genType t;
+	//! t = clamp ((x – edge0) / (edge1 – edge0), 0, 1);
+	//! return t * t * (3 – 2 * t);
+	//! Results are undefined if edge0 >= edge1.
+	//! (From GLSL 1.30.08 specification, section 8.3)
+	template <typename genType> 
+	genType smoothstep(
+		genType const & edge0, 
+		genType const & edge1, 
+		genType const & x);
+
+	template <typename genType> 
+	genType smoothstep(
+		typename genType::value_type const & edge0, 
+		typename genType::value_type const & edge1, 
+		genType const & x);
+
+	//! Returns true if x holds a NaN (not a number)
+	//! representation in the underlying implementation's set of
+	//! floating point representations. Returns false otherwise,
+	//! including for implementations with no NaN
+	//! representations.
+	//! (From GLSL 1.30.08 specification, section 8.3)
+	template <typename genType> 
+	typename genType::bool_type isnan(genType const & x);
+
+	//! Returns true if x holds a positive infinity or negative
+	//! infinity representation in the underlying implementation's
+	//! set of floating point representations. Returns false
+	//! otherwise, including for implementations with no infinity
+	//! representations.
+	//! (From GLSL 1.30.08 specification, section 8.3)
+	template <typename genType> 
+	typename genType::bool_type isinf(genType const & x);
+
+	//! Returns a signed or unsigned integer value representing
+	//! the encoding of a floating-point value. The floatingpoint
+	//! value's bit-level representation is preserved.
+	//! (From GLSL 4.00.08 specification, section 8.3)
+	template <typename genType, typename genIType>
+	genIType floatBitsToInt(genType const & value);
+
+	//! Returns a signed or unsigned integer value representing
+	//! the encoding of a floating-point value. The floatingpoint
+	//! value's bit-level representation is preserved.
+	//! (From GLSL 4.00.08 specification, section 8.3)
+	template <typename genType, typename genUType>
+	genUType floatBitsToInt(genType const & value);
+
+	//! Returns a floating-point value corresponding to a signed
+	//! or unsigned integer encoding of a floating-point value.
+	//! If an inf or NaN is passed in, it will not signal, and the
+	//! resulting floating point value is unspecified. Otherwise,
+	//! the bit-level representation is preserved.
+	//! (From GLSL 4.00.08 specification, section 8.3)
+	template <typename genType, typename genIUType>
+	genType intBitsToFloat(genIUType const & value);
+
+	//! Computes and returns a * b + c.
+	//! (From GLSL 4.00.08 specification, section 8.3)
+	template <typename genType>
+	genType fma(genType const & a, genType const & b, genType const & c);
+
+	//! Splits x into a floating-point significand in the range
+	//! [0.5, 1.0) and an integral exponent of two, such that:
+	//! x = significand * exp(2, exponent)
+	//! The significand is returned by the function and the
+	//! exponent is returned in the parameter exp. For a
+	//! floating-point value of zero, the significant and exponent
+	//! are both zero. For a floating-point value that is an
+	//! infinity or is not a number, the results are undefined.
+	//! (From GLSL 4.00.08 specification, section 8.3)
+	template <typename genType, typename genIType>
+	genType frexp(genType const & x, genIType & exp);
+
+	//! Builds a floating-point number from x and the
+	//! corresponding integral exponent of two in exp, returning:
+	//! significand * exp(2, exponent)
+	//! If this product is too large to be represented in the
+	//! floating-point type, the result is undefined.
+	//! (From GLSL 4.00.08 specification, section 8.3)
+	template <typename genType, typename genIType>
+	genType ldexp(genType const & x, genIType const & exp);
+
+	}//namespace common
+	}//namespace function
+	}//namespace core
+
+	using namespace core::function::common;
+}//namespace glm
+
+#include "func_common.inl"
+
+#endif//glm_core_func_common

glm/core/func_exponential.hpp

@@ -0,0 +1,71 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2010 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2008-08-08
+// Updated : 2010-02-04
+// Licence : This source is under MIT License
+// File    : glm/core/func_exponential.hpp
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#ifndef glm_core_func_exponential
+#define glm_core_func_exponential
+
+namespace glm
+{
+	namespace test{
+		void main_core_func_exponential();
+	}//namespace test
+
+	namespace core{
+	namespace function{
+	//! Define all exponential functions from Section 8.2 of GLSL 1.30.8 specification. Included in glm namespace.
+	namespace exponential{
+
+	//! Returns x raised to the y power. 
+	//! (From GLSL 1.30.08 specification, section 8.2)
+	template <typename genType> 
+	genType pow(genType const & x, genType const & y);
+
+	//! Returns the natural exponentiation of x, i.e., e^x.
+	//! (From GLSL 1.30.08 specification, section 8.2)
+	template <typename genType> 
+	genType exp(genType const & x);
+
+	//! Returns the natural logarithm of x, i.e., 
+	//! returns the value y which satisfies the equation x = e^y. 
+	//! Results are undefined if x <= 0.
+	//! (From GLSL 1.30.08 specification, section 8.2)
+	template <typename genType> 
+	genType log(genType const & x);
+
+	//! Returns 2 raised to the x power.
+	//! (From GLSL 1.30.08 specification, section 8.2)
+	template <typename genType> 
+	genType exp2(genType const & x);
+
+	//! Returns the base 2 log of x, i.e., returns the value y, 
+	//! which satisfies the equation x = 2 ^ y.
+	//! (From GLSL 1.30.08 specification, section 8.2)
+	template <typename genType> 
+	genType log2(genType const & x);
+
+	//! Returns the positive square root of x.
+	//! (From GLSL 1.30.08 specification, section 8.2)
+	template <typename genType> 
+	genType sqrt(genType const & x);
+    
+	//! Returns the reciprocal of the positive square root of x.
+	//! (From GLSL 1.30.08 specification, section 8.2)
+	template <typename genType> 
+	genType inversesqrt(genType const & x);
+
+	}//namespace exponential
+	}//namespace function
+	}//namespace core
+
+	using namespace core::function::exponential;
+}//namespace glm
+
+#include "func_exponential.inl"
+
+#endif//glm_core_func_exponential

glm/core/func_exponential.inl

@@ -0,0 +1,358 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2010 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2008-08-03
+// Updated : 2010-02-04
+// Licence : This source is under MIT License
+// File    : glm/core/func_exponential.inl
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+namespace glm
+{
+	namespace core{
+	namespace function{
+	namespace exponential{
+
+    // pow
+    template <typename genType>
+    inline genType pow
+	(
+		genType const & x, 
+		genType const & y
+	)
+    {
+		GLM_STATIC_ASSERT(detail::type<genType>::is_float);
+
+        return ::std::pow(x, y);
+    }
+
+    template <typename T>
+    inline detail::tvec2<T> pow
+	(
+		detail::tvec2<T> const & x, 
+		detail::tvec2<T> const & y
+	)
+    {
+        return detail::tvec2<T>(
+            pow(x.x, y.x),
+            pow(x.y, y.y));
+    }
+
+    template <typename T>
+    inline detail::tvec3<T> pow
+	(
+		detail::tvec3<T> const & x, 
+		detail::tvec3<T> const & y
+	)
+    {
+        return detail::tvec3<T>(
+            pow(x.x, y.x),
+            pow(x.y, y.y),
+            pow(x.z, y.z));
+    }
+
+    template <typename T>
+    inline detail::tvec4<T> pow
+	(
+		detail::tvec4<T> const & x, 
+		detail::tvec4<T> const & y
+	)
+    {
+        return detail::tvec4<T>(
+            pow(x.x, y.x),
+            pow(x.y, y.y),
+            pow(x.z, y.z),
+            pow(x.w, y.w));
+    }
+
+    // exp
+    template <typename genType>
+    inline genType exp
+	(
+		genType const & x
+	)
+    {
+		GLM_STATIC_ASSERT(detail::type<genType>::is_float);
+
+        return ::std::exp(x);
+    }
+
+    template <typename T>
+    inline detail::tvec2<T> exp
+	(
+		detail::tvec2<T> const & x
+	)
+    {
+        return detail::tvec2<T>(
+            exp(x.x),
+            exp(x.y));
+    }
+
+    template <typename T>
+    inline detail::tvec3<T> exp
+	(
+		detail::tvec3<T> const & x
+	)
+    {
+        return detail::tvec3<T>(
+            exp(x.x),
+            exp(x.y),
+            exp(x.z));
+    }
+
+    template <typename T>
+    inline detail::tvec4<T> exp
+	(
+		detail::tvec4<T> const & x
+	)
+    {
+        return detail::tvec4<T>(
+            exp(x.x),
+            exp(x.y),
+            exp(x.z),
+            exp(x.w));
+    }
+
+    // log
+    template <typename genType>
+    inline genType log
+	(
+		genType const & x
+	)
+    {
+		GLM_STATIC_ASSERT(detail::type<genType>::is_float);
+
+        return ::std::log(x);
+    }
+
+    template <typename T>
+    inline detail::tvec2<T> log
+	(
+		detail::tvec2<T> const & x
+	)
+    {
+        return detail::tvec2<T>(
+            log(x.x),
+            log(x.y));
+    }
+
+    template <typename T>
+    inline detail::tvec3<T> log
+	(
+		detail::tvec3<T> const & x
+	)
+    {
+        return detail::tvec3<T>(
+            log(x.x),
+            log(x.y),
+            log(x.z));
+    }
+
+    template <typename T>
+    inline detail::tvec4<T> log
+	(
+		detail::tvec4<T> const & x
+	)
+    {
+        return detail::tvec4<T>(
+            log(x.x),
+            log(x.y),
+            log(x.z),
+            log(x.w));
+    }
+
+    //exp2, ln2 = 0.69314718055994530941723212145818f
+    template <typename genType>
+    inline genType exp2
+	(
+		genType const & x
+	)
+    {
+		GLM_STATIC_ASSERT(detail::type<genType>::is_float);
+
+        return ::std::exp(genType(0.69314718055994530941723212145818) * x);
+    }
+
+    template <typename T>
+    inline detail::tvec2<T> exp2
+	(
+		detail::tvec2<T> const & x
+	)
+    {
+        return detail::tvec2<T>(
+            exp2(x.x),
+            exp2(x.y));
+    }
+
+    template <typename T>
+    inline detail::tvec3<T> exp2
+	(
+		detail::tvec3<T> const & x
+	)
+    {
+        return detail::tvec3<T>(
+            exp2(x.x),
+            exp2(x.y),
+            exp2(x.z));
+    }
+
+    template <typename T>
+    inline detail::tvec4<T> exp2
+	(
+		detail::tvec4<T> const & x
+	)
+    {
+        return detail::tvec4<T>(
+            exp2(x.x),
+            exp2(x.y),
+            exp2(x.z),
+            exp2(x.w));
+    }
+
+    // log2, ln2 = 0.69314718055994530941723212145818f
+    template <typename genType>
+    inline genType log2
+	(
+		genType const & x
+	)
+    {
+		GLM_STATIC_ASSERT(detail::type<genType>::is_float);
+
+        return ::std::log(x) / genType(0.69314718055994530941723212145818);
+    }
+
+    template <typename T>
+    inline detail::tvec2<T> log2
+	(
+		detail::tvec2<T> const & x
+	)
+    {
+        return detail::tvec2<T>(
+            log2(x.x),
+            log2(x.y));
+    }
+
+    template <typename T>
+    inline detail::tvec3<T> log2
+	(
+		detail::tvec3<T> const & x
+	)
+    {
+        return detail::tvec3<T>(
+            log2(x.x),
+            log2(x.y),
+            log2(x.z));
+    }
+
+    template <typename T>
+    inline detail::tvec4<T> log2
+	(
+		detail::tvec4<T> const & x
+	)
+    {
+        return detail::tvec4<T>(
+            log2(x.x),
+            log2(x.y),
+            log2(x.z),
+            log2(x.w));
+    }
+
+    // sqrt
+    template <typename genType>
+    inline genType sqrt
+	(
+		genType const & x
+	)
+    {
+		GLM_STATIC_ASSERT(detail::type<genType>::is_float);
+
+        return genType(::std::sqrt(double(x)));
+    }
+
+    template <typename T>
+    inline detail::tvec2<T> sqrt
+	(
+		detail::tvec2<T> const & x
+	)
+    {
+        return detail::tvec2<T>(
+            sqrt(x.x),
+            sqrt(x.y));
+    }
+
+    template <typename T>
+    inline detail::tvec3<T> sqrt
+	(
+		detail::tvec3<T> const & x
+	)
+    {
+        return detail::tvec3<T>(
+            sqrt(x.x),
+            sqrt(x.y),
+            sqrt(x.z));
+    }
+
+    template <typename T>
+    inline detail::tvec4<T> sqrt
+	(
+		detail::tvec4<T> const & x
+	)
+    {
+        return detail::tvec4<T>(
+            sqrt(x.x),
+            sqrt(x.y),
+            sqrt(x.z),
+            sqrt(x.w));
+    }
+
+    template <typename genType>
+    inline genType inversesqrt
+	(
+		genType const & x
+	)
+    {
+		GLM_STATIC_ASSERT(detail::type<genType>::is_float);
+
+        return genType(1) / ::std::sqrt(x);
+    }
+
+    template <typename T>
+    inline detail::tvec2<T> inversesqrt
+	(
+		detail::tvec2<T> const & x
+	)
+    {
+        return detail::tvec2<T>(
+            inversesqrt(x.x),
+            inversesqrt(x.y));
+    }
+
+    template <typename T>
+    inline detail::tvec3<T> inversesqrt
+	(
+		detail::tvec3<T> const & x
+	)
+    {
+        return detail::tvec3<T>(
+            inversesqrt(x.x),
+            inversesqrt(x.y),
+            inversesqrt(x.z));
+    }
+
+    template <typename T>
+    inline detail::tvec4<T> inversesqrt
+	(
+		detail::tvec4<T> const & x
+	)
+    {
+        return detail::tvec4<T>(
+            inversesqrt(x.x),
+            inversesqrt(x.y),
+            inversesqrt(x.z),
+            inversesqrt(x.w));
+    }
+
+	}//namespace exponential
+	}//namespace function
+	}//namespace core
+}//namespace glm

glm/core/func_geometric.hpp

@@ -0,0 +1,92 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2010 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2008-08-03
+// Updated : 2010-02-04
+// Licence : This source is under MIT License
+// File    : glm/core/func_geometric.hpp
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#ifndef glm_core_func_geometric
+#define glm_core_func_geometric
+
+namespace glm
+{
+	namespace test{
+		void main_core_func_geometric();
+	}//namespace test
+
+	namespace core{
+	namespace function{
+	//! Define all geometric functions from Section 8.4 of GLSL 1.30.8 specification. Included in glm namespace.
+	namespace geometric{
+
+	//! Returns the length of x, i.e., sqrt(x * x).
+	//! (From GLSL 1.30.08 specification, section 8.4)
+	template <typename genType> 
+	typename genType::value_type length(
+		genType const & x); 
+
+	//! Returns the distance betwwen p0 and p1, i.e., length(p0 - p1).
+    //! (From GLSL 1.30.08 specification, section 8.4)
+	template <typename genType> 
+	typename genType::value_type distance(
+		genType const & p0, 
+		genType const & p1);
+
+	//! Returns the dot product of x and y, i.e., result = x * y.
+	//! (From GLSL 1.30.08 specification, section 8.4)
+    template <typename genType> 
+	typename genType::value_type dot(
+		genType const & x, 
+		genType const & y);
+
+	//! Returns the cross product of x and y.
+    //! (From GLSL 1.30.08 specification, section 8.4)
+    template <typename T> 
+	detail::tvec3<T> cross(
+		detail::tvec3<T> const & x, 
+		detail::tvec3<T> const & y);
+
+	//! Returns a vector in the same direction as x but with length of 1.
+	//! (From GLSL 1.30.08 specification, section 8.4)
+	template <typename genType> 
+	genType normalize(
+		genType const & x);
+
+	//! If dot(Nref, I) < 0.0, return N, otherwise, return -N.
+	//! (From GLSL 1.30.08 specification, section 8.4)
+    template <typename genType> 
+	genType faceforward(
+		genType const & N, 
+		genType const & I, 
+		genType const & Nref);
+  
+	//! For the incident vector I and surface orientation N, 
+	//! returns the reflection direction : result = I - 2.0 * dot(N, I) * N.
+	//! (From GLSL 1.30.08 specification, section 8.4)
+    template <typename genType> 
+	genType reflect(
+		genType const & I, 
+		genType const & N);
+  
+	//! For the incident vector I and surface normal N, 
+	//! and the ratio of indices of refraction eta, 
+	//! return the refraction vector.
+	//! (From GLSL 1.30.08 specification, section 8.4)
+    template <typename genType> 
+	genType refract(
+		genType const & I, 
+		genType const & N, 
+		typename genType::value_type const & eta);
+
+	}//namespace geometric
+	}//namespace function
+	}//namespace core
+
+	using namespace core::function::geometric;
+}//namespace glm
+
+#include "func_geometric.inl"
+
+#endif//glm_core_func_geometric

glm/core/func_geometric.inl

@@ -0,0 +1,290 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2010 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2008-08-03
+// Updated : 2010-02-04
+// Licence : This source is under MIT License
+// File    : glm/core/func_geometric.inl
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+namespace glm
+{
+	namespace core{
+	namespace function{
+	namespace geometric{
+
+    // length
+    template <typename genType>
+	inline genType length
+	(
+		genType const & x
+	)
+    {
+		GLM_STATIC_ASSERT(detail::type<genType>::is_float);
+
+        genType sqr = x * x;
+        return sqrt(sqr);
+    }
+
+	template <typename T>
+	inline typename detail::tvec2<T>::value_type length
+	(
+		detail::tvec2<T> const & v
+	)
+    {
+		GLM_STATIC_ASSERT(detail::type<T>::is_float);
+
+        typename detail::tvec2<T>::value_type sqr = v.x * v.x + v.y * v.y;
+        return sqrt(sqr);
+    }
+
+    template <typename T>
+    inline typename detail::tvec3<T>::value_type length
+	(
+		detail::tvec3<T> const & v
+	)
+    {
+		GLM_STATIC_ASSERT(detail::type<T>::is_float);
+
+        typename detail::tvec3<T>::value_type sqr = v.x * v.x + v.y * v.y + v.z * v.z;
+        return sqrt(sqr);
+    }
+
+    template <typename T>
+    inline typename detail::tvec4<T>::value_type length
+	(
+		detail::tvec4<T> const & v
+	)
+    {
+		GLM_STATIC_ASSERT(detail::type<T>::is_float);
+
+        typename detail::tvec4<T>::value_type sqr = v.x * v.x + v.y * v.y + v.z * v.z + v.w * v.w;
+        return sqrt(sqr);
+    }
+
+    // distance
+	template <typename genType>
+    inline genType distance
+	(
+		genType const & p0, 
+		genType const & p1
+	)
+    {
+        GLM_STATIC_ASSERT(detail::type<genType>::is_float);
+
+		return length(p1 - p0);
+    }
+ 
+	template <typename T>
+	inline typename detail::tvec2<T>::value_type distance
+	(
+		detail::tvec2<T> const & p0,
+		detail::tvec2<T> const & p1
+	)
+    {
+		GLM_STATIC_ASSERT(detail::type<T>::is_float);
+
+        return length(p1 - p0);
+    }
+
+    template <typename T>
+    inline typename detail::tvec3<T>::value_type distance
+	(
+		detail::tvec3<T> const & p0,
+		detail::tvec3<T> const & p1
+	)
+    {
+		GLM_STATIC_ASSERT(detail::type<T>::is_float);
+
+		return length(p1 - p0);
+    }
+
+    template <typename T>
+    inline typename detail::tvec4<T>::value_type distance
+	(
+		detail::tvec4<T> const & p0,
+		detail::tvec4<T> const & p1
+	)
+    {
+		GLM_STATIC_ASSERT(detail::type<T>::is_float);
+
+		return length(p1 - p0);
+    }
+
+	// dot
+	template <typename genType>
+	inline genType dot
+	(
+		genType const & x, 
+		genType const & y
+	)
+	{
+		GLM_STATIC_ASSERT(detail::type<genType>::is_float);
+
+		return x * y;
+	}
+
+    template <typename T>
+	inline typename detail::tvec2<T>::value_type dot
+	(
+		detail::tvec2<T> const & x, 
+		detail::tvec2<T> const & y
+	)
+    {
+		GLM_STATIC_ASSERT(detail::type<T>::is_float);
+
+		return x.x * y.x + x.y * y.y;
+    }
+
+    template <typename T>
+    inline T dot
+	(
+		detail::tvec3<T> const & x, 
+		detail::tvec3<T> const & y
+	)
+    {
+		GLM_STATIC_ASSERT(detail::type<T>::is_float);
+
+		return x.x * y.x + x.y * y.y + x.z * y.z;
+    }
+/* // SSE3
+    inline float dot(const tvec4<float>& x, const tvec4<float>& y)
+    {
+	    float Result;
+	    __asm
+        {
+		    mov		esi, x
+		    mov		edi, y
+		    movaps	xmm0, [esi]
+		    mulps	xmm0, [edi]
+		    haddps(	_xmm0, _xmm0 )
+		    haddps(	_xmm0, _xmm0 )
+		    movss	Result, xmm0
+	    }
+	    return Result;
+    }
+*/
+    template <typename T>
+    inline T dot
+	(
+		detail::tvec4<T> const & x, 
+		detail::tvec4<T> const & y
+	)
+    {
+		GLM_STATIC_ASSERT(detail::type<T>::is_float);
+
+        return x.x * y.x + x.y * y.y + x.z * y.z + x.w * y.w;
+    }
+
+    // cross
+    template <typename T>
+    inline detail::tvec3<T> cross
+	(
+		detail::tvec3<T> const & x, 
+		detail::tvec3<T> const & y
+	)
+    {
+		GLM_STATIC_ASSERT(detail::type<T>::is_float);
+
+        return detail::tvec3<T>(
+            x.y * y.z - y.y * x.z,
+            x.z * y.x - y.z * x.x,
+            x.x * y.y - y.x * x.y);
+    }
+
+    // normalize
+    template <typename genType>
+    inline genType normalize
+	(
+		genType const & x
+	)
+    {
+		GLM_STATIC_ASSERT(detail::type<genType>::is_float);
+
+        return x < genType(0) ? genType(-1) : genType(1);
+    }
+
+    // According to issue 10 GLSL 1.10 specification, if length(x) == 0 then result is undefine and generate an error
+    template <typename T>
+    inline detail::tvec2<T> normalize
+	(
+		detail::tvec2<T> const & x
+	)
+    {
+		GLM_STATIC_ASSERT(detail::type<T>::is_float);
+		
+		typename detail::tvec2<T>::value_type sqr = x.x * x.x + x.y * x.y;
+	    return x * inversesqrt(sqr);
+    }
+
+    template <typename T>
+    inline detail::tvec3<T> normalize
+	(
+		detail::tvec3<T> const & x
+	)
+    {
+        GLM_STATIC_ASSERT(detail::type<T>::is_float);
+
+		typename detail::tvec3<T>::value_type sqr = x.x * x.x + x.y * x.y + x.z * x.z;
+	    return x * inversesqrt(sqr);
+    }
+
+    template <typename T>
+    inline detail::tvec4<T> normalize
+	(
+		detail::tvec4<T> const & x
+	)
+    {
+        GLM_STATIC_ASSERT(detail::type<T>::is_float);
+		
+		typename detail::tvec4<T>::value_type sqr = x.x * x.x + x.y * x.y + x.z * x.z + x.w * x.w;
+	    return x * inversesqrt(sqr);
+    }
+
+    // faceforward
+	template <typename genType>
+	inline genType faceforward
+	(
+		genType const & N, 
+		genType const & I, 
+		genType const & Nref
+	)
+	{
+		return dot(Nref, I) < 0 ? N : -N;
+	}
+
+	// reflect
+	template <typename genType>
+	genType reflect
+	(
+		genType const & I, 
+		genType const & N
+	)
+	{
+		return I - N * dot(N, I) * float(2);
+	}
+
+    // refract
+    template <typename genType>
+    inline genType refract
+	(
+		genType const & I, 
+		genType const & N, 
+		typename genType::value_type const & eta
+	)
+    {
+		//It could be a vector
+		//GLM_STATIC_ASSERT(detail::type<genType>::is_float);
+
+        typename genType::value_type dotValue = dot(N, I);
+        typename genType::value_type k = typename genType::value_type(1) - eta * eta * (typename genType::value_type(1) - dotValue * dotValue);
+        if(k < typename genType::value_type(0))
+            return genType(0);
+        else
+            return eta * I - (eta * dotValue + sqrt(k)) * N;
+    }
+
+	}//namespace geometric
+	}//namespace function
+	}//namespace core
+}//namespace glm

glm/core/func_integer.hpp

@@ -0,0 +1,142 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2010 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2010-03-17
+// Updated : 2010-03-31
+// Licence : This source is under MIT License
+// File    : glm/core/func_integer.hpp
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#ifndef glm_core_func_integer
+#define glm_core_func_integer
+
+namespace glm
+{
+	namespace test{
+		void main_core_func_integer();
+	}//namespace test
+
+	namespace core{
+	namespace function{
+	//! Define integer functions from Section 8.8 of GLSL 4.00.8 specification. 
+	namespace integer{
+
+		//! Adds 32-bit unsigned integer x and y, returning the sum
+		//! modulo pow(2, 32). The value carry is set to 0 if the sum was
+		//! less than pow(2, 32), or to 1 otherwise.
+		//!
+		//! (From GLSL 4.00.08 specification, section 8.8)
+		template <typename genUType>
+		genUType uaddCarry(
+			genUType const & x, 
+			genUType const & y, 
+			genUType & carry);
+
+		//! Subtracts the 32-bit unsigned integer y from x, returning
+		//! the difference if non-negative, or pow(2, 32) plus the difference
+		//! otherwise. The value borrow is set to 0 if x >= y, or to 1 otherwise.
+		//! 
+		//! (From GLSL 4.00.08 specification, section 8.8)
+		template <typename genUType>
+		genUType usubBorrow(
+			genUType const & x, 
+			genUType const & y, 
+			genUType & borrow);
+		
+		//! Multiplies 32-bit integers x and y, producing a 64-bit
+		//! result. The 32 least-significant bits are returned in lsb.
+		//! The 32 most-significant bits are returned in msb.
+		//! (From GLSL 4.00.08 specification, section 8.8)
+		template <typename genUType>
+		void umulExtended(
+			genUType const & x, 
+			genUType const & y, 
+			genUType & msb, 
+			genUType & lsb);
+		
+		//! Multiplies 32-bit integers x and y, producing a 64-bit
+		//! result. The 32 least-significant bits are returned in lsb.
+		//! The 32 most-significant bits are returned in msb.
+		//! (From GLSL 4.00.08 specification, section 8.8)
+		template <typename genIType>
+		void imulExtended(
+			genIType const & x, 
+			genIType const & y, 
+			genIType & msb, 
+			genIType & lsb);
+
+
+		//! Extracts bits [offset, offset + bits - 1] from value,
+		//! returning them in the least significant bits of the result.
+		//! For unsigned data types, the most significant bits of the
+		//! result will be set to zero. For signed data types, the
+		//! most significant bits will be set to the value of bit offset + base – 1.
+		//!
+		//! If bits is zero, the result will be zero. The result will be
+		//! undefined if offset or bits is negative, or if the sum of
+		//! offset and bits is greater than the number of bits used
+		//! to store the operand.
+		//!
+		//! (From GLSL 4.00.08 specification, section 8.8)
+		template <typename genIUType>
+		genIUType bitfieldExtract(
+			genIUType const & Value, 
+			int const & Offset, 
+			int const & Bits);
+
+		//! Returns the insertion the bits least-significant bits of insert into base.
+		//!
+		//! The result will have bits [offset, offset + bits - 1] taken
+		//! from bits [0, bits – 1] of insert, and all other bits taken
+		//! directly from the corresponding bits of base. If bits is
+		//! zero, the result will simply be base. The result will be
+		//! undefined if offset or bits is negative, or if the sum of
+		//! offset and bits is greater than the number of bits used to
+		//! store the operand.
+		//!
+		//! (From GLSL 4.00.08 specification, section 8.8)
+		template <typename genIUType>
+		genIUType bitfieldInsert(
+			genIUType const & Base, 
+			genIUType const & Insert, 
+			int const & Offset, 
+			int const & Bits);
+
+		//! Returns the reversal of the bits of value. 
+		//! The bit numbered n of the result will be taken from bit (bits - 1) - n of value, 
+		//! where bits is the total number of bits used to represent value.
+		//! (From GLSL 4.00.08 specification, section 8.8)
+		template <typename genIUType>
+		genIUType bitfieldReverse(genIUType const & value);
+		
+		//! Returns the number of bits set to 1 in the binary representation of value.
+		//! (From GLSL 4.00.08 specification, section 8.8)
+		template <typename T, template <typename> class C>
+		typename C<T>::signed_type bitCount(C<T> const & Value);
+
+		//! Returns the bit number of the least significant bit set to
+		//! 1 in the binary representation of value. 
+		//! If value is zero, -1 will be returned.
+		//! (From GLSL 4.00.08 specification, section 8.8)
+		template <typename T, template <typename> class C>
+		typename C<T>::signed_type findLSB(C<T> const & Value);
+
+		//! Returns the bit number of the most significant bit in the binary representation of value.
+		//! For positive integers, the result will be the bit number of the most significant bit set to 1. 
+		//! For negative integers, the result will be the bit number of the most significant
+		//! bit set to 0. For a value of zero or negative one, -1 will be returned.
+		//! (From GLSL 4.00.08 specification, section 8.8)
+		template <typename T, template <typename> class C>
+		typename C<T>::signed_type findMSB(C<T> const & Value);
+
+	}//namespace integer
+	}//namespace function
+	}//namespace core
+
+	using namespace core::function::integer;
+}//namespace glm
+
+#include "func_integer.inl"
+
+#endif//glm_core_func_integer
+

glm/core/func_integer.inl

@@ -0,0 +1,600 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2010 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2010-03-17
+// Updated : 2010-03-31
+// Licence : This source is under MIT License
+// File    : glm/core/func_integer.inl
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+namespace glm
+{
+	namespace detail
+	{
+		
+	}//namespace detail
+
+	namespace core{
+	namespace function{
+	namespace integer
+	{
+		// uaddCarry
+		template <typename genUType>
+		inline genUType uaddCarry
+		(
+			genUType const & x, 
+			genUType const & y, 
+			genUType & Carry
+		)
+		{
+			detail::highp_uint_t Value64 = detail::highp_uint_t(x) + detail::highp_uint_t(y);
+			genUType Result = genUType(Value64 % (1 << 32));
+			Carry = (Value64 % (1 << 32)) > 1 : 1 : 0;
+			return Result;
+		}
+
+		template <typename T>
+		inline detail::tvec2<T> uaddCarry
+		(
+			detail::tvec2<T> const & x, 
+			detail::tvec2<T> const & y, 
+			detail::tvec2<T> & Carry
+		)
+		{
+			return detail::tvec2<T>(
+				uaddCarry(x[0], y[0], Carry[0]),
+				uaddCarry(x[1], y[1], Carry[1]));
+		}
+
+		template <typename T>
+		inline detail::tvec3<T> uaddCarry
+		(
+			detail::tvec3<T> const & x, 
+			detail::tvec3<T> const & y, 
+			detail::tvec3<T> & Carry
+		)
+		{
+			return detail::tvec3<T>(
+				uaddCarry(x[0], y[0], Carry[0]),
+				uaddCarry(x[1], y[1], Carry[1]),
+				uaddCarry(x[2], y[2], Carry[2]));
+		}
+
+		template <typename T>
+		inline detail::tvec4<T> uaddCarry
+		(
+			detail::tvec4<T> const & x, 
+			detail::tvec4<T> const & y, 
+			detail::tvec4<T> & Carry
+		)
+		{
+			return detail::tvec4<T>(
+				uaddCarry(x[0], y[0], Carry[0]),
+				uaddCarry(x[1], y[1], Carry[1]),
+				uaddCarry(x[2], y[2], Carry[2]),
+				uaddCarry(x[3], y[3], Carry[3]));
+		}
+
+		// usubBorrow
+		template <typename genUType>
+		inline genUType usubBorrow
+		(
+			genUType const & x, 
+			genUType const & y, 
+			genUType & Borrow
+		)
+		{
+			Borrow = x >= y ? 0 : 1;
+			if(x > y)
+				return genUType(detail::highp_int_t(x) - detail::highp_int_t(y));
+			else
+				return genUType(detail::highp_int_t(1 << 32) + detail::highp_int_t(x) - detail::highp_int_t(y));
+		}
+
+		template <typename T>
+		inline detail::tvec2<T> usubBorrow
+		(
+			detail::tvec2<T> const & x, 
+			detail::tvec2<T> const & y, 
+			detail::tvec2<T> & Borrow
+		)
+		{
+			return detail::tvec2<T>(
+				usubBorrow(x[0], y[0], Borrow[0]),
+				usubBorrow(x[1], y[1], Borrow[1]));
+		}
+
+		template <typename T>
+		inline detail::tvec3<T> usubBorrow
+		(
+			detail::tvec3<T> const & x, 
+			detail::tvec3<T> const & y, 
+			detail::tvec3<T> & Borrow
+		)
+		{
+			return detail::tvec3<T>(
+				usubBorrow(x[0], y[0], Borrow[0]),
+				usubBorrow(x[1], y[1], Borrow[1]),
+				usubBorrow(x[2], y[2], Borrow[2]));
+		}
+
+		template <typename T>
+		inline detail::tvec4<T> usubBorrow
+		(
+			detail::tvec4<T> const & x, 
+			detail::tvec4<T> const & y, 
+			detail::tvec4<T> & Borrow
+		)
+		{
+			return detail::tvec4<T>(
+				usubBorrow(x[0], y[0], Borrow[0]),
+				usubBorrow(x[1], y[1], Borrow[1]),
+				usubBorrow(x[2], y[2], Borrow[2]),
+				usubBorrow(x[3], y[3], Borrow[3]));
+		}
+
+		// umulExtended
+		template <typename genUType>
+		inline void umulExtended
+		(
+			genUType const & x, 
+			genUType const & y, 
+			genUType & msb, 
+			genUType & lsb
+		)
+		{
+			detail::highp_uint_t ValueX64 = x;
+			detail::highp_uint_t ValueY64 = y;
+			detail::highp_uint_t Value64 = ValueX64 * ValueY64;
+			msb = *(genUType*)&(Value64 & ((1 << 32) - 1));
+			lsb = *(genUType*)&(Value64 >> 32);
+		}
+
+		template <typename T>
+		inline detail::tvec2<T> umulExtended
+		(
+			detail::tvec2<T> const & x, 
+			detail::tvec2<T> const & y, 
+			detail::tvec2<T> & msb, 
+			detail::tvec2<T> & lsb
+		)
+		{
+			return detail::tvec2<T>(
+				umulExtended(x[0], y[0], msb, lsb),
+				umulExtended(x[1], y[1], msb, lsb));
+		}
+
+		template <typename T>
+		inline detail::tvec3<T> umulExtended
+		(
+			detail::tvec3<T> const & x, 
+			detail::tvec3<T> const & y, 
+			detail::tvec3<T> & msb, 
+			detail::tvec3<T> & lsb
+		)
+		{
+			return detail::tvec3<T>(
+				umulExtended(x[0], y[0], msb, lsb),
+				umulExtended(x[1], y[1], msb, lsb),
+				umulExtended(x[2], y[2], msb, lsb));
+		}
+
+		template <typename T>
+		inline detail::tvec4<T> umulExtended
+		(
+			detail::tvec4<T> const & x, 
+			detail::tvec4<T> const & y, 
+			detail::tvec4<T> & msb, 
+			detail::tvec4<T> & lsb
+		)
+		{
+			return detail::tvec4<T>(
+				umulExtended(x[0], y[0], msb, lsb),
+				umulExtended(x[1], y[1], msb, lsb),
+				umulExtended(x[2], y[2], msb, lsb),
+				umulExtended(x[3], y[3], msb, lsb));
+		}
+
+		// imulExtended
+		template <typename genIType>
+		void imulExtended
+		(
+			genIType const & x, 
+			genIType const & y, 
+			genIType & msb, 
+			genIType & lsb
+		)
+		{
+			detail::highp_int_t ValueX64 = x;
+			detail::highp_int_t ValueY64 = y;
+			detail::highp_int_t Value64 = ValueX64 * ValueY64;
+			msb = *(genIType*)&(Value64 & ((1 << 32) - 1));
+			lsb = *(genIType*)&(Value64 >> 32);
+		}
+
+		template <typename T>
+		inline detail::tvec2<T> imulExtended
+		(
+			detail::tvec2<T> const & x, 
+			detail::tvec2<T> const & y, 
+			detail::tvec2<T> & msb, 
+			detail::tvec2<T> & lsb
+		)
+		{
+			return detail::tvec2<T>(
+				imulExtended(x[0], y[0], msb, lsb),
+				imulExtended(x[1], y[1], msb, lsb));
+		}
+
+		template <typename T>
+		inline detail::tvec3<T> imulExtended
+		(
+			detail::tvec3<T> const & x, 
+			detail::tvec3<T> const & y, 
+			detail::tvec3<T> & msb, 
+			detail::tvec3<T> & lsb
+		)
+		{
+			return detail::tvec3<T>(
+				imulExtended(x[0], y[0], msb, lsb),
+				imulExtended(x[1], y[1], msb, lsb),
+				imulExtended(x[2], y[2], msb, lsb));
+		}
+
+		template <typename T>
+		inline detail::tvec4<T> imulExtended
+		(
+			detail::tvec4<T> const & x, 
+			detail::tvec4<T> const & y, 
+			detail::tvec4<T> & msb, 
+			detail::tvec4<T> & lsb
+		)
+		{
+			return detail::tvec4<T>(
+				imulExtended(x[0], y[0], msb, lsb),
+				imulExtended(x[1], y[1], msb, lsb),
+				imulExtended(x[2], y[2], msb, lsb),
+				imulExtended(x[3], y[3], msb, lsb));
+		}
+
+		// bitfieldExtract
+		template <typename genIUType>
+		genIUType bitfieldExtract
+		(
+			genIUType const & Value, 
+			int const & Offset, 
+			int const & Bits
+		)
+		{
+			GLM_STATIC_ASSERT(std::numeric_limits<genIUType>::is_integer);
+			GLM_STATIC_ASSERT(Offset + Bits <= sizeof(genIUType));
+
+			genIUType Result = 0;
+			if(std::numeric_limits<genIUType>::is_signed)
+				Result |= (1 << (sizeof(genIUType) * 8 - 1)) & (1 << (Offset + Bits - 1));
+
+			genIUType Mask = 0;
+			for(std::size_t Bit = Offset; Bit < Bits; ++Bit)
+				Mask |= (1 << Bit);
+
+			return Result | ((Mask & Value) >> Offset);
+		}
+
+		template <typename T>
+		inline detail::tvec2<T> bitfieldExtract
+		(
+			detail::tvec2<T> const & Value, 
+			int const & Offset, 
+			int const & Bits
+		)
+		{
+			return detail::tvec2<T>(
+				bitfieldExtract(value[0]),
+				bitfieldExtract(value[1]));
+		}
+
+		template <typename T>
+		inline detail::tvec3<T> bitfieldExtract
+		(
+			detail::tvec3<T> const & Value, 
+			int const & Offset, 
+			int const & Bits
+		)
+		{
+			return detail::tvec3<T>(
+				bitfieldExtract(value[0]),
+				bitfieldExtract(value[1]),
+				bitfieldExtract(value[2]));
+		}
+
+		template <typename T>
+		inline detail::tvec4<T> bitfieldExtract
+		(
+			detail::tvec4<T> const & Value, 
+			int const & Offset, 
+			int const & Bits
+		)
+		{
+			return detail::tvec4<T>(
+				bitfieldExtract(value[0]),
+				bitfieldExtract(value[1]),
+				bitfieldExtract(value[2]),
+				bitfieldExtract(value[3]));
+		}
+
+		// bitfieldInsert
+		template <typename genIUType>
+		inline genIUType bitfieldInsert
+		(
+			genIUType const & Base, 
+			genIUType const & Insert, 
+			int const & Offset, 
+			int const & Bits
+		)
+		{
+			GLM_STATIC_ASSERT(std::numeric_limits<genIUType>::is_integer);
+			GLM_STATIC_ASSERT(Offset + Bits <= sizeof(genIUType));
+
+			if(Bits == 0)
+				return Base;
+
+			genIUType Mask = 0;
+			for(std::size_t Bit = Offset; Bit < Offset + Bits; ++Bit)
+				Mask |= (1 << Bit);
+
+			return (Base & ~Mask) | (Insert & Mask);
+		}
+
+		template <typename T>
+		inline detail::tvec2<T> bitfieldInsert
+		(
+			detail::tvec2<T> const & Base, 
+			detail::tvec2<T> const & Insert, 
+			int const & Offset, 
+			int const & Bits
+		)
+		{
+			return detail::tvec2<T>(
+				bitfieldInsert(value[0]),
+				bitfieldInsert(value[1]));
+		}
+
+		template <typename T>
+		inline detail::tvec3<T> bitfieldInsert
+		(
+			detail::tvec3<T> const & Base, 
+			detail::tvec3<T> const & Insert, 
+			int const & Offset, 
+			int const & Bits
+		)
+		{
+			return detail::tvec3<T>(
+				bitfieldInsert(value[0]),
+				bitfieldInsert(value[1]),
+				bitfieldInsert(value[2]));
+		}
+
+		template <typename T>
+		inline detail::tvec4<T> bitfieldInsert
+		(
+			detail::tvec4<T> const & Base, 
+			detail::tvec4<T> const & Insert, 
+			int const & Offset, 
+			int const & Bits
+		)
+		{
+			return detail::tvec4<T>(
+				bitfieldInsert(value[0]),
+				bitfieldInsert(value[1]),
+				bitfieldInsert(value[2]),
+				bitfieldInsert(value[3]));
+		}
+
+		// bitfieldReverse
+		template <typename genIUType>
+		inline genIUType bitfieldReverse(genIUType const & Value)
+		{
+			GLM_STATIC_ASSERT(std::numeric_limits<genIUType>::is_integer);
+
+			genIUType Result = 0;
+			for(std::size_t i = 0; i < sizeof(genIUType) * std::size_t(8); ++i)
+				if(Value & (1 << i))
+					Result |= (1 << (sizeof(genIUType) * std::size_t(8)) - 1 - i);
+			return Result;
+		}	
+
+		template <typename T>
+		inline detail::tvec2<T> bitfieldReverse
+		(
+			detail::tvec2<T> const & value
+		)
+		{
+			return detail::tvec2<T>(
+				bitfieldReverse(value[0]),
+				bitfieldReverse(value[1]));
+		}
+
+		template <typename T>
+		inline detail::tvec3<T> bitfieldReverse
+		(
+			detail::tvec3<T> const & value
+		)
+		{
+			return detail::tvec3<T>(
+				bitfieldReverse(value[0]),
+				bitfieldReverse(value[1]),
+				bitfieldReverse(value[2]));
+		}
+
+		template <typename T>
+		inline detail::tvec4<T> bitfieldReverse
+		(
+			detail::tvec4<T> const & value
+		)
+		{
+			return detail::tvec4<T>(
+				bitfieldReverse(value[0]),
+				bitfieldReverse(value[1]),
+				bitfieldReverse(value[2]),
+				bitfieldReverse(value[3]));
+		}
+
+		// bitCount
+		template <typename genIUType>
+		int bitCount(genIUType const & Value)
+		{
+			GLM_STATIC_ASSERT(std::numeric_limits<genIUType>::is_integer);
+
+			int Count = 0;
+			for(std::size_t i = 0; i < sizeof(genIUType) * std::size_t(8); ++i)
+			{
+				if(Value & (1 << i))
+					++Count;
+			}
+			return Count;
+		}
+
+		template <typename T>
+		inline detail::tvec2<int> bitCount
+		(
+			detail::tvec2<T> const & value
+		)
+		{
+			return detail::tvec2<int>(
+				bitCount(value[0]),
+				bitCount(value[1]));
+		}
+
+		template <typename T>
+		inline detail::tvec3<int> bitCount
+		(
+			detail::tvec3<T> const & value
+		)
+		{
+			return detail::tvec3<int>(
+				bitCount(value[0]),
+				bitCount(value[1]),
+				bitCount(value[2]));
+		}
+
+		template <typename T>
+		inline detail::tvec4<int> bitCount
+		(
+			detail::tvec4<T> const & value
+		)
+		{
+			return detail::tvec4<int>(
+				bitCount(value[0]),
+				bitCount(value[1]),
+				bitCount(value[2]),
+				bitCount(value[3]));
+		}
+
+		// findLSB
+		template <typename genType>
+		inline int findLSB
+		(
+			genType const & Value
+		)
+		{
+			GLM_STATIC_ASSERT(std::numeric_limits<genIUType>::is_integer);
+			if(Value == 0)
+				return -1;
+
+			genType Bit;
+			for(Bit = genType(0); !(Value & (1 << Bit)); ++Bit){}
+			return Bit;
+		}
+
+		template <typename T>
+		inline detail::tvec2<int> findLSB
+		(
+			detail::tvec2<T> const & value
+		)
+		{
+			return detail::tvec2<int>(
+				findLSB(value[0]),
+				findLSB(value[1]));
+		}
+
+		template <typename T>
+		inline detail::tvec3<int> findLSB
+		(
+			detail::tvec3<T> const & value
+		)
+		{
+			return detail::tvec3<int>(
+				findLSB(value[0]),
+				findLSB(value[1]),
+				findLSB(value[2]));
+		}
+
+		template <typename T>
+		inline detail::tvec4<int> findLSB
+		(
+			detail::tvec4<T> const & value
+		)
+		{
+			return detail::tvec4<int>(
+				findLSB(value[0]),
+				findLSB(value[1]),
+				findLSB(value[2]),
+				findLSB(value[3]));
+		}
+
+		// findMSB
+		template <typename genType>
+		inline int findMSB
+		(
+			genType const & value
+		)
+		{
+			GLM_STATIC_ASSERT(std::numeric_limits<genIUType>::is_integer);
+			if(Value == 0)
+				return -1;
+
+			genType bit = genType(-1);
+			for(genType tmp = value; tmp; tmp >>= 1, ++bit){}
+			return bit;
+		}
+
+		template <typename T>
+		inline detail::tvec2<int> findMSB
+		(
+			detail::tvec2<T> const & value
+		)
+		{
+			return detail::tvec2<int>(
+				findMSB(value[0]),
+				findMSB(value[1]));
+		}
+
+		template <typename T>
+		inline detail::tvec3<int> findMSB
+		(
+			detail::tvec3<T> const & value
+		)
+		{
+			return detail::tvec3<int>(
+				findMSB(value[0]),
+				findMSB(value[1]),
+				findMSB(value[2]));
+		}
+
+		template <typename T>
+		inline detail::tvec4<int> findMSB
+		(
+			detail::tvec4<T> const & value
+		)
+		{
+			return detail::tvec4<int>(
+				findMSB(value[0]),
+				findMSB(value[1]),
+				findMSB(value[2]),
+				findMSB(value[3]));
+		}
+
+	}//namespace integer
+	}//namespace function
+	}//namespace core
+}//namespace glm

glm/core/func_matrix.hpp

@@ -0,0 +1,92 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2010 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2008-08-03
+// Updated : 2010-02-04
+// Licence : This source is under MIT License
+// File    : glm/core/func_matrix.hpp
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#ifndef glm_core_func_matrix
+#define glm_core_func_matrix
+
+namespace glm
+{
+	namespace test{
+		void main_core_func_matrix();
+	}//namespace test
+
+	namespace core{
+	namespace function{
+	//! Define all matrix functions from Section 8.5 of GLSL 1.30.8 specification. Included in glm namespace.
+	namespace matrix{
+
+	//! Multiply matrix x by matrix y component-wise, i.e., 
+	//! result[i][j] is the scalar product of x[i][j] and y[i][j].
+	//! (From GLSL 1.30.08 specification, section 8.5)
+	template <typename matType> 
+	matType matrixCompMult(
+		matType const & x, 
+		matType const & y);
+
+	//! Treats the first parameter c as a column vector 
+	//! and the second parameter r as a row vector
+	//! and does a linear algebraic matrix multiply c * r.
+	//! (From GLSL 1.30.08 specification, section 8.5)
+	template <typename vecType, typename matType> 
+	matType outerProduct(
+		vecType const & c, 
+		vecType const & r);
+
+	//! Returns the transposed matrix of x
+	//! (From GLSL 1.30.08 specification, section 8.5)
+	template <typename matType> 
+	typename matType::transpose_type transpose(
+		matType const & x);
+	
+	//! Return the determinant of a mat2 matrix. 
+	//! (From GLSL 1.50.09 specification, section 8.5)..
+	template <typename T> 
+	typename detail::tmat2x2<T>::value_type determinant(
+		detail::tmat2x2<T> const & m);
+
+	//! Return the determinant of a mat3 matrix. 
+	//! (From GLSL 1.50.09 specification, section 8.5).
+	template <typename T> 
+	typename detail::tmat3x3<T>::value_type determinant(
+		detail::tmat3x3<T> const & m);
+
+	//! Return the determinant of a mat4 matrix. 
+	//! (From GLSL 1.50.09 specification, section 8.5).
+	template <typename T> 
+	typename detail::tmat4x4<T>::value_type determinant(
+		detail::tmat4x4<T> const & m);
+
+	//! Return the inverse of a mat2 matrix. 
+	//! (From GLSL 1.40.07 specification, section 8.5).
+	template <typename T> 
+	detail::tmat2x2<T> inverse(
+		detail::tmat2x2<T> const & m);
+
+	//! Return the inverse of a mat3 matrix. 
+	//! (From GLSL 1.40.07 specification, section 8.5).
+	template <typename T> 
+	detail::tmat3x3<T> inverse(
+		detail::tmat3x3<T> const & m);
+
+	//! Return the inverse of a mat4 matrix. 
+	//! (From GLSL 1.40.07 specification, section 8.5).
+	template <typename T> 
+	detail::tmat4x4<T> inverse(
+		detail::tmat4x4<T> const & m);
+
+	}//namespace matrix
+	}//namespace function
+	}//namespace core
+
+	using namespace core::function::matrix;
+}//namespace glm
+
+#include "func_matrix.inl"
+
+#endif//glm_core_func_matrix

glm/core/func_matrix.inl

@@ -0,0 +1,559 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2010 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2008-03-08
+// Updated : 2010-02-04
+// Licence : This source is under MIT License
+// File    : glm/core/func_matrix.inl
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+namespace glm
+{
+	namespace core{
+	namespace function{
+	namespace matrix{
+
+    // matrixCompMult
+    template <typename matType>
+    inline matType matrixCompMult
+	(
+		matType const & x, 
+		matType const & y
+	)
+    {
+		GLM_STATIC_ASSERT(detail::type<typename matType::value_type>::is_float);
+
+        matType result(matType::null);
+		for(typename matType::size_type i = 0; i < matType::col_size(); ++i)
+			result[i] = x[i] * y[i];
+        return result;
+    }
+
+	// outerProduct
+    template <typename T>
+    inline detail::tmat2x2<T> outerProduct
+	(
+		detail::tvec2<T> const & c, 
+		detail::tvec2<T> const & r
+	)
+    {
+		GLM_STATIC_ASSERT(detail::type<T>::is_float);
+
+		detail::tmat2x2<T> m(detail::tmat2x2<T>::null);
+		m[0][0] = c[0] * r[0];
+		m[0][1] = c[1] * r[0];
+		m[1][0] = c[0] * r[1];
+		m[1][1] = c[1] * r[1];
+        return m;
+    }
+
+    template <typename T>
+    inline detail::tmat3x3<T> outerProduct
+	(
+		detail::tvec3<T> const & c, 
+		detail::tvec3<T> const & r
+	)
+    {
+		GLM_STATIC_ASSERT(detail::type<T>::is_float);
+
+		detail::tmat3x3<T> m(detail::tmat3x3<T>::null);
+		for(typename detail::tmat3x3<T>::size_type i = 0; i < detail::tmat3x3<T>::col_size(); ++i)
+			m[i] = c * r[i];
+        return m;
+    }
+
+    template <typename T>
+    inline detail::tmat4x4<T> outerProduct
+	(
+		detail::tvec4<T> const & c, 
+		detail::tvec4<T> const & r
+	)
+    {
+		GLM_STATIC_ASSERT(detail::type<T>::is_float);
+
+		detail::tmat4x4<T> m(detail::tmat4x4<T>::null);
+		for(typename detail::tmat4x4<T>::size_type i = 0; i < detail::tmat4x4<T>::col_size(); ++i)
+			m[i] = c * r[i];
+        return m;
+    }
+
+    template <typename T>
+	inline detail::tmat2x3<T> outerProduct
+	(
+		detail::tvec3<T> const & c, 
+		detail::tvec2<T> const & r
+	)
+	{
+		GLM_STATIC_ASSERT(detail::type<T>::is_float);
+
+		detail::tmat2x3<T> m(detail::tmat2x3<T>::null);
+		m[0][0] = c.x * r.x;
+		m[0][1] = c.y * r.x;
+		m[0][2] = c.z * r.x;
+		m[1][0] = c.x * r.y;
+		m[1][1] = c.y * r.y;
+		m[1][2] = c.z * r.y;
+		return m;
+	}
+
+    template <typename T>
+	inline detail::tmat3x2<T> outerProduct
+	(
+		detail::tvec2<T> const & c, 
+		detail::tvec3<T> const & r
+	)
+	{
+		GLM_STATIC_ASSERT(detail::type<T>::is_float);
+
+		detail::tmat3x2<T> m(detail::tmat3x2<T>::null);
+		m[0][0] = c.x * r.x;
+		m[0][1] = c.y * r.x;
+		m[1][0] = c.x * r.y;
+		m[1][1] = c.y * r.y;
+		m[2][0] = c.x * r.z;
+		m[2][1] = c.y * r.z;
+		return m;
+	}
+
+	template <typename T>
+	inline detail::tmat2x4<T> outerProduct
+	(
+		detail::tvec2<T> const & c, 
+		detail::tvec4<T> const & r
+	)
+	{
+		GLM_STATIC_ASSERT(detail::type<T>::is_float);
+
+		detail::tmat2x4<T> m(detail::tmat2x4<T>::null);
+		m[0][0] = c.x * r.x;
+		m[0][1] = c.y * r.x;
+		m[0][2] = c.z * r.x;
+		m[0][3] = c.w * r.x;
+		m[1][0] = c.x * r.y;
+		m[1][1] = c.y * r.y;
+		m[1][2] = c.z * r.y;
+		m[1][3] = c.w * r.y;
+		return m;
+	}
+
+	template <typename T>
+	inline detail::tmat4x2<T> outerProduct
+	(
+		detail::tvec4<T> const & c, 
+		detail::tvec2<T> const & r
+	)
+	{
+		GLM_STATIC_ASSERT(detail::type<T>::is_float);
+
+		detail::tmat4x2<T> m(detail::tmat4x2<T>::null);
+		m[0][0] = c.x * r.x;
+		m[0][1] = c.y * r.x;
+		m[1][0] = c.x * r.y;
+		m[1][1] = c.y * r.y;
+		m[2][0] = c.x * r.z;
+		m[2][1] = c.y * r.z;
+		m[3][0] = c.x * r.w;
+		m[3][1] = c.y * r.w;
+		return m;
+	}
+
+	template <typename T>
+	inline detail::tmat3x4<T> outerProduct
+	(
+		detail::tvec4<T> const & c, 
+		detail::tvec3<T> const & r
+	)
+	{
+		GLM_STATIC_ASSERT(detail::type<T>::is_float);
+
+		detail::tmat3x4<T> m(detail::tmat3x4<T>::null);
+		m[0][0] = c.x * r.x;
+		m[0][1] = c.y * r.x;
+		m[0][2] = c.z * r.x;
+		m[0][3] = c.w * r.x;
+		m[1][0] = c.x * r.y;
+		m[1][1] = c.y * r.y;
+		m[1][2] = c.z * r.y;
+		m[1][3] = c.w * r.y;
+		m[2][0] = c.x * r.z;
+		m[2][1] = c.y * r.z;
+		m[2][2] = c.z * r.z;
+		m[2][3] = c.w * r.z;
+		return m;
+	}
+
+	template <typename T>
+	inline detail::tmat4x3<T> outerProduct
+	(
+		detail::tvec3<T> const & c, 
+		detail::tvec4<T> const & r
+	)
+	{
+		GLM_STATIC_ASSERT(detail::type<T>::is_float);
+
+		detail::tmat4x3<T> m(detail::tmat4x3<T>::null);
+		m[0][0] = c.x * r.x;
+		m[0][1] = c.y * r.x;
+		m[0][2] = c.z * r.x;
+		m[1][0] = c.x * r.y;
+		m[1][1] = c.y * r.y;
+		m[1][2] = c.z * r.y;
+		m[2][0] = c.x * r.z;
+		m[2][1] = c.y * r.z;
+		m[2][2] = c.z * r.z;
+		m[3][0] = c.x * r.w;
+		m[3][1] = c.y * r.w;
+		m[3][2] = c.z * r.w;
+		return m;
+	}
+
+    template <typename T>
+    inline detail::tmat2x2<T> transpose
+	(
+		detail::tmat2x2<T> const & m
+	)
+    {
+		GLM_STATIC_ASSERT(detail::type<T>::is_float);
+
+        detail::tmat2x2<T> result(detail::tmat2x2<T>::null);
+        result[0][0] = m[0][0];
+        result[0][1] = m[1][0];
+        result[1][0] = m[0][1];
+        result[1][1] = m[1][1];
+        return result;
+    }
+
+    template <typename T>
+    inline detail::tmat3x3<T> transpose
+	(
+		detail::tmat3x3<T> const & m
+	)
+    {
+		GLM_STATIC_ASSERT(detail::type<T>::is_float);
+
+        detail::tmat3x3<T> result(detail::tmat3x3<T>::null);
+        result[0][0] = m[0][0];
+        result[0][1] = m[1][0];
+        result[0][2] = m[2][0];
+
+        result[1][0] = m[0][1];
+        result[1][1] = m[1][1];
+        result[1][2] = m[2][1];
+
+        result[2][0] = m[0][2];
+        result[2][1] = m[1][2];
+        result[2][2] = m[2][2];
+        return result;
+    }
+
+    template <typename T>
+    inline detail::tmat4x4<T> transpose
+	(
+		detail::tmat4x4<T> const & m
+	)
+    {
+		GLM_STATIC_ASSERT(detail::type<T>::is_float);
+
+        detail::tmat4x4<T> result(detail::tmat4x4<T>::null);
+        result[0][0] = m[0][0];
+        result[0][1] = m[1][0];
+        result[0][2] = m[2][0];
+        result[0][3] = m[3][0];
+
+        result[1][0] = m[0][1];
+        result[1][1] = m[1][1];
+        result[1][2] = m[2][1];
+        result[1][3] = m[3][1];
+
+        result[2][0] = m[0][2];
+        result[2][1] = m[1][2];
+        result[2][2] = m[2][2];
+        result[2][3] = m[3][2];
+
+        result[3][0] = m[0][3];
+        result[3][1] = m[1][3];
+        result[3][2] = m[2][3];
+        result[3][3] = m[3][3];
+        return result;
+    }
+
+    template <typename T>
+    inline detail::tmat2x3<T> transpose
+	(
+		detail::tmat3x2<T> const & m
+	)
+    {
+		GLM_STATIC_ASSERT(detail::type<T>::is_float);
+
+        detail::tmat2x3<T> result(detail::tmat2x3<T>::null);
+        result[0][0] = m[0][0];
+        result[0][1] = m[1][0];
+		result[0][2] = m[2][0];
+        result[1][0] = m[0][1];
+        result[1][1] = m[1][1];
+		result[1][2] = m[2][1];
+        return result;
+    }
+
+    template <typename T>
+    inline detail::tmat3x2<T> transpose
+	(
+		detail::tmat2x3<T> const & m
+	)
+    {
+		GLM_STATIC_ASSERT(detail::type<T>::is_float);
+
+        detail::tmat3x2<T> result(detail::tmat3x2<T>::null);
+        result[0][0] = m[0][0];
+        result[0][1] = m[1][0];
+        result[1][0] = m[0][1];
+        result[1][1] = m[1][1];
+        result[2][0] = m[0][2];
+        result[2][1] = m[1][2];
+        return result;
+    }
+
+    template <typename T>
+	inline detail::tmat2x4<T> transpose
+	(
+		detail::tmat4x2<T> const & m
+	)
+	{
+		GLM_STATIC_ASSERT(detail::type<T>::is_float);
+
+		detail::tmat2x4<T> result(detail::tmat2x4<T>::null);
+        result[0][0] = m[0][0];
+        result[0][1] = m[1][0];
+		result[0][2] = m[2][0];
+		result[0][3] = m[3][0];
+        result[1][0] = m[0][1];
+        result[1][1] = m[1][1];
+		result[1][2] = m[2][1];
+		result[1][3] = m[3][1];
+		return result;
+	}
+
+    template <typename T>
+	inline detail::tmat4x2<T> transpose
+	(
+		detail::tmat2x4<T> const & m
+	)
+	{
+		GLM_STATIC_ASSERT(detail::type<T>::is_float);
+
+        detail::tmat4x2<T> result(detail::tmat4x2<T>::null);
+        result[0][0] = m[0][0];
+        result[0][1] = m[1][0];
+        result[1][0] = m[0][1];
+        result[1][1] = m[1][1];
+        result[2][0] = m[0][2];
+        result[2][1] = m[1][2];
+        result[3][0] = m[0][3];
+        result[3][1] = m[1][3];
+        return result;
+	}
+
+    template <typename T>
+	inline detail::tmat3x4<T> transpose
+	(
+		detail::tmat4x3<T> const & m
+	)
+	{
+		GLM_STATIC_ASSERT(detail::type<T>::is_float);
+
+		detail::tmat3x4<T> result(detail::tmat3x4<T>::null);
+        result[0][0] = m[0][0];
+        result[0][1] = m[1][0];
+		result[0][2] = m[2][0];
+		result[0][3] = m[3][0];
+        result[1][0] = m[0][1];
+        result[1][1] = m[1][1];
+		result[1][2] = m[2][1];
+		result[1][3] = m[3][1];
+        result[2][0] = m[0][2];
+        result[2][1] = m[1][2];
+		result[2][2] = m[2][2];
+		result[2][3] = m[3][2];
+		return result;
+	}
+
+    template <typename T>
+	inline detail::tmat4x3<T> transpose
+	(
+		detail::tmat3x4<T> const & m
+	)
+	{
+		GLM_STATIC_ASSERT(detail::type<T>::is_float);
+
+        detail::tmat4x3<T> result(detail::tmat4x3<T>::null);
+        result[0][0] = m[0][0];
+        result[0][1] = m[1][0];
+		result[0][2] = m[2][0];
+        result[1][0] = m[0][1];
+        result[1][1] = m[1][1];
+		result[1][2] = m[2][1];
+        result[2][0] = m[0][2];
+        result[2][1] = m[1][2];
+		result[2][2] = m[2][2];
+        result[3][0] = m[0][3];
+        result[3][1] = m[1][3];
+		result[3][2] = m[2][3];
+        return result;
+	}
+
+	template <typename T>
+	inline typename detail::tmat2x2<T>::value_type determinant
+	(
+		detail::tmat2x2<T> const & m
+	)
+	{
+		return m[0][0] * m[1][1] - m[1][0] * m[0][1];
+	}
+
+	template <typename T>
+	inline typename detail::tmat3x3<T>::value_type determinant
+	(
+		detail::tmat3x3<T> const & m
+	)
+	{
+		return 
+			+ m[0][0] * (m[1][1] * m[2][2] - m[2][1] * m[1][2])
+			- m[1][0] * (m[0][1] * m[2][2] - m[2][1] * m[0][2])
+			+ m[2][0] * (m[0][1] * m[1][2] - m[1][1] * m[0][2]);
+	}
+
+	template <typename T>
+	inline typename detail::tmat4x4<T>::value_type determinant
+	(
+		detail::tmat4x4<T> const & m
+	)
+	{
+		T SubFactor00 = m[2][2] * m[3][3] - m[3][2] * m[2][3];
+		T SubFactor01 = m[2][1] * m[3][3] - m[3][1] * m[2][3];
+		T SubFactor02 = m[2][1] * m[3][2] - m[3][1] * m[2][2];
+		T SubFactor03 = m[2][0] * m[3][3] - m[3][0] * m[2][3];
+		T SubFactor04 = m[2][0] * m[3][2] - m[3][0] * m[2][2];
+		T SubFactor05 = m[2][0] * m[3][1] - m[3][0] * m[2][1];
+
+		detail::tvec4<T> DetCof(
+			+ (m[1][1] * SubFactor00 - m[1][2] * SubFactor01 + m[1][3] * SubFactor02),
+			- (m[1][0] * SubFactor00 - m[1][2] * SubFactor03 + m[1][3] * SubFactor04),
+			+ (m[1][0] * SubFactor01 - m[1][1] * SubFactor03 + m[1][3] * SubFactor05),
+			- (m[1][0] * SubFactor02 - m[1][1] * SubFactor04 + m[1][2] * SubFactor05));
+
+		return m[0][0] * DetCof[0]
+			 + m[0][1] * DetCof[1]
+			 + m[0][2] * DetCof[2]
+			 + m[0][3] * DetCof[3];
+	}
+
+	template <typename T> 
+	inline detail::tmat2x2<T> inverse
+	(
+		detail::tmat2x2<T> const & m
+	)
+	{
+		//valType Determinant = m[0][0] * m[1][1] - m[1][0] * m[0][1];
+		T Determinant = determinant(m);
+
+		detail::tmat2x2<T> Inverse(
+			+ m[1][1] / Determinant,
+			- m[1][0] / Determinant,
+			- m[0][1] / Determinant, 
+			+ m[0][0] / Determinant);
+
+		return Inverse;
+	}
+
+	template <typename T> 
+	inline detail::tmat3x3<T> inverse
+	(
+		detail::tmat3x3<T> const & m
+	)
+	{
+		//valType Determinant = m[0][0] * (m[1][1] * m[2][2] - m[2][1] * m[1][2])
+		//					- m[1][0] * (m[0][1] * m[2][2] - m[2][1] * m[0][2])
+		//					+ m[2][0] * (m[0][1] * m[1][2] - m[1][1] * m[0][2]);
+
+		T Determinant = determinant(m);
+
+		detail::tmat3x3<T> Inverse(detail::tmat3x3<T>::null);
+		Inverse[0][0] = + (m[1][1] * m[2][2] - m[2][1] * m[1][2]);
+		Inverse[1][0] = - (m[1][0] * m[2][2] - m[2][0] * m[1][2]);
+		Inverse[2][0] = + (m[1][0] * m[2][1] - m[2][0] * m[1][1]);
+		Inverse[0][1] = - (m[0][1] * m[2][2] - m[2][1] * m[0][2]);
+		Inverse[1][1] = + (m[0][0] * m[2][2] - m[2][0] * m[0][2]);
+		Inverse[2][1] = - (m[0][0] * m[2][1] - m[2][0] * m[0][1]);
+		Inverse[0][2] = + (m[0][1] * m[1][2] - m[1][1] * m[0][2]);
+		Inverse[1][2] = - (m[0][0] * m[1][2] - m[1][0] * m[0][2]);
+		Inverse[2][2] = + (m[0][0] * m[1][1] - m[1][0] * m[0][1]);
+		Inverse /= Determinant;
+
+		return Inverse;
+	}
+
+	template <typename T> 
+	inline detail::tmat4x4<T> inverse
+	(
+		detail::tmat4x4<T> const & m
+	)
+	{
+		T Coef00 = m[2][2] * m[3][3] - m[3][2] * m[2][3];
+		T Coef02 = m[1][2] * m[3][3] - m[3][2] * m[1][3];
+		T Coef03 = m[1][2] * m[2][3] - m[2][2] * m[1][3];
+
+		T Coef04 = m[2][1] * m[3][3] - m[3][1] * m[2][3];
+		T Coef06 = m[1][1] * m[3][3] - m[3][1] * m[1][3];
+		T Coef07 = m[1][1] * m[2][3] - m[2][1] * m[1][3];
+
+		T Coef08 = m[2][1] * m[3][2] - m[3][1] * m[2][2];
+		T Coef10 = m[1][1] * m[3][2] - m[3][1] * m[1][2];
+		T Coef11 = m[1][1] * m[2][2] - m[2][1] * m[1][2];
+
+		T Coef12 = m[2][0] * m[3][3] - m[3][0] * m[2][3];
+		T Coef14 = m[1][0] * m[3][3] - m[3][0] * m[1][3];
+		T Coef15 = m[1][0] * m[2][3] - m[2][0] * m[1][3];
+
+		T Coef16 = m[2][0] * m[3][2] - m[3][0] * m[2][2];
+		T Coef18 = m[1][0] * m[3][2] - m[3][0] * m[1][2];
+		T Coef19 = m[1][0] * m[2][2] - m[2][0] * m[1][2];
+
+		T Coef20 = m[2][0] * m[3][1] - m[3][0] * m[2][1];
+		T Coef22 = m[1][0] * m[3][1] - m[3][0] * m[1][1];
+		T Coef23 = m[1][0] * m[2][1] - m[2][0] * m[1][1];
+
+		detail::tvec4<T> const SignA(+1, -1, +1, -1);
+		detail::tvec4<T> const SignB(-1, +1, -1, +1);
+
+		detail::tvec4<T> Fac0(Coef00, Coef00, Coef02, Coef03);
+		detail::tvec4<T> Fac1(Coef04, Coef04, Coef06, Coef07);
+		detail::tvec4<T> Fac2(Coef08, Coef08, Coef10, Coef11);
+		detail::tvec4<T> Fac3(Coef12, Coef12, Coef14, Coef15);
+		detail::tvec4<T> Fac4(Coef16, Coef16, Coef18, Coef19);
+		detail::tvec4<T> Fac5(Coef20, Coef20, Coef22, Coef23);
+
+		detail::tvec4<T> Vec0(m[1][0], m[0][0], m[0][0], m[0][0]);
+		detail::tvec4<T> Vec1(m[1][1], m[0][1], m[0][1], m[0][1]);
+		detail::tvec4<T> Vec2(m[1][2], m[0][2], m[0][2], m[0][2]);
+		detail::tvec4<T> Vec3(m[1][3], m[0][3], m[0][3], m[0][3]);
+
+		detail::tvec4<T> Inv0 = SignA * (Vec1 * Fac0 - Vec2 * Fac1 + Vec3 * Fac2);
+		detail::tvec4<T> Inv1 = SignB * (Vec0 * Fac0 - Vec2 * Fac3 + Vec3 * Fac4);
+		detail::tvec4<T> Inv2 = SignA * (Vec0 * Fac1 - Vec1 * Fac3 + Vec3 * Fac5);
+		detail::tvec4<T> Inv3 = SignB * (Vec0 * Fac2 - Vec1 * Fac4 + Vec2 * Fac5);
+
+		detail::tmat4x4<T> Inverse(Inv0, Inv1, Inv2, Inv3);
+
+		detail::tvec4<T> Row0(Inverse[0][0], Inverse[1][0], Inverse[2][0], Inverse[3][0]);
+
+		T Determinant = glm::dot(m[0], Row0);
+
+		Inverse /= Determinant;
+	    
+		return Inverse;
+	}
+
+	}//namespace matrix
+	}//namespace function
+	}//namespace core
+}//namespace glm

glm/core/func_noise.hpp

@@ -0,0 +1,53 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2010 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2008-08-01
+// Updated : 2008-09-10
+// Licence : This source is under MIT License
+// File    : glm/core/func_noise.hpp
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#ifndef glm_core_func_noise
+#define glm_core_func_noise
+
+namespace glm
+{
+	namespace test{
+		void main_core_func_noise();
+	}//namespace test
+
+	namespace core{
+	namespace function{
+	// Define all noise functions from Section 8.9 of GLSL 1.30.8 specification. Included in glm namespace.
+	namespace noise{
+
+	// Returns a 1D noise value based on the input value x.
+	// From GLSL 1.30.08 specification, section 8.9.
+	template <typename genType>
+	typename genType::value_type noise1(genType const & x);
+
+	// Returns a 2D noise value based on the input value x.
+	// From GLSL 1.30.08 specification, section 8.9.
+	template <typename genType>
+	detail::tvec2<typename genType::value_type> noise2(genType const & x);
+
+	// Returns a 3D noise value based on the input value x.
+	// From GLSL 1.30.08 specification, section 8.9.
+	template <typename genType>
+	detail::tvec3<typename genType::value_type> noise3(genType const & x);
+
+	// Returns a 4D noise value based on the input value x.
+	// From GLSL 1.30.08 specification, section 8.9.
+	template <typename genType>
+	detail::tvec4<typename genType::value_type> noise4(genType const & x);
+
+	}//namespace noise
+	}//namespace function
+	}//namespace core
+
+	using namespace core::function::noise;
+}//namespace glm
+
+#include "func_noise.inl"
+
+#endif//glm_core_func_noise

glm/core/func_noise.inl

@@ -0,0 +1,305 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2010 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2008-08-01
+// Updated : 2008-09-23
+// Licence : This source is under MIT License
+// File    : glm/core/func_noise.inl
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+namespace glm
+{
+	namespace core{
+	namespace function{
+	namespace noise{
+
+	// noise1
+	template <typename genType>
+	inline genType noise1
+	(
+		genType const & x
+	)
+	{
+		GLM_STATIC_ASSERT(detail::type<genType>::is_float);
+
+		int iNbr = int(x + genType(3) / genType(2)) * 1103515245 + 12345;
+		return genType(int(iNbr / genType(65536)) % 32768) / genType(32767);
+	}
+
+	template <typename T>
+	inline typename detail::tvec2<T>::value_type noise1
+	(
+		detail::tvec2<T> const & x
+	)
+	{
+		T tmp(0);
+		for(typename detail::tvec2<T>::size_type i = 0; i < detail::tvec2<T>::value_size(); ++i)
+			tmp += x[i];
+		return noise1(tmp);
+	}
+
+	template <typename T>
+	inline typename detail::tvec3<T>::value_type noise1
+	(
+		detail::tvec3<T> const & x
+	)
+	{
+		T tmp(0);
+		for(typename detail::tvec3<T>::size_type i = 0; i < detail::tvec3<T>::value_size(); ++i)
+			tmp += x[i];
+		return noise1(tmp);
+	}
+
+	template <typename T>
+	inline typename detail::tvec4<T>::value_type noise1
+	(
+		detail::tvec4<T> const & x
+	)
+	{
+		T tmp(0);
+		for(typename detail::tvec4<T>::size_type i = 0; i < detail::tvec4<T>::value_size(); ++i)
+			tmp += x[i];
+		return noise1(tmp);
+	}
+
+	// noise2
+	template <typename genType>
+	inline detail::tvec2<genType> noise2
+	(
+		genType const & x
+	)
+	{
+		GLM_STATIC_ASSERT(detail::type<genType>::is_float);
+
+		genType f1 = x * genType(1103515245) + genType(12345);
+		genType f2 = f1 * genType(1103515245) + genType(12345);
+		return detail::tvec2<genType>(
+			noise1(f1),
+			noise1(f2));
+	}
+
+	template <typename T>
+	inline detail::tvec2<T> noise2
+	(
+		detail::tvec2<T> const & x
+	)
+	{
+		GLM_STATIC_ASSERT(detail::type<T>::is_float);
+
+		T f0(0);
+		for(typename detail::tvec2<T>::size_type i = 0; i < detail::tvec2<T>::value_size(); ++i)
+			f0 += x[i];
+		
+		T f1 = f0 * T(1103515245) + T(12345);
+		T f2 = f1 * T(1103515245) + T(12345);
+		return detail::tvec2<T>(
+			noise1(f1),
+			noise1(f2));
+	}
+
+	template <typename T>
+	inline detail::tvec2<T> noise2
+	(
+		detail::tvec3<T> const & x
+	)
+	{
+		GLM_STATIC_ASSERT(detail::type<T>::is_float);
+
+		T f0(0);
+		for(typename detail::tvec3<T>::size_type i = 0; i < detail::tvec3<T>::value_size(); ++i)
+			f0 += x[i];
+
+		T f1 = f0 * T(1103515245) + T(12345);
+		T f2 = f1 * T(1103515245) + T(12345);
+		return detail::tvec2<T>(
+			noise1(f1),
+			noise1(f2));
+	}
+
+	template <typename T>
+	inline detail::tvec2<T> noise2
+	(
+		detail::tvec4<T> const & x
+	)
+	{
+		GLM_STATIC_ASSERT(detail::type<T>::is_float);
+
+		T f0(0);
+		for(typename detail::tvec4<T>::size_type i = 0; i < detail::tvec4<T>::value_size(); ++i)
+			f0 += x[i];
+		
+		T f1 = f0 * T(1103515245) + T(12345);
+		T f2 = f1 * T(1103515245) + T(12345);
+		return detail::tvec2<T>(
+			noise1(f1),
+			noise1(f2));
+	}
+
+	// noise3
+	template <typename genType>
+	inline detail::tvec3<genType> noise3
+	(
+		genType const & x
+	)
+	{
+		GLM_STATIC_ASSERT(detail::type<genType>::is_float);
+
+		genType f1 = x * genType(1103515245) + genType(12345);
+		genType f2 = f1 * genType(1103515245) + genType(12345);
+		genType f3 = f2 * genType(1103515245) + genType(12345);
+		return detail::tvec3<genType>(
+			noise1(f1),
+			noise1(f2),
+			noise1(f3));
+	}
+
+	template <typename T>
+	inline detail::tvec3<T> noise3
+	(
+		detail::tvec2<T> const & x
+	)
+	{
+		GLM_STATIC_ASSERT(detail::type<T>::is_float);
+
+		T f0(0);
+		for(typename detail::tvec2<T>::size_type i = 0; i < detail::tvec2<T>::value_size(); ++i)
+			f0 += x[i];
+		T f1 = f0 * T(1103515245) + T(12345);
+		T f2 = f1 * T(1103515245) + T(12345);
+		T f3 = f2 * T(1103515245) + T(12345);
+		return detail::tvec3<T>(
+			noise1(f1),
+			noise1(f2),
+			noise1(f3));
+	}
+
+	template <typename T>
+	inline detail::tvec3<T> noise3
+	(
+		detail::tvec3<T> const & x
+	)
+	{
+		GLM_STATIC_ASSERT(detail::type<T>::is_float);
+
+		T f0(0);
+		for(typename detail::tvec3<T>::size_type i = 0; i < detail::tvec3<T>::value_size(); ++i)
+			f0 += x[i];
+		T f1 = f0 * T(1103515245) + T(12345);
+		T f2 = f1 * T(1103515245) + T(12345);
+		T f3 = f2 * T(1103515245) + T(12345);
+		return detail::tvec3<T>(
+			noise1(f1),
+			noise1(f2),
+			noise1(f3));
+	}
+
+	template <typename T>
+	inline detail::tvec3<T> noise3
+	(
+		detail::tvec4<T> const & x
+	)
+	{
+		GLM_STATIC_ASSERT(detail::type<T>::is_float);
+
+		T f0(0);
+		for(typename detail::tvec4<T>::size_type i = 0; i < detail::tvec4<T>::value_size(); ++i)
+			f0 += x[i];
+		T f1 = f0 * T(1103515245) + T(12345);
+		T f2 = f1 * T(1103515245) + T(12345);
+		T f3 = f2 * T(1103515245) + T(12345);
+		return detail::tvec3<T>(
+			noise1(f1),
+			noise1(f2),
+			noise1(f3));
+	}
+
+	// noise4
+	template <typename genType>
+	inline detail::tvec4<genType> noise4
+	(
+		genType const & x
+	)
+	{
+		GLM_STATIC_ASSERT(detail::type<genType>::is_float);
+
+		genType f1 = x * genType(1103515245) + genType(12345);
+		genType f2 = f1 * genType(1103515245) + genType(12345);
+		genType f3 = f2 * genType(1103515245) + genType(12345);
+		genType f4 = f3 * genType(1103515245) + genType(12345);
+		return detail::tvec4<genType>(
+			noise1(f1),
+			noise1(f2),
+			noise1(f3),
+			noise1(f4));
+	}
+
+	template <typename T>
+	inline detail::tvec4<T> noise4
+	(
+		detail::tvec2<T> const & x
+	)
+	{
+		GLM_STATIC_ASSERT(detail::type<T>::is_float);
+
+		T f0(0);
+		for(typename detail::tvec2<T>::size_type i = 0; i < detail::tvec2<T>::value_size(); ++i)
+			f0 += x[i];
+		T f1 = f0 * T(1103515245) + T(12345);
+		T f2 = f1 * T(1103515245) + T(12345);
+		T f3 = f2 * T(1103515245) + T(12345);
+		T f4 = f3 * T(1103515245) + T(12345);
+		return detail::tvec4<T>(
+			noise1(f1),
+			noise1(f2),
+			noise1(f3),
+			noise1(f4));
+	}
+
+	template <typename T>
+	inline detail::tvec4<T> noise4
+	(
+		detail::tvec3<T> const & x
+	)
+	{
+		GLM_STATIC_ASSERT(detail::type<T>::is_float);
+
+		T f0(0);
+		for(typename detail::tvec3<T>::size_type i = 0; i < detail::tvec3<T>::value_size()(); ++i)
+			f0 += x[i];
+		T f1 = f0 * T(1103515245) + T(12345);
+		T f2 = f1 * T(1103515245) + T(12345);
+		T f3 = f2 * T(1103515245) + T(12345);
+		T f4 = f3 * T(1103515245) + T(12345);
+		return detail::tvec4<T>(
+			noise1(f1),
+			noise1(f2),
+			noise1(f3),
+			noise1(f4));
+	}
+
+	template <typename T>
+	inline detail::tvec4<T> noise4
+	(
+		detail::tvec4<T> const & x
+	)
+	{
+		GLM_STATIC_ASSERT(detail::type<T>::is_float);
+
+		T f0(0);
+		for(typename detail::tvec4<T>::size_type i = 0; i < detail::tvec4<T>::value_size()(); ++i)
+			f0 += x[i];
+		T f1 = f0 * T(1103515245) + T(12345);
+		T f2 = f1 * T(1103515245) + T(12345);
+		T f3 = f2 * T(1103515245) + T(12345);
+		T f4 = f3 * T(1103515245) + T(12345);
+		return detail::tvec4<T>(
+			noise1(f1),
+			noise1(f2),
+			noise1(f3),
+			noise1(f4));
+	}
+
+	}//namespace noise
+	}//namespace function
+	}//namespace core
+}//namespace glm

glm/core/func_packing.hpp

@@ -0,0 +1,45 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2010 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2010-03-17
+// Updated : 2010-03-17
+// Licence : This source is under MIT License
+// File    : glm/core/func_packing.hpp
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#ifndef glm_core_func_packing
+#define glm_core_func_packing
+
+namespace glm
+{
+	namespace test{
+		void main_core_func_packing();
+	}//namespace test
+
+	namespace core{
+	namespace function{
+	//! Define packing functions from section 8.4 floating-point pack and unpack functions of GLSL 4.00.8 specification
+	namespace packing
+	{
+		uint packUnorm2x16(vec2 const & v);
+		uint packUnorm4x8(vec4 const & v);
+		uint packSnorm4x8(vec4 const & v);
+
+		vec2 unpackUnorm2x16(uint const & p);
+		vec4 unpackUnorm4x8(uint const & p);
+		vec4 unpackSnorm4x8(uint const & p);
+
+		double packDouble2x32(uvec2 const & v);
+		uvec2 unpackDouble2x32(double const & v);
+
+	}//namespace packing
+	}//namespace function
+	}//namespace core
+
+	using namespace core::function::packing;
+}//namespace glm
+
+#include "func_packing.inl"
+
+#endif//glm_core_func_packing
+

glm/core/func_packing.inl

@@ -0,0 +1,25 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2010 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2010-03-17
+// Updated : 2010-03-17
+// Licence : This source is under MIT License
+// File    : glm/core/func_packing.inl
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+namespace glm
+{
+	namespace detail
+	{
+		
+	}//namespace detail
+
+	namespace core{
+	namespace function{
+	namespace packing{
+
+
+	}//namespace packing
+	}//namespace function
+	}//namespace core
+}//namespace glm

glm/core/func_trigonometric.hpp

@@ -0,0 +1,125 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2010 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2008-08-01
+// Updated : 2008-09-10
+// Licence : This source is under MIT License
+// File    : glm/core/func_trigonometric.hpp
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#ifndef glm_core_func_trigonometric
+#define glm_core_func_trigonometric
+
+namespace glm
+{
+	namespace test{
+		void main_core_func_trigonometric();
+	}//namespace test
+
+	namespace core{
+	namespace function{
+	//! Define Angle and trigonometry functions 
+	//! from Section 8.1 of GLSL 1.30.8 specification. 
+	//! Included in glm namespace.
+	namespace trigonometric{
+
+	//! Converts degrees to radians and returns the result.
+	//! (From GLSL 1.30.08 specification, section 8.1)
+	template <typename genType> 
+	genType radians(genType const & degrees);
+
+	//! Converts radians to degrees and returns the result.
+	//! (From GLSL 1.30.08 specification, section 8.1)
+	template <typename genType> 
+	genType degrees(genType const & radians);
+
+	//! The standard trigonometric sine function. 
+	//! The values returned by this function will range from [-1, 1].
+	//! (From GLSL 1.30.08 specification, section 8.1)
+	template <typename genType> 
+	genType sin(genType const & angle);
+
+	//! The standard trigonometric cosine function. 
+	//! The values returned by this function will range from [-1, 1].
+	//! (From GLSL 1.30.08 specification, section 8.1)
+	template <typename genType> 
+	genType cos(genType const & angle);
+
+	//! The standard trigonometric tangent function.
+	//! (From GLSL 1.30.08 specification, section 8.1)
+	template <typename genType> 
+	genType tan(genType const & angle); 
+
+	//! Arc sine. Returns an angle whose sine is x. 
+	//! The range of values returned by this function is [-PI/2, PI/2]. 
+	//! Results are undefined if |x| > 1.
+	//! (From GLSL 1.30.08 specification, section 8.1)
+	template <typename genType> 
+	genType asin(genType const & x);
+
+	//! Arc cosine. Returns an angle whose sine is x. 
+	//! The range of values returned by this function is [0, PI]. 
+	//! Results are undefined if |x| > 1.
+	//! (From GLSL 1.30.08 specification, section 8.1)
+	template <typename genType> 
+	genType acos(genType const & x);
+
+	//! Arc tangent. Returns an angle whose tangent is y/x. 
+	//! The signs of x and y are used to determine what 
+	//! quadrant the angle is in. The range of values returned 
+	//! by this function is [-PI, PI]. Results are undefined 
+	//! if x and y are both 0. 
+	//! (From GLSL 1.30.08 specification, section 8.1)
+	template <typename genType> 
+	genType atan(genType const & y, genType const & x);
+
+	//! Arc tangent. Returns an angle whose tangent is y_over_x. 
+	//! The range of values returned by this function is [-PI/2, PI/2].
+	//! (From GLSL 1.30.08 specification, section 8.1)
+	template <typename genType> 
+	genType atan(genType const & y_over_x);
+
+	//! Returns the hyperbolic sine function, (exp(x) - exp(-x)) / 2
+	//! (From GLSL 1.30.08 specification, section 8.1)
+	template <typename genType> 
+	genType sinh(genType const & angle);
+
+	//! Returns the hyperbolic cosine function, (exp(x) + exp(-x)) / 2
+	//! (From GLSL 1.30.08 specification, section 8.1)
+	template <typename genType> 
+	genType cosh(genType const & angle);
+
+	//! Returns the hyperbolic tangent function, sinh(angle) / cosh(angle)
+	//! (From GLSL 1.30.08 specification, section 8.1)
+	template <typename genType> 
+	genType tanh(genType const & angle);
+
+	//! Arc hyperbolic sine; returns the inverse of sinh.
+	//! (From GLSL 1.30.08 specification, section 8.1)
+	template <typename genType> 
+	genType asinh(genType const & x);
+	
+	//! Arc hyperbolic cosine; returns the non-negative inverse
+	//! of cosh. Results are undefined if x < 1.
+	//! (From GLSL 1.30.08 specification, section 8.1)
+	template <typename genType> 
+	genType acosh(genType const & x);
+
+	//! Arc hyperbolic tangent; returns the inverse of tanh.
+	//! Results are undefined if abs(x) >= 1.
+	//! (From GLSL 1.30.08 specification, section 8.1)
+	template <typename genType> 
+	genType atanh(genType const & x);
+
+	}//namespace trigonometric
+	}//namespace function
+	}//namespace core
+
+	using namespace core::function::trigonometric;
+}//namespace glm
+
+#include "func_trigonometric.inl"
+
+#endif//glm_core_func_trigonometric
+
+

glm/core/func_trigonometric.inl

@@ -0,0 +1,745 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2010 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2008-08-03
+// Updated : 2008-09-14
+// Licence : This source is under MIT License
+// File    : glm/core/func_trigonometric.inl
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+namespace glm
+{
+	namespace core{
+	namespace function{
+	namespace trigonometric{
+
+    // radians
+    template <typename genType>
+    inline genType radians
+	(
+		genType const & degrees
+	)
+    {
+		GLM_STATIC_ASSERT(detail::type<genType>::is_float);
+
+        const genType pi = genType(3.1415926535897932384626433832795);
+        return degrees * (pi / genType(180));
+    }
+
+    template <typename T>
+	inline detail::tvec2<T> radians
+	(
+		detail::tvec2<T> const & degrees
+	)
+    {
+        return detail::tvec2<T>(
+            radians(degrees.x),
+            radians(degrees.y));
+    }
+
+    template <typename T>
+    inline detail::tvec3<T> radians
+	(
+		detail::tvec3<T> const & degrees
+	)
+    {
+        return detail::tvec3<T>(
+            radians(degrees.x),
+            radians(degrees.y),
+            radians(degrees.z));
+    }
+
+    template <typename T>
+    inline detail::tvec4<T> radians
+	(
+		detail::tvec4<T> const & degrees
+	)
+    {
+        return detail::tvec4<T>(
+            radians(degrees.x),
+            radians(degrees.y),
+            radians(degrees.z),
+            radians(degrees.w));
+    }
+
+    // degrees
+    template <typename genType>
+    inline genType degrees
+	(
+		genType const & radians
+	)
+    {
+		GLM_STATIC_ASSERT(detail::type<genType>::is_float);
+
+        const genType pi = genType(3.1415926535897932384626433832795);
+        return radians * (genType(180) / pi);
+    }
+
+    template <typename T>
+    inline detail::tvec2<T> degrees
+	(
+		detail::tvec2<T> const & radians
+	)
+    {
+        return detail::tvec2<T>(
+            degrees(radians.x),
+            degrees(radians.y));
+    }
+
+    template <typename T>
+    inline detail::tvec3<T> degrees
+	(	
+		detail::tvec3<T> const & radians
+	)
+    {
+        return detail::tvec3<T>(
+            degrees(radians.x),
+            degrees(radians.y),
+            degrees(radians.z));
+    }
+
+    template <typename T>
+    inline detail::tvec4<T> degrees
+	(
+		detail::tvec4<T> const & radians
+	)
+    {
+        return detail::tvec4<T>(
+            degrees(radians.x),
+            degrees(radians.y),
+            degrees(radians.z),
+            degrees(radians.w));
+    }
+
+    // sin
+    template <typename genType>
+    inline genType sin
+	(
+		genType const & angle
+	)
+    {
+		GLM_STATIC_ASSERT(detail::type<genType>::is_float);
+
+		return ::std::sin(angle);
+    }
+
+    template <typename T>
+    inline detail::tvec2<T> sin
+	(
+		detail::tvec2<T> const & angle
+	)
+    {
+        return detail::tvec2<T>(
+            sin(angle.x),
+            sin(angle.y));
+    }
+
+    template <typename T>
+    inline detail::tvec3<T> sin
+	(
+		detail::tvec3<T> const & angle
+	)
+    {
+        return detail::tvec3<T>(
+            sin(angle.x),
+            sin(angle.y),
+            sin(angle.z));
+    }
+
+    template <typename T>
+    inline detail::tvec4<T> sin
+	(
+		detail::tvec4<T> const & angle
+	)
+    {
+        return detail::tvec4<T>(
+            sin(angle.x),
+            sin(angle.y),
+            sin(angle.z),
+            sin(angle.w));
+    }
+
+    // cos
+    template <typename genType>
+    inline genType cos(genType const & angle)
+    {
+		GLM_STATIC_ASSERT(detail::type<genType>::is_float);
+
+        return ::std::cos(angle);
+    }
+
+    template <typename T>
+    inline detail::tvec2<T> cos
+	(
+		detail::tvec2<T> const & angle
+	)
+    {
+        return detail::tvec2<T>(
+            cos(angle.x),
+            cos(angle.y));
+    }
+
+    template <typename T>
+    inline detail::tvec3<T> cos
+	(
+		detail::tvec3<T> const & angle
+	)
+    {
+        return detail::tvec3<T>(
+            cos(angle.x),
+            cos(angle.y),
+            cos(angle.z));
+    }
+
+    template <typename T>
+    inline detail::tvec4<T> cos
+	(	
+		detail::tvec4<T> const & angle
+	)
+    {
+        return detail::tvec4<T>(
+            cos(angle.x),
+            cos(angle.y),
+            cos(angle.z),
+            cos(angle.w));
+    }
+
+    // tan
+    template <typename genType>
+    inline genType tan
+	(
+		genType const & angle
+	)
+    {
+		GLM_STATIC_ASSERT(detail::type<genType>::is_float);
+
+        return ::std::tan(angle);
+    }
+
+    template <typename T>
+    inline detail::tvec2<T> tan
+	(
+		detail::tvec2<T> const & angle
+	)
+    {
+        return detail::tvec2<T>(
+            tan(angle.x),
+            tan(angle.y));
+    }
+
+    template <typename T>
+    inline detail::tvec3<T> tan
+	(
+		detail::tvec3<T> const & angle
+	)
+    {
+        return detail::tvec3<T>(
+            tan(angle.x),
+            tan(angle.y),
+            tan(angle.z));
+    }
+
+    template <typename T>
+    inline detail::tvec4<T> tan
+	(
+		detail::tvec4<T> const & angle
+	)
+    {
+        return detail::tvec4<T>(
+            tan(angle.x),
+            tan(angle.y),
+            tan(angle.z),
+            tan(angle.w));
+    }
+
+    // asin
+    template <typename genType>
+    inline genType asin
+	(
+		genType const & x
+	)
+    {
+		GLM_STATIC_ASSERT(detail::type<genType>::is_float);
+
+        return ::std::asin(x);
+    }
+
+    template <typename T>
+	inline detail::tvec2<T> asin
+	(
+		detail::tvec2<T> const & x
+	)
+    {
+        return detail::tvec2<T>(
+            asin(x.x),
+            asin(x.y));
+    }
+
+    template <typename T>
+	inline detail::tvec3<T> asin
+	(
+		detail::tvec3<T> const & x
+	)
+    {
+        return detail::tvec3<T>(
+            asin(x.x),
+            asin(x.y),
+            asin(x.z));
+    }
+
+    template <typename T>
+	inline detail::tvec4<T> asin
+	(
+		detail::tvec4<T> const & x
+	)
+    {
+        return detail::tvec4<T>(
+            asin(x.x),
+            asin(x.y),
+            asin(x.z),
+            asin(x.w));
+    }
+
+    // acos
+    template <typename genType>
+    inline genType acos
+	(
+		genType const & x
+	)
+    {
+		GLM_STATIC_ASSERT(detail::type<genType>::is_float);
+
+        return ::std::acos(x);
+    }
+
+    template <typename T>
+	inline detail::tvec2<T> acos
+	(
+		detail::tvec2<T> const & x
+	)
+    {
+        return detail::tvec2<T>(
+            acos(x.x),
+            acos(x.y));
+    }
+
+    template <typename T>
+	inline detail::tvec3<T> acos
+	(
+		detail::tvec3<T> const & x
+	)
+    {
+        return detail::tvec3<T>(
+            acos(x.x),
+            acos(x.y),
+            acos(x.z));
+    }
+
+    template <typename T>
+	inline detail::tvec4<T> acos
+	(
+		detail::tvec4<T> const & x
+	)
+    {
+        return detail::tvec4<T>(
+            acos(x.x),
+            acos(x.y),
+            acos(x.z),
+            acos(x.w));
+    }
+
+    // atan
+    template <typename genType>
+    inline genType atan
+	(
+		genType const & y, 
+		genType const & x
+	)
+    {
+		GLM_STATIC_ASSERT(detail::type<genType>::is_float);
+
+        return ::std::atan2(y, x);
+    }
+
+    template <typename T>
+    inline detail::tvec2<T> atan
+	(
+		detail::tvec2<T> const & y, 
+		detail::tvec2<T> const & x
+	)
+    {
+        return detail::tvec2<T>(
+            atan(y.x, x.x),
+            atan(y.y, x.y));
+    }
+
+    template <typename T>
+    inline detail::tvec3<T> atan
+	(
+		detail::tvec3<T> const & y, 
+		detail::tvec3<T> const & x
+	)
+    {
+        return detail::tvec3<T>(
+            atan(y.x, x.x),
+            atan(y.y, x.y),
+            atan(y.z, x.z));
+    }
+
+    template <typename T>
+    inline detail::tvec4<T> atan
+	(
+		detail::tvec4<T> const & y, 
+		detail::tvec4<T> const & x
+	)
+    {
+        return detail::tvec4<T>(
+            atan(y.x, x.x),
+            atan(y.y, x.y),
+            atan(y.z, x.z),
+            atan(y.w, x.w));
+    }
+
+    template <typename genType>
+    inline genType atan
+	(
+		genType const & x
+	)
+    {
+		GLM_STATIC_ASSERT(detail::type<genType>::is_float);
+
+        return ::std::atan(x);
+    }
+
+    template <typename T>
+    inline detail::tvec2<T> atan
+	(
+		detail::tvec2<T> const & x
+	)
+    {
+        return detail::tvec2<T>(
+            atan(x.x),
+            atan(x.y));
+    }
+
+    template <typename T>
+    inline detail::tvec3<T> atan
+	(
+		detail::tvec3<T> const & x
+	)
+    {
+        return detail::tvec3<T>(
+            atan(x.x),
+            atan(x.y),
+            atan(x.z));
+    }
+
+    template <typename T>
+    inline detail::tvec4<T> atan
+	(
+		detail::tvec4<T> const & x
+	)
+    {
+        return detail::tvec4<T>(
+            atan(x.x),
+            atan(x.y),
+            atan(x.z),
+            atan(x.w));
+    }
+
+    // sinh
+    template <typename genType> 
+    inline genType sinh
+	(
+		genType const & angle
+	)
+    {
+        GLM_STATIC_ASSERT(detail::type<genType>::is_float);
+
+		return std::sinh(angle);
+    }
+
+    template <typename T> 
+    inline detail::tvec2<T> sinh
+	(
+		detail::tvec2<T> const & angle
+	)
+    {
+        return detail::tvec2<T>(
+            sinh(angle.x),
+            sinh(angle.y));
+    }
+
+    template <typename T> 
+    inline detail::tvec3<T> sinh
+	(
+		detail::tvec3<T> const & angle
+	)
+    {
+        return detail::tvec3<T>(
+            sinh(angle.x),
+            sinh(angle.y),
+            sinh(angle.z));
+    }
+
+    template <typename T> 
+    inline detail::tvec4<T> sinh
+	(
+		detail::tvec4<T> const & angle
+	)
+    {
+        return detail::tvec4<T>(
+            sinh(angle.x),
+            sinh(angle.y),
+            sinh(angle.z),
+            sinh(angle.w));
+    }
+
+    // cosh
+    template <typename genType> 
+    inline genType cosh
+	(
+		genType const & angle
+	)
+    {
+        GLM_STATIC_ASSERT(detail::type<genType>::is_float);
+
+		return std::cosh(angle);
+    }
+
+    template <typename T> 
+    inline detail::tvec2<T> cosh
+	(
+		detail::tvec2<T> const & angle
+	)
+    {
+        return detail::tvec2<T>(
+            cosh(angle.x),
+            cosh(angle.y));
+    }
+
+    template <typename T> 
+    inline detail::tvec3<T> cosh
+	(
+		detail::tvec3<T> const & angle
+	)
+    {
+        return detail::tvec3<T>(
+            cosh(angle.x),
+            cosh(angle.y),
+            cosh(angle.z));
+    }
+
+    template <typename T> 
+    inline detail::tvec4<T> cosh
+	(
+		detail::tvec4<T> const & angle
+	)
+    {
+        return detail::tvec4<T>(
+            cosh(angle.x),
+            cosh(angle.y),
+            cosh(angle.z),
+            cosh(angle.w));
+    }
+
+    // tanh
+    template <typename genType>
+    inline genType tanh
+	(
+		genType const & angle
+	)
+    {
+        GLM_STATIC_ASSERT(detail::type<genType>::is_float);
+
+		return std::tanh(angle);
+    }
+
+    template <typename T> 
+    inline detail::tvec2<T> tanh
+	(
+		detail::tvec2<T> const & angle
+	)
+    {
+        return detail::tvec2<T>(
+            tanh(angle.x),
+            tanh(angle.y));
+    }
+
+    template <typename T> 
+    inline detail::tvec3<T> tanh
+	(
+		detail::tvec3<T> const & angle
+	)
+    {
+        return detail::tvec3<T>(
+            tanh(angle.x),
+            tanh(angle.y),
+            tanh(angle.z));
+    }
+
+    template <typename T> 
+    inline detail::tvec4<T> tanh
+	(
+		detail::tvec4<T> const & angle
+	)
+    {
+        return detail::tvec4<T>(
+            tanh(angle.x),
+            tanh(angle.y),
+            tanh(angle.z),
+            tanh(angle.w));
+    }
+
+    // asinh
+    template <typename genType> 
+    inline genType asinh
+	(
+		genType const & x
+	)
+    {
+		GLM_STATIC_ASSERT(detail::type<genType>::is_float);
+		
+		return (x < genType(0) ? genType(-1) : (x > genType(0) ? genType(1) : genType(0))) * log(abs(x) + sqrt(genType(1) + x * x));
+    }
+
+    template <typename T> 
+    inline detail::tvec2<T> asinh
+	(
+		detail::tvec2<T> const & x
+	)
+    {
+        return detail::tvec2<T>(
+            asinh(x.x),
+            asinh(x.y));
+    }
+
+    template <typename T> 
+    inline detail::tvec3<T> asinh
+	(
+		detail::tvec3<T> const & x
+	)
+    {
+        return detail::tvec3<T>(
+            asinh(x.x),
+            asinh(x.y),
+            asinh(x.z));
+    }
+
+    template <typename T> 
+    inline detail::tvec4<T> asinh
+	(
+		detail::tvec4<T> const & x
+	)
+    {
+        return detail::tvec4<T>(
+            asinh(x.x),
+            asinh(x.y),
+            asinh(x.z),
+            asinh(x.w));
+    }
+
+    // acosh
+    template <typename genType> 
+    inline genType acosh
+	(
+		genType const & x
+	)
+    {
+		GLM_STATIC_ASSERT(detail::type<genType>::is_float);
+
+		if(x < genType(1))
+			return genType(0);
+		return log(x + sqrt(x * x - genType(1)));
+    }
+
+	template <typename T> 
+	inline detail::tvec2<T> acosh
+	(
+		detail::tvec2<T> const & x
+	)
+	{
+		return detail::tvec2<T>(
+			acosh(x.x),
+			acosh(x.y));
+	}
+
+    template <typename T> 
+    inline detail::tvec3<T> acosh
+	(
+		detail::tvec3<T> const & x
+	)
+    {
+        return detail::tvec3<T>(
+            acosh(x.x),
+            acosh(x.y),
+            acosh(x.z));
+    }
+
+    template <typename T> 
+    inline detail::tvec4<T> acosh
+	(
+		detail::tvec4<T> const & x
+	)
+    {
+        return detail::tvec4<T>(
+            acosh(x.x),
+            acosh(x.y),
+            acosh(x.z),
+            acosh(x.w));
+    }
+
+    // atanh
+    template <typename genType>
+    inline genType atanh
+	(
+		genType const & x
+	)
+    {
+		GLM_STATIC_ASSERT(detail::type<genType>::is_float);
+		
+		if(abs(x) >= genType(1))
+			return 0;
+		return genType(0.5) * log((genType(1) + x) / (genType(1) - x));
+    }
+
+    template <typename T> 
+    inline detail::tvec2<T> atanh
+	(
+		detail::tvec2<T> const & x
+	)
+    {
+        return detail::tvec2<T>(
+            atanh(x.x),
+            atanh(x.y));
+    }
+
+    template <typename T> 
+    inline detail::tvec3<T> atanh
+	(
+		detail::tvec3<T> const & x
+	)
+    {
+        return detail::tvec3<T>(
+            atanh(x.x),
+            atanh(x.y),
+            atanh(x.z));
+    }
+
+    template <typename T> 
+    inline detail::tvec4<T> atanh
+	(
+		detail::tvec4<T> const & x
+	)
+    {
+        return detail::tvec4<T>(
+            atanh(x.x),
+            atanh(x.y),
+            atanh(x.z),
+            atanh(x.w));
+    }
+
+	}//namespace trigonometric
+	}//namespace function
+	}//namespace core
+}//namespace glm

glm/core/func_vector_relational.hpp

@@ -0,0 +1,189 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2010 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2008-08-03
+// Updated : 2008-09-09
+// Licence : This source is under MIT License
+// File    : glm/core/func_vector_relational.hpp
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#ifndef glm_core_func_vector_relational
+#define glm_core_func_vector_relational
+
+namespace glm
+{
+	namespace test{
+		void main_core_func_vector_relational();
+	}//namespace test
+
+	namespace core{
+	namespace function{
+	//! Define vector relational functions from Section 8.3 of GLSL 1.30.8 specification. 
+	//! Included in glm namespace.
+	namespace vector_relational
+	{
+		//! Returns the component-wise comparison result of x < y.
+		//! (From GLSL 1.30.08 specification, section 8.6)
+		template <typename T, template <typename> class vecType> 
+		inline typename vecType<T>::bool_type lessThan
+		(
+			vecType<T> const & x, 
+			vecType<T> const & y
+		)
+		{
+			GLM_STATIC_ASSERT(
+				detail::type<T>::is_float || 
+				detail::type<T>::is_int || 
+				detail::type<T>::is_uint);
+
+			typename vecType<bool>::bool_type Result(vecType<bool>::null);
+			for(typename vecType<bool>::size_type i = 0; i < vecType<bool>::value_size(); ++i)
+				Result[i] = x[i] < y[i];
+			return Result;
+		}
+
+		//! Returns the component-wise comparison of result x <= y.
+		//! (From GLSL 1.30.08 specification, section 8.6)
+		template <typename T, template <typename> class vecType> 
+		inline typename vecType<T>::bool_type lessThanEqual
+		(
+			vecType<T> const & x, 
+			vecType<T> const & y
+		)
+		{
+			GLM_STATIC_ASSERT(
+				detail::type<T>::is_float || 
+				detail::type<T>::is_int || 
+				detail::type<T>::is_uint);
+
+			typename vecType<bool>::bool_type Result(vecType<bool>::null);
+			for(typename vecType<bool>::size_type i = 0; i < vecType<bool>::value_size(); ++i)
+				Result[i] = x[i] <= y[i];
+			return Result;
+		}
+
+		//! Returns the component-wise comparison of result x > y.
+		//! (From GLSL 1.30.08 specification, section 8.6)
+		template <typename T, template <typename> class vecType> 
+		inline typename vecType<T>::bool_type greaterThan
+		(
+			vecType<T> const & x, 
+			vecType<T> const & y
+		)
+		{
+			GLM_STATIC_ASSERT(
+				detail::type<T>::is_float || 
+				detail::type<T>::is_int || 
+				detail::type<T>::is_uint);
+
+			typename vecType<bool>::bool_type Result(vecType<bool>::null);
+			for(typename vecType<bool>::size_type i = 0; i < vecType<bool>::value_size(); ++i)
+				Result[i] = x[i] > y[i];
+			return Result;
+		}
+
+		//! Returns the component-wise comparison of result x >= y.
+		//! (From GLSL 1.30.08 specification, section 8.6)
+		template <typename T, template <typename> class vecType> 
+		inline typename vecType<T>::bool_type greaterThanEqual
+		(
+			vecType<T> const & x, 
+			vecType<T> const & y
+		)
+		{
+			GLM_STATIC_ASSERT(
+				detail::type<T>::is_float || 
+				detail::type<T>::is_int || 
+				detail::type<T>::is_uint);
+
+			typename vecType<bool>::bool_type Result(vecType<bool>::null);
+			for(typename vecType<bool>::size_type i = 0; i < vecType<bool>::value_size(); ++i)
+				Result[i] = x[i] >= y[i];
+			return Result;
+		}
+
+		//! Returns the component-wise comparison of result x == y.
+		//! (From GLSL 1.30.08 specification, section 8.6)
+		template <typename T, template <typename> class vecType> 
+		inline typename vecType<T>::bool_type equal
+		(
+			vecType<T> const & x, 
+			vecType<T> const & y
+		)
+		{
+			GLM_STATIC_ASSERT(
+				detail::type<T>::is_float || 
+				detail::type<T>::is_int || 
+				detail::type<T>::is_uint || 
+				detail::type<T>::is_bool);
+
+			typename vecType<bool>::bool_type Result(vecType<bool>::null);
+			for(typename vecType<bool>::size_type i = 0; i < vecType<bool>::value_size(); ++i)
+				Result[i] = x[i] == y[i];
+			return Result;
+		}
+
+		//! Returns the component-wise comparison of result x != y.
+		//! (From GLSL 1.30.08 specification, section 8.6)
+		template <typename T, template <typename> class vecType> 
+		inline typename vecType<T>::bool_type notEqual
+		(
+			vecType<T> const & x, 
+			vecType<T> const & y
+		)
+		{
+			GLM_STATIC_ASSERT(
+				detail::type<T>::is_float || 
+				detail::type<T>::is_int || 
+				detail::type<T>::is_uint || 
+				detail::type<T>::is_bool);
+
+			typename vecType<bool>::bool_type Result(vecType<bool>::null);
+			for(typename vecType<bool>::size_type i = 0; i < vecType<bool>::value_size(); ++i)
+				Result[i] = x[i] != y[i];
+			return Result;
+		}
+
+		//! Returns true if any component of x is true.
+		//! (From GLSL 1.30.08 specification, section 8.6)
+		template <template <typename> class vecType> 
+		inline bool any(vecType<bool> const & v)
+		{
+			bool Result = false;
+			for(typename vecType<bool>::size_type i = 0; i < vecType<bool>::value_size(); ++i)
+				Result = Result || v[i];
+			return Result;
+		}
+
+		//! Returns true if all components of x are true.
+		//! (From GLSL 1.30.08 specification, section 8.6)
+		template <template <typename> class vecType> 
+		inline bool all(vecType<bool> const & v)
+		{
+			bool Result = true;
+			for(typename vecType<bool>::size_type i = 0; i < vecType<bool>::value_size(); ++i)
+				Result = Result && v[i];
+			return Result;
+		}
+
+		//! Returns the component-wise logical complement of x.
+		//! (From GLSL 1.30.08 specification, section 8.6)
+		template <template <typename> class vecType> 
+		inline vecType<bool> not_(vecType<bool> const & v)
+		{
+			typename vecType<bool>::bool_type Result(vecType<bool>::null);
+			for(typename vecType<bool>::size_type i = 0; i < vecType<bool>::value_size(); ++i)
+				Result[i] = !v[i];
+			return Result;
+		}
+
+	}//namespace vector_relational
+	}//namespace function
+	}//namespace core
+
+	using namespace core::function::vector_relational;
+}//namespace glm
+
+#include "func_vector_relational.inl"
+
+#endif//glm_core_func_vector_relational

glm/core/func_vector_relational.inl

@@ -0,0 +1,20 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2010 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2008-08-03
+// Updated : 2008-09-14
+// Licence : This source is under MIT License
+// File    : glm/core/func_vector_relational.inl
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+namespace glm
+{
+	namespace core{
+	namespace function{
+	namespace vector_relational{
+
+	}//namespace vector_relational
+	}//namespace function
+	}//namespace core
+}//namespace glm
+

glm/core/hint.hpp

@@ -0,0 +1,21 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2010 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2008-08-14
+// Updated : 2008-08-14
+// Licence : This source is under MIT License
+// File    : glm/core/hint.hpp
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#ifndef glm_core_type
+#define glm_core_type
+
+namespace glm
+{
+	// Use dont_care, nicest and fastest to optimize implementations.
+	class dont_care {};
+	class nicest {};
+	class fastest {};
+};
+
+#endif//glm_core_type

glm/core/intrinsic_common.hpp

@@ -0,0 +1,60 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2010 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2009-05-11
+// Updated : 2009-05-11
+// Licence : This source is under MIT License
+// File    : glm/core/intrinsic_common.hpp
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#ifndef GLM_DETAIL_INTRINSIC_COMMON_INCLUDED
+#define GLM_DETAIL_INTRINSIC_COMMON_INCLUDED
+
+//#include <mmintrin.h>
+//#include <emmintrin.h>
+#include <xmmintrin.h>
+#include <emmintrin.h>
+
+__m128 _mm_abs_ps(__m128 x);
+
+__m128 _mm_sgn_ps(__m128 x);
+
+//floor
+__m128 _mm_flr_ps(__m128 v);
+
+//trunc
+__m128 _mm_trc_ps(__m128 v);
+
+//round
+__m128 _mm_rnd_ps(__m128 v);
+
+//roundEven
+__m128 _mm_rde_ps(__m128 v);
+
+__m128 _mm_ceil_ps(__m128 v);
+
+__m128 _mm_frc_ps(__m128 x);
+
+__m128 _mm_mod_ps(__m128 x, __m128 y);
+
+__m128 _mm_modf_ps(__m128 x, __m128i & i);
+
+//inline __m128 _mm_min_ps(__m128 x, __m128 y)
+
+//inline __m128 _mm_max_ps(__m128 x, __m128 y)
+
+__m128 _mm_clp_ps(__m128 v, __m128 minVal, __m128 maxVal);
+
+__m128 _mm_mix_ps(__m128 v1, __m128 v2, __m128 a);
+
+__m128 _mm_stp_ps(__m128 edge, __m128 x);
+
+__m128 _mm_ssp_ps(__m128 edge0, __m128 edge1, __m128 x);
+
+__m128 _mm_nan_ps(__m128 x);
+
+__m128 _mm_inf_ps(__m128 x);
+
+#include "intrinsic_common.inl"
+
+#endif//GLM_DETAIL_INTRINSIC_COMMON_INCLUDED

glm/core/intrinsic_common.inl

@@ -0,0 +1,280 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2010 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2009-05-08
+// Updated : 2009-05-08
+// Licence : This source is under MIT License
+// File    : glm/core/intrinsic_common.inl
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+namespace glm{
+namespace detail{
+
+	union ieee754_QNAN
+	{
+	   const float f;
+	   struct
+	   {
+		  const unsigned int mantissa:23, exp:8, sign:1;
+	   };
+	   
+	   ieee754_QNAN() : f(0.0), mantissa(0x7FFFFF), exp(0xFF), sign(0x0) {}
+	};
+
+	static const __m128 zero = _mm_setzero_ps();
+	static const __m128 one = _mm_set_ps1(1.0f);
+	static const __m128 minus_one = _mm_set_ps1(-1.0f);
+	static const __m128 two = _mm_set_ps1(2.0f);
+	static const __m128 three = _mm_set_ps1(3.0f);
+	static const __m128 pi = _mm_set_ps1(3.1415926535897932384626433832795f);
+	static const __m128 hundred_eighty = _mm_set_ps1(180.f);
+	static const __m128 pi_over_hundred_eighty = _mm_set_ps1(0.017453292519943295769236907684886f);
+	static const __m128 hundred_eighty_over_pi = _mm_set_ps1(57.295779513082320876798154814105f);
+
+	static const ieee754_QNAN absMask;
+	static const __m128 abs4Mask = _mm_set_ps1(absMask.f);
+
+        //static const __m128 _epi32_sign_mask = _mm_castsi128_ps(_mm_set1_epi32(0x80000000));
+        //static const __m128 _epi32_inv_sign_mask = _mm_castsi128_ps(_mm_set1_epi32(0x7FFFFFFF));
+        //static const __m128 _epi32_mant_mask = _mm_castsi128_ps(_mm_set1_epi32(0x7F800000));
+        //static const __m128 _epi32_inv_mant_mask = _mm_castsi128_ps(_mm_set1_epi32(0x807FFFFF));
+        //static const __m128 _epi32_min_norm_pos = _mm_castsi128_ps(_mm_set1_epi32(0x00800000));
+	static const __m128 _epi32_0 = _mm_set_ps1(0);
+	static const __m128 _epi32_1 = _mm_set_ps1(1);
+	static const __m128 _epi32_2 = _mm_set_ps1(2);
+	static const __m128 _epi32_3 = _mm_set_ps1(3);
+	static const __m128 _epi32_4 = _mm_set_ps1(4);
+	static const __m128 _epi32_5 = _mm_set_ps1(5);
+	static const __m128 _epi32_6 = _mm_set_ps1(6);
+	static const __m128 _epi32_7 = _mm_set_ps1(7);
+	static const __m128 _epi32_8 = _mm_set_ps1(8);
+	static const __m128 _epi32_9 = _mm_set_ps1(9);
+	static const __m128 _epi32_127 = _mm_set_ps1(127);
+        //static const __m128 _epi32_ninf = _mm_castsi128_ps(_mm_set1_epi32(0xFF800000));
+        //static const __m128 _epi32_pinf = _mm_castsi128_ps(_mm_set1_epi32(0x7F800000));
+
+	static const __m128 _ps_1_3 = _mm_set_ps1(0.33333333333333333333333333333333f);
+	static const __m128 _ps_0p5 = _mm_set_ps1(0.5f);
+	static const __m128 _ps_1 = _mm_set_ps1(1.0f);
+	static const __m128 _ps_m1 = _mm_set_ps1(-1.0f);
+	static const __m128 _ps_2 = _mm_set_ps1(2.0f);
+	static const __m128 _ps_3 = _mm_set_ps1(3.0f);
+	static const __m128 _ps_127 = _mm_set_ps1(127.0f);
+	static const __m128 _ps_255 = _mm_set_ps1(255.0f);
+	static const __m128 _ps_2pow23 = _mm_set_ps1(8388608.0f);
+
+	static const __m128 _ps_1_0_0_0 = _mm_set_ps(1.0f, 0.0f, 0.0f, 0.0f);
+	static const __m128 _ps_0_1_0_0 = _mm_set_ps(0.0f, 1.0f, 0.0f, 0.0f);
+	static const __m128 _ps_0_0_1_0 = _mm_set_ps(0.0f, 0.0f, 1.0f, 0.0f);
+	static const __m128 _ps_0_0_0_1 = _mm_set_ps(0.0f, 0.0f, 0.0f, 1.0f);
+
+	static const __m128 _ps_pi = _mm_set_ps1(3.1415926535897932384626433832795f);
+	static const __m128 _ps_pi2 = _mm_set_ps1(6.283185307179586476925286766560f);
+	static const __m128 _ps_2_pi = _mm_set_ps1(0.63661977236758134307553505349006f);
+	static const __m128 _ps_pi_2 = _mm_set_ps1(1.5707963267948966192313216916398f);
+	static const __m128 _ps_4_pi = _mm_set_ps1(1.2732395447351626861510701069801f);
+	static const __m128 _ps_pi_4 = _mm_set_ps1(0.78539816339744830961566084581988f);
+
+	static const __m128 _ps_sincos_p0 = _mm_set_ps1(0.15707963267948963959e1f);
+	static const __m128 _ps_sincos_p1 = _mm_set_ps1(-0.64596409750621907082e0f);
+	static const __m128 _ps_sincos_p2 = _mm_set_ps1(0.7969262624561800806e-1f);
+	static const __m128 _ps_sincos_p3 = _mm_set_ps1(-0.468175413106023168e-2f);
+	static const __m128 _ps_tan_p0 = _mm_set_ps1(-1.79565251976484877988e7f);
+	static const __m128 _ps_tan_p1 = _mm_set_ps1(1.15351664838587416140e6f);
+	static const __m128 _ps_tan_p2 = _mm_set_ps1(-1.30936939181383777646e4f);
+	static const __m128 _ps_tan_q0 = _mm_set_ps1(-5.38695755929454629881e7f);
+	static const __m128 _ps_tan_q1 = _mm_set_ps1(2.50083801823357915839e7f);
+	static const __m128 _ps_tan_q2 = _mm_set_ps1(-1.32089234440210967447e6f);
+	static const __m128 _ps_tan_q3 = _mm_set_ps1(1.36812963470692954678e4f);
+	static const __m128 _ps_tan_poleval = _mm_set_ps1(3.68935e19f);
+	static const __m128 _ps_atan_t0 = _mm_set_ps1(-0.91646118527267623468e-1f);
+	static const __m128 _ps_atan_t1 = _mm_set_ps1(-0.13956945682312098640e1f);
+	static const __m128 _ps_atan_t2 = _mm_set_ps1(-0.94393926122725531747e2f);
+	static const __m128 _ps_atan_t3 = _mm_set_ps1(0.12888383034157279340e2f);
+	static const __m128 _ps_atan_s0 = _mm_set_ps1(0.12797564625607904396e1f);
+	static const __m128 _ps_atan_s1 = _mm_set_ps1(0.21972168858277355914e1f);
+	static const __m128 _ps_atan_s2 = _mm_set_ps1(0.68193064729268275701e1f);
+	static const __m128 _ps_atan_s3 = _mm_set_ps1(0.28205206687035841409e2f);
+
+	static const __m128 _ps_exp_hi = _mm_set_ps1(88.3762626647949f);
+	static const __m128 _ps_exp_lo = _mm_set_ps1(-88.3762626647949f);
+	static const __m128 _ps_exp_rln2 = _mm_set_ps1(1.4426950408889634073599f);
+	static const __m128 _ps_exp_p0 = _mm_set_ps1(1.26177193074810590878e-4f);
+	static const __m128 _ps_exp_p1 = _mm_set_ps1(3.02994407707441961300e-2f);
+	static const __m128 _ps_exp_q0 = _mm_set_ps1(3.00198505138664455042e-6f);
+	static const __m128 _ps_exp_q1 = _mm_set_ps1(2.52448340349684104192e-3f);
+	static const __m128 _ps_exp_q2 = _mm_set_ps1(2.27265548208155028766e-1f);
+	static const __m128 _ps_exp_q3 = _mm_set_ps1(2.00000000000000000009e0f);
+	static const __m128 _ps_exp_c1 = _mm_set_ps1(6.93145751953125e-1f);
+	static const __m128 _ps_exp_c2 = _mm_set_ps1(1.42860682030941723212e-6f);
+	static const __m128 _ps_exp2_hi = _mm_set_ps1(127.4999961853f);
+	static const __m128 _ps_exp2_lo = _mm_set_ps1(-127.4999961853f);
+	static const __m128 _ps_exp2_p0 = _mm_set_ps1(2.30933477057345225087e-2f);
+	static const __m128 _ps_exp2_p1 = _mm_set_ps1(2.02020656693165307700e1f);
+	static const __m128 _ps_exp2_p2 = _mm_set_ps1(1.51390680115615096133e3f);
+	static const __m128 _ps_exp2_q0 = _mm_set_ps1(2.33184211722314911771e2f);
+	static const __m128 _ps_exp2_q1 = _mm_set_ps1(4.36821166879210612817e3f);
+	static const __m128 _ps_log_p0 = _mm_set_ps1(-7.89580278884799154124e-1f);
+	static const __m128 _ps_log_p1 = _mm_set_ps1(1.63866645699558079767e1f);
+	static const __m128 _ps_log_p2 = _mm_set_ps1(-6.41409952958715622951e1f);
+	static const __m128 _ps_log_q0 = _mm_set_ps1(-3.56722798256324312549e1f);
+	static const __m128 _ps_log_q1 = _mm_set_ps1(3.12093766372244180303e2f);
+	static const __m128 _ps_log_q2 = _mm_set_ps1(-7.69691943550460008604e2f);
+	static const __m128 _ps_log_c0 = _mm_set_ps1(0.693147180559945f);
+	static const __m128 _ps_log2_c0 = _mm_set_ps1(1.44269504088896340735992f);
+
+}//namespace detail
+}//namespace glm
+
+inline __m128 _mm_abs_ps(__m128 x)
+{
+	return _mm_and_ps(glm::detail::abs4Mask, x);
+} 
+
+inline __m128 _mm_sgn_ps(__m128 x)
+{
+	//__m128 cmp0 = _mm_cmpeq_ps(x, zero);
+	//__m128 cmp1 = _mm_cmple_ps(x, zero);
+	//__m128 cmp2 = _mm_cmpge_ps(x, zero);
+
+	__m128 result;
+	__m128 cmp0 = _mm_cmpeq_ps(x, glm::detail::zero);
+	if(_mm_movemask_ps(cmp0) == 0)
+		result = glm::detail::zero;
+	else
+	{
+		__m128 cmp1 = _mm_cmpge_ps(x, glm::detail::zero);
+		//__m128 cmp2 = _mm_cmple_ps(x, glm::detail::zero);
+		if(_mm_movemask_ps(cmp1) > 0)
+			result = glm::detail::one;
+		else //if(_mm_movemask_ps(cmp2) > 0)
+			result = glm::detail::minus_one;
+	}
+	return result;
+}
+
+//floor
+inline __m128 _mm_flr_ps(__m128 x)
+{
+	__m128 rnd0 = _mm_rnd_ps(x);
+	__m128 cmp0 = _mm_cmplt_ps(x, rnd0);
+	__m128 and0 = _mm_and_ps(cmp0, glm::detail::_ps_1);
+	__m128 sub0 = _mm_sub_ps(rnd0, and0);
+	return sub0;
+}
+
+//trunc
+inline __m128 _mm_trc_ps(__m128 v)
+{
+	return __m128();
+}
+
+//round
+inline __m128 _mm_rnd_ps(__m128 x)
+{
+	__m128 and0;// = _mm_and_ps(glm::detail::_epi32_sign_mask, x);
+	__m128 or0 = _mm_or_ps(and0, glm::detail::_ps_2pow23);
+	__m128 add0 = _mm_add_ps(x, or0);
+	__m128 sub0 = _mm_sub_ps(add0, or0);
+	return sub0;
+}
+
+//roundEven
+inline __m128 _mm_rde_ps(__m128 v)
+{
+
+}
+
+inline __m128 _mm_ceil_ps(__m128 x)
+{
+	__m128 rnd0 = _mm_rnd_ps(x);
+	__m128 cmp0 = _mm_cmpgt_ps(x, rnd0);
+	__m128 and0 = _mm_and_ps(cmp0, glm::detail::_ps_1);
+	__m128 add0 = _mm_add_ps(rnd0, and0);
+	return add0;
+}
+
+inline __m128 _mm_frc_ps(__m128 x)
+{
+	__m128 flr0 = _mm_flr_ps(x);
+	__m128 sub0 = _mm_sub_ps(x, flr0);
+	return sub0;
+}
+
+inline __m128 _mm_mod_ps(__m128 x, __m128 y)
+{
+	__m128 div0 = _mm_div_ps(x, y);
+	__m128 flr0 = _mm_flr_ps(div0);
+	__m128 mul0 = _mm_mul_ps(y, flr0);
+	__m128 sub0 = _mm_sub_ps(x, mul0);
+	return sub0;
+}
+
+inline __m128 _mm_modf_ps(__m128 x, __m128i & i)
+{
+
+}
+
+//inline __m128 _mm_min_ps(__m128 x, __m128 y)
+
+//inline __m128 _mm_max_ps(__m128 x, __m128 y)
+
+inline __m128 _mm_clp_ps(__m128 v, __m128 minVal, __m128 maxVal)
+{
+	__m128 min0 = _mm_min_ps(v, maxVal);
+	__m128 max0 = _mm_max_ps(min0, minVal);
+	return max0;
+}
+
+inline __m128 _mm_mix_ps(__m128 v1, __m128 v2, __m128 a)
+{
+	__m128 sub0 = _mm_sub_ps(glm::detail::one, a);
+	__m128 mul0 = _mm_mul_ps(v1, sub0);
+	__m128 mul1 = _mm_mul_ps(v2, a);
+	__m128 add0 = _mm_add_ps(mul0, mul1);
+	return add0;
+}
+
+inline __m128 _mm_stp_ps(__m128 edge, __m128 x)
+{
+	__m128 cmp = _mm_cmple_ps(x, edge);
+	if(_mm_movemask_ps(cmp) == 0)
+		return glm::detail::one;
+	else
+		return glm::detail::zero;
+}
+
+inline __m128 _mm_ssp_ps(__m128 edge0, __m128 edge1, __m128 x)
+{
+	__m128 sub0 = _mm_sub_ps(x, edge0);
+	__m128 sub1 = _mm_sub_ps(edge1, edge0);
+	__m128 div0 = _mm_sub_ps(sub0, sub1);
+	__m128 clp0 = _mm_clp_ps(div0, glm::detail::zero, glm::detail::one);
+	__m128 mul0 = _mm_mul_ps(glm::detail::two, clp0);
+	__m128 sub2 = _mm_sub_ps(glm::detail::three, mul0);
+	__m128 mul1 = _mm_mul_ps(clp0, clp0);
+	__m128 mul2 = _mm_mul_ps(mul1, sub2);
+	return mul2;
+}
+
+inline __m128 _mm_nan_ps(__m128 x)
+{
+
+}
+
+inline __m128 _mm_inf_ps(__m128 x)
+{
+
+}
+
+// SSE scalar reciprocal sqrt using rsqrt op, plus one Newton-Rhaphson iteration
+// By Elan Ruskin, 
+inline __m128 _mm_sqrt_wip_ss(__m128 const x)
+{
+	__m128 recip = _mm_rsqrt_ss( x );  // "estimate" opcode
+	const static __m128 three = { 3, 3, 3, 3 }; // aligned consts for fast load
+	const static __m128 half = { 0.5,0.5,0.5,0.5 };
+	__m128 halfrecip = _mm_mul_ss( half, recip );
+	__m128 threeminus_xrr = _mm_sub_ss( three, _mm_mul_ss( x, _mm_mul_ss ( recip, recip ) ) );
+	return _mm_mul_ss( halfrecip, threeminus_xrr );
+}

glm/core/intrinsic_exponential.hpp

@@ -0,0 +1,34 @@
+/*
+inline __m128 _mm_rsqrt_nr_ss(__m128 const x)
+{
+	__m128 recip = _mm_rsqrt_ss( x );  // "estimate" opcode
+	const static __m128 three = { 3, 3, 3, 3 }; // aligned consts for fast load
+	const static __m128 half = { 0.5,0.5,0.5,0.5 };
+	__m128 halfrecip = _mm_mul_ss( half, recip );
+	__m128 threeminus_xrr = _mm_sub_ss( three, _mm_mul_ss( x, _mm_mul_ss ( recip, recip ) ) );
+	return _mm_mul_ss( halfrecip, threeminus_xrr );
+}
+ 
+inline __m128 __mm_normalize_fast_ps(  float * RESTRICT vOut, float * RESTRICT vIn )
+{
+        __m128 x = _mm_load_ss(&vIn[0]);
+        __m128 y = _mm_load_ss(&vIn[1]);
+        __m128 z = _mm_load_ss(&vIn[2]);
+ 
+        const __m128 l =  // compute x*x + y*y + z*z
+                _mm_add_ss(
+                 _mm_add_ss( _mm_mul_ss(x,x),
+                             _mm_mul_ss(y,y)
+                            ),
+                 _mm_mul_ss( z, z )
+                );
+ 
+ 
+        const __m128 rsqt = _mm_rsqrt_nr_ss( l );
+        _mm_store_ss( &vOut[0] , _mm_mul_ss( rsqt, x ) );
+        _mm_store_ss( &vOut[1] , _mm_mul_ss( rsqt, y ) );
+        _mm_store_ss( &vOut[2] , _mm_mul_ss( rsqt, z ) );
+ 
+        return _mm_mul_ss( l , rsqt );
+}
+*/

glm/core/intrinsic_geometric.hpp

@@ -0,0 +1,45 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2010 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2009-05-08
+// Updated : 2009-05-08
+// Licence : This source is under MIT License
+// File    : glm/core/intrinsic_geometric.hpp
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#ifndef glm_core_intrinsic_geometric
+#define glm_core_intrinsic_geometric
+
+#include "intrinsic_common.hpp"
+
+//length
+__m128 _mm_len_ps(__m128 x);
+
+//distance
+__m128 _mm_dst_ps(__m128 p0, __m128 p1);
+
+//dot
+__m128 _mm_dot_ps(__m128 v1, __m128 v2);
+
+// SSE1
+__m128 _mm_dot_ss(__m128 v1, __m128 v2);
+
+//cross
+__m128 _mm_xpd_ps(__m128 v1, __m128 v2);
+
+//normalize
+__m128 _mm_nrm_ps(__m128 v);
+
+//faceforward
+__m128 _mm_ffd_ps(__m128 N, __m128 I, __m128 Nref);
+
+//reflect
+__m128 _mm_rfe_ps(__m128 I, __m128 N);
+
+//refract
+__m128 _mm_rfa_ps(__m128 I, __m128 N, __m128 eta);
+
+
+#include "intrinsic_geometric.inl"
+
+#endif//glm_core_intrinsic_geometric

glm/core/intrinsic_geometric.inl

@@ -0,0 +1,117 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2010 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2009-05-08
+// Updated : 2009-05-08
+// Licence : This source is under MIT License
+// File    : glm/core/intrinsic_geometric.inl
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+//length
+inline __m128 _mm_len_ps(__m128 x)
+{
+    __m128 dot0 = _mm_dot_ps(x, x);
+	__m128 sqt0 = _mm_sqrt_ps(dot0);
+    return sqt0;
+}
+
+//distance
+inline __m128 _mm_dst_ps(__m128 p0, __m128 p1)
+{
+	__m128 sub0 = _mm_sub_ps(p0, p1);
+    __m128 len0 = _mm_len_ps(sub0);
+    return len0;
+}
+
+//dot
+inline __m128 _mm_dot_ps(__m128 v1, __m128 v2)
+{
+	__m128 mul0 = _mm_mul_ps(v1, v2);
+	__m128 swp0 = _mm_shuffle_ps(mul0, mul0, _MM_SHUFFLE(2, 3, 0, 1));
+	__m128 add0 = _mm_add_ps(mul0, swp0);
+	__m128 swp1 = _mm_shuffle_ps(add0, add0, _MM_SHUFFLE(0, 1, 2, 3));
+	__m128 add1 = _mm_add_ps(add0, swp1);
+	return add1;
+}
+
+// SSE1
+inline __m128 _mm_dot_ss(__m128 v1, __m128 v2)
+{
+	__m128 mul0 = _mm_mul_ps(v1, v2);
+	__m128 mov0 = _mm_movehl_ps(mul0, mul0);
+	__m128 add0 = _mm_add_ps(mov0, mul0);
+	__m128 swp1 = _mm_shuffle_ps(add0, add0, 1);
+	__m128 add1 = _mm_add_ss(add0, swp1);
+	return add1;
+}
+
+//cross
+inline __m128 _mm_xpd_ps(__m128 v1, __m128 v2)
+{
+	__m128 swp0 = _mm_shuffle_ps(v1, v1, _MM_SHUFFLE(3, 0, 2, 1));
+	__m128 swp1 = _mm_shuffle_ps(v1, v1, _MM_SHUFFLE(3, 1, 0, 2));
+	__m128 swp2 = _mm_shuffle_ps(v2, v2, _MM_SHUFFLE(3, 0, 2, 1));
+	__m128 swp3 = _mm_shuffle_ps(v2, v2, _MM_SHUFFLE(3, 1, 0, 2));
+	__m128 mul0 = _mm_mul_ps(swp0, swp3);
+	__m128 mul1 = _mm_mul_ps(swp1, swp2);
+	__m128 sub0 = _mm_sub_ps(mul0, mul1);
+	return sub0;
+}
+
+//normalize
+inline __m128 _mm_nrm_ps(__m128 v)
+{
+	__m128 dot0 = _mm_dot_ps(v, v);
+	__m128 isr0 = _mm_rsqrt_ps(dot0);
+	__m128 mul0 = _mm_mul_ps(v, isr0);
+	return mul0;
+}
+
+//faceforward
+inline __m128 _mm_ffd_ps(__m128 N, __m128 I, __m128 Nref)
+{
+	//__m128 dot0 = _mm_dot_ps(v, v);
+	//__m128 neg0 = _mm_neg_ps(N);
+	//__m128 sgn0 = _mm_sgn_ps(dot0);
+	//__m128 mix0 = _mm_mix_ps(N, neg0, sgn0);
+	//return mix0;
+
+	__m128 dot0 = _mm_dot_ps(Nref, I);
+	__m128 sgn0 = _mm_sgn_ps(dot0);
+	__m128 mul0 = _mm_mul_ps(sgn0, glm::detail::minus_one);
+	__m128 mul1 = _mm_mul_ps(N, mul0);
+	return mul1;
+}
+
+//reflect
+inline __m128 _mm_rfe_ps(__m128 I, __m128 N)
+{
+	__m128 dot0 = _mm_dot_ps(N, I);
+	__m128 mul0 = _mm_mul_ps(N, I);
+	__m128 mul1 = _mm_mul_ps(mul0, glm::detail::two);
+	__m128 sub0 = _mm_sub_ps(I, mul1);
+	return sub0;
+}
+
+//refract
+inline __m128 _mm_rfa_ps(__m128 I, __m128 N, __m128 eta)
+{
+	__m128 dot0 = _mm_dot_ps(N, I);
+	__m128 mul0 = _mm_mul_ps(eta, eta);
+	__m128 mul1 = _mm_mul_ps(dot0, dot0);
+	__m128 sub0 = _mm_sub_ps(glm::detail::one, mul0);
+	__m128 sub1 = _mm_sub_ps(glm::detail::one, mul1);
+	__m128 mul2 = _mm_mul_ps(sub0, sub1);
+	
+	if(_mm_movemask_ps(_mm_cmplt_ss(mul2, glm::detail::zero)) == 0)
+		return glm::detail::zero;
+
+	__m128 sqt0 = _mm_sqrt_ps(mul2);
+	__m128 mul3 = _mm_mul_ps(eta, dot0);
+	__m128 add0 = _mm_add_ps(mul3, sqt0);
+	__m128 mul4 = _mm_mul_ps(add0, N);
+	__m128 mul5 = _mm_mul_ps(eta, I);
+	__m128 sub2 = _mm_sub_ps(mul5, mul4);
+
+	return sub2;
+}

glm/core/intrinsic_matrix.hpp

@@ -0,0 +1,36 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2010 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2009-06-05
+// Updated : 2009-06-05
+// Licence : This source is under MIT License
+// File    : glm/core/intrinsic_common.hpp
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#ifndef GLM_DETAIL_INTRINSIC_MATRIX_INCLUDED
+#define GLM_DETAIL_INTRINSIC_MATRIX_INCLUDED
+
+#include "../glm.hpp"
+
+#include <xmmintrin.h>
+#include <emmintrin.h>
+
+void _mm_add_ps(__m128 in1[4], __m128 in2[4], __m128 out[4]);
+
+void _mm_sub_ps(__m128 in1[4], __m128 in2[4], __m128 out[4]);
+
+__m128 _mm_mul_ps(__m128 m[4], __m128 v);
+
+__m128 _mm_mul_ps(__m128 v, __m128 m[4]);
+
+void _mm_mul_ps(__m128 const in1[4], __m128 const in2[4], __m128 out[4]);
+
+void _mm_transpose_ps(__m128 const in[4], __m128 out[4]);
+
+void _mm_inverse_ps(__m128 const in[4], __m128 out[4]);
+
+void _mm_rotate_ps(__m128 const in[4], float Angle, float const v[3], __m128 out[4]);
+
+#include "intrinsic_matrix.inl"
+
+#endif//GLM_DETAIL_INTRINSIC_MATRIX_INCLUDED

glm/core/intrinsic_matrix.inl

@@ -0,0 +1,704 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2010 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2009-06-05
+// Updated : 2009-06-05
+// Licence : This source is under MIT License
+// File    : glm/core/intrinsic_common.inl
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+static const __m128 one = _mm_set_ps1(1.0f);
+static const __m128 pi = _mm_set_ps1(3.141592653589793238462643383279f);
+static const __m128 _m128_rad_ps = _mm_set_ps1(3.141592653589793238462643383279f / 180.f);
+static const __m128 _m128_deg_ps = _mm_set_ps1(180.f / 3.141592653589793238462643383279f);
+
+inline void _mm_add_ps(__m128 in1[4], __m128 in2[4], __m128 out[4])
+{
+	{
+		out[0] = _mm_add_ps(in1[0], in2[0]);
+		out[1] = _mm_add_ps(in1[1], in2[1]);
+		out[2] = _mm_add_ps(in1[2], in2[2]);
+		out[3] = _mm_add_ps(in1[3], in2[3]);
+	}
+}
+
+inline void _mm_sub_ps(__m128 in1[4], __m128 in2[4], __m128 out[4])
+{
+	{
+		out[0] = _mm_sub_ps(in1[0], in2[0]);
+		out[1] = _mm_sub_ps(in1[1], in2[1]);
+		out[2] = _mm_sub_ps(in1[2], in2[2]);
+		out[3] = _mm_sub_ps(in1[3], in2[3]);
+	}
+}
+
+inline __m128 _mm_mul_ps(__m128 m[4], __m128 v)
+{
+	__m128 v0 = _mm_shuffle_ps(v, v, _MM_SHUFFLE(0, 0, 0, 0));
+	__m128 v1 = _mm_shuffle_ps(v, v, _MM_SHUFFLE(1, 1, 1, 1));
+	__m128 v2 = _mm_shuffle_ps(v, v, _MM_SHUFFLE(2, 2, 2, 2));
+	__m128 v3 = _mm_shuffle_ps(v, v, _MM_SHUFFLE(3, 3, 3, 3));
+
+	__m128 m0 = _mm_mul_ps(m[0], v0);
+	__m128 m1 = _mm_mul_ps(m[1], v1);
+	__m128 m2 = _mm_mul_ps(m[2], v2);
+	__m128 m3 = _mm_mul_ps(m[3], v3);
+
+	__m128 a0 = _mm_add_ps(m0, m1);
+	__m128 a1 = _mm_add_ps(m2, m3);
+	__m128 a2 = _mm_add_ps(a0, a1);
+
+	return a2;
+}
+
+inline __m128 _mm_mul_ps(__m128 v, __m128 m[4])
+{
+	__m128 i0 = m[0];
+	__m128 i1 = m[1];
+	__m128 i2 = m[2];
+	__m128 i3 = m[3];
+
+	__m128 m0 = _mm_mul_ps(v, i0);
+	__m128 m1 = _mm_mul_ps(v, i1);
+	__m128 m2 = _mm_mul_ps(v, i2);
+	__m128 m3 = _mm_mul_ps(v, i3);
+
+	__m128 u0 = _mm_unpacklo_ps(m0, m1);
+	__m128 u1 = _mm_unpackhi_ps(m0, m1);
+	__m128 a0 = _mm_add_ps(u0, u1);
+
+	__m128 u2 = _mm_unpacklo_ps(m2, m3);
+	__m128 u3 = _mm_unpackhi_ps(m2, m3);
+	__m128 a1 = _mm_add_ps(u2, u3);
+
+	__m128 f0 = _mm_movelh_ps(a0, a1);
+	__m128 f1 = _mm_movehl_ps(a1, a0);
+	__m128 f2 = _mm_add_ps(f0, f1);
+
+	return f2;
+}
+
+inline void _mm_mul_ps(__m128 const in1[4], __m128 const in2[4], __m128 out[4])
+{
+	{
+		__m128 e0 = _mm_shuffle_ps(in2[0], in2[0], _MM_SHUFFLE(0, 0, 0, 0));
+		__m128 e1 = _mm_shuffle_ps(in2[0], in2[0], _MM_SHUFFLE(1, 1, 1, 1));
+		__m128 e2 = _mm_shuffle_ps(in2[0], in2[0], _MM_SHUFFLE(2, 2, 2, 2));
+		__m128 e3 = _mm_shuffle_ps(in2[0], in2[0], _MM_SHUFFLE(3, 3, 3, 3));
+
+		__m128 m0 = _mm_mul_ps(in1[0], e0);
+		__m128 m1 = _mm_mul_ps(in1[1], e1);
+		__m128 m2 = _mm_mul_ps(in1[2], e2);
+		__m128 m3 = _mm_mul_ps(in1[3], e3);
+
+		__m128 a0 = _mm_add_ps(m0, m1);
+		__m128 a1 = _mm_add_ps(m2, m3);
+		__m128 a2 = _mm_add_ps(a0, a1);
+
+		out[0] = a2;
+	}
+
+	{
+		__m128 e0 = _mm_shuffle_ps(in2[1], in2[1], _MM_SHUFFLE(0, 0, 0, 0));
+		__m128 e1 = _mm_shuffle_ps(in2[1], in2[1], _MM_SHUFFLE(1, 1, 1, 1));
+		__m128 e2 = _mm_shuffle_ps(in2[1], in2[1], _MM_SHUFFLE(2, 2, 2, 2));
+		__m128 e3 = _mm_shuffle_ps(in2[1], in2[1], _MM_SHUFFLE(3, 3, 3, 3));
+
+		__m128 m0 = _mm_mul_ps(in1[0], e0);
+		__m128 m1 = _mm_mul_ps(in1[1], e1);
+		__m128 m2 = _mm_mul_ps(in1[2], e2);
+		__m128 m3 = _mm_mul_ps(in1[3], e3);
+
+		__m128 a0 = _mm_add_ps(m0, m1);
+		__m128 a1 = _mm_add_ps(m2, m3);
+		__m128 a2 = _mm_add_ps(a0, a1);
+
+		out[1] = a2;
+	}
+
+	{
+		__m128 e0 = _mm_shuffle_ps(in2[2], in2[2], _MM_SHUFFLE(0, 0, 0, 0));
+		__m128 e1 = _mm_shuffle_ps(in2[2], in2[2], _MM_SHUFFLE(1, 1, 1, 1));
+		__m128 e2 = _mm_shuffle_ps(in2[2], in2[2], _MM_SHUFFLE(2, 2, 2, 2));
+		__m128 e3 = _mm_shuffle_ps(in2[2], in2[2], _MM_SHUFFLE(3, 3, 3, 3));
+
+		__m128 m0 = _mm_mul_ps(in1[0], e0);
+		__m128 m1 = _mm_mul_ps(in1[1], e1);
+		__m128 m2 = _mm_mul_ps(in1[2], e2);
+		__m128 m3 = _mm_mul_ps(in1[3], e3);
+
+		__m128 a0 = _mm_add_ps(m0, m1);
+		__m128 a1 = _mm_add_ps(m2, m3);
+		__m128 a2 = _mm_add_ps(a0, a1);
+
+		out[2] = a2;
+	}
+
+	{
+		//(__m128&)_mm_shuffle_epi32(__m128i&)in2[0], _MM_SHUFFLE(3, 3, 3, 3))
+		__m128 e0 = _mm_shuffle_ps(in2[3], in2[3], _MM_SHUFFLE(0, 0, 0, 0));
+		__m128 e1 = _mm_shuffle_ps(in2[3], in2[3], _MM_SHUFFLE(1, 1, 1, 1));
+		__m128 e2 = _mm_shuffle_ps(in2[3], in2[3], _MM_SHUFFLE(2, 2, 2, 2));
+		__m128 e3 = _mm_shuffle_ps(in2[3], in2[3], _MM_SHUFFLE(3, 3, 3, 3));
+
+		__m128 m0 = _mm_mul_ps(in1[0], e0);
+		__m128 m1 = _mm_mul_ps(in1[1], e1);
+		__m128 m2 = _mm_mul_ps(in1[2], e2);
+		__m128 m3 = _mm_mul_ps(in1[3], e3);
+
+		__m128 a0 = _mm_add_ps(m0, m1);
+		__m128 a1 = _mm_add_ps(m2, m3);
+		__m128 a2 = _mm_add_ps(a0, a1);
+
+		out[3] = a2;
+	}
+}
+
+inline void _mm_transpose_ps(__m128 const in[4], __m128 out[4])
+{
+    __m128 tmp0 = _mm_shuffle_ps(in[0], in[1], 0x44);
+    __m128 tmp2 = _mm_shuffle_ps(in[0], in[1], 0xEE);
+    __m128 tmp1 = _mm_shuffle_ps(in[2], in[3], 0x44);
+    __m128 tmp3 = _mm_shuffle_ps(in[2], in[3], 0xEE);
+
+    out[0] = _mm_shuffle_ps(tmp0, tmp1, 0x88);
+    out[1] = _mm_shuffle_ps(tmp0, tmp1, 0xDD);
+    out[2] = _mm_shuffle_ps(tmp2, tmp3, 0x88);
+    out[3] = _mm_shuffle_ps(tmp2, tmp3, 0xDD);
+}
+
+inline void _mm_inverse_ps(__m128 const in[4], __m128 out[4])
+{
+	__m128 Fac0;
+	{
+		//	valType SubFactor00 = m[2][2] * m[3][3] - m[3][2] * m[2][3];
+		//	valType SubFactor00 = m[2][2] * m[3][3] - m[3][2] * m[2][3];
+		//	valType SubFactor06 = m[1][2] * m[3][3] - m[3][2] * m[1][3];
+		//	valType SubFactor13 = m[1][2] * m[2][3] - m[2][2] * m[1][3];
+
+		__m128 Swp0a = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(3, 3, 3, 3));
+		__m128 Swp0b = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(2, 2, 2, 2));
+
+		__m128 Swp00 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(2, 2, 2, 2));
+		__m128 Swp01 = _mm_shuffle_ps(Swp0a, Swp0a, _MM_SHUFFLE(2, 0, 0, 0));
+		__m128 Swp02 = _mm_shuffle_ps(Swp0b, Swp0b, _MM_SHUFFLE(2, 0, 0, 0));
+		__m128 Swp03 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(3, 3, 3, 3));
+
+		__m128 Mul00 = _mm_mul_ps(Swp00, Swp01);
+		__m128 Mul01 = _mm_mul_ps(Swp02, Swp03);
+		Fac0 = _mm_sub_ps(Mul00, Mul01);
+
+		bool stop = true;
+	}
+
+	__m128 Fac1;
+	{
+		//	valType SubFactor01 = m[2][1] * m[3][3] - m[3][1] * m[2][3];
+		//	valType SubFactor01 = m[2][1] * m[3][3] - m[3][1] * m[2][3];
+		//	valType SubFactor07 = m[1][1] * m[3][3] - m[3][1] * m[1][3];
+		//	valType SubFactor14 = m[1][1] * m[2][3] - m[2][1] * m[1][3];
+
+		__m128 Swp0a = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(3, 3, 3, 3));
+		__m128 Swp0b = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(1, 1, 1, 1));
+
+		__m128 Swp00 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(1, 1, 1, 1));
+		__m128 Swp01 = _mm_shuffle_ps(Swp0a, Swp0a, _MM_SHUFFLE(2, 0, 0, 0));
+		__m128 Swp02 = _mm_shuffle_ps(Swp0b, Swp0b, _MM_SHUFFLE(2, 0, 0, 0));
+		__m128 Swp03 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(3, 3, 3, 3));
+
+		__m128 Mul00 = _mm_mul_ps(Swp00, Swp01);
+		__m128 Mul01 = _mm_mul_ps(Swp02, Swp03);
+		Fac1 = _mm_sub_ps(Mul00, Mul01);
+
+		bool stop = true;
+	}
+
+
+	__m128 Fac2;
+	{
+		//	valType SubFactor02 = m[2][1] * m[3][2] - m[3][1] * m[2][2];
+		//	valType SubFactor02 = m[2][1] * m[3][2] - m[3][1] * m[2][2];
+		//	valType SubFactor08 = m[1][1] * m[3][2] - m[3][1] * m[1][2];
+		//	valType SubFactor15 = m[1][1] * m[2][2] - m[2][1] * m[1][2];
+
+		__m128 Swp0a = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(2, 2, 2, 2));
+		__m128 Swp0b = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(1, 1, 1, 1));
+
+		__m128 Swp00 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(1, 1, 1, 1));
+		__m128 Swp01 = _mm_shuffle_ps(Swp0a, Swp0a, _MM_SHUFFLE(2, 0, 0, 0));
+		__m128 Swp02 = _mm_shuffle_ps(Swp0b, Swp0b, _MM_SHUFFLE(2, 0, 0, 0));
+		__m128 Swp03 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(2, 2, 2, 2));
+
+		__m128 Mul00 = _mm_mul_ps(Swp00, Swp01);
+		__m128 Mul01 = _mm_mul_ps(Swp02, Swp03);
+		Fac2 = _mm_sub_ps(Mul00, Mul01);
+
+		bool stop = true;
+	}
+
+	__m128 Fac3;
+	{
+		//	valType SubFactor03 = m[2][0] * m[3][3] - m[3][0] * m[2][3];
+		//	valType SubFactor03 = m[2][0] * m[3][3] - m[3][0] * m[2][3];
+		//	valType SubFactor09 = m[1][0] * m[3][3] - m[3][0] * m[1][3];
+		//	valType SubFactor16 = m[1][0] * m[2][3] - m[2][0] * m[1][3];
+
+		__m128 Swp0a = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(3, 3, 3, 3));
+		__m128 Swp0b = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(0, 0, 0, 0));
+
+		__m128 Swp00 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(0, 0, 0, 0));
+		__m128 Swp01 = _mm_shuffle_ps(Swp0a, Swp0a, _MM_SHUFFLE(2, 0, 0, 0));
+		__m128 Swp02 = _mm_shuffle_ps(Swp0b, Swp0b, _MM_SHUFFLE(2, 0, 0, 0));
+		__m128 Swp03 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(3, 3, 3, 3));
+
+		__m128 Mul00 = _mm_mul_ps(Swp00, Swp01);
+		__m128 Mul01 = _mm_mul_ps(Swp02, Swp03);
+		Fac3 = _mm_sub_ps(Mul00, Mul01);
+
+		bool stop = true;
+	}
+
+	__m128 Fac4;
+	{
+		//	valType SubFactor04 = m[2][0] * m[3][2] - m[3][0] * m[2][2];
+		//	valType SubFactor04 = m[2][0] * m[3][2] - m[3][0] * m[2][2];
+		//	valType SubFactor10 = m[1][0] * m[3][2] - m[3][0] * m[1][2];
+		//	valType SubFactor17 = m[1][0] * m[2][2] - m[2][0] * m[1][2];
+
+		__m128 Swp0a = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(2, 2, 2, 2));
+		__m128 Swp0b = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(0, 0, 0, 0));
+
+		__m128 Swp00 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(0, 0, 0, 0));
+		__m128 Swp01 = _mm_shuffle_ps(Swp0a, Swp0a, _MM_SHUFFLE(2, 0, 0, 0));
+		__m128 Swp02 = _mm_shuffle_ps(Swp0b, Swp0b, _MM_SHUFFLE(2, 0, 0, 0));
+		__m128 Swp03 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(2, 2, 2, 2));
+
+		__m128 Mul00 = _mm_mul_ps(Swp00, Swp01);
+		__m128 Mul01 = _mm_mul_ps(Swp02, Swp03);
+		Fac4 = _mm_sub_ps(Mul00, Mul01);
+
+		bool stop = true;
+	}
+
+	__m128 Fac5;
+	{
+		//	valType SubFactor05 = m[2][0] * m[3][1] - m[3][0] * m[2][1];
+		//	valType SubFactor05 = m[2][0] * m[3][1] - m[3][0] * m[2][1];
+		//	valType SubFactor12 = m[1][0] * m[3][1] - m[3][0] * m[1][1];
+		//	valType SubFactor18 = m[1][0] * m[2][1] - m[2][0] * m[1][1];
+
+		__m128 Swp0a = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(1, 1, 1, 1));
+		__m128 Swp0b = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(0, 0, 0, 0));
+
+		__m128 Swp00 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(0, 0, 0, 0));
+		__m128 Swp01 = _mm_shuffle_ps(Swp0a, Swp0a, _MM_SHUFFLE(2, 0, 0, 0));
+		__m128 Swp02 = _mm_shuffle_ps(Swp0b, Swp0b, _MM_SHUFFLE(2, 0, 0, 0));
+		__m128 Swp03 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(1, 1, 1, 1));
+
+		__m128 Mul00 = _mm_mul_ps(Swp00, Swp01);
+		__m128 Mul01 = _mm_mul_ps(Swp02, Swp03);
+		Fac5 = _mm_sub_ps(Mul00, Mul01);
+
+		bool stop = true;
+	}
+
+	__m128 SignA = _mm_set_ps( 1.0f,-1.0f, 1.0f,-1.0f);
+	__m128 SignB = _mm_set_ps(-1.0f, 1.0f,-1.0f, 1.0f);
+
+	// m[1][0]
+	// m[0][0]
+	// m[0][0]
+	// m[0][0]
+	__m128 Temp0 = _mm_shuffle_ps(in[1], in[0], _MM_SHUFFLE(0, 0, 0, 0));
+	__m128 Vec0 = _mm_shuffle_ps(Temp0, Temp0, _MM_SHUFFLE(2, 2, 2, 0));
+
+	// m[1][1]
+	// m[0][1]
+	// m[0][1]
+	// m[0][1]
+	__m128 Temp1 = _mm_shuffle_ps(in[1], in[0], _MM_SHUFFLE(1, 1, 1, 1));
+	__m128 Vec1 = _mm_shuffle_ps(Temp1, Temp1, _MM_SHUFFLE(2, 2, 2, 0));
+
+	// m[1][2]
+	// m[0][2]
+	// m[0][2]
+	// m[0][2]
+	__m128 Temp2 = _mm_shuffle_ps(in[1], in[0], _MM_SHUFFLE(2, 2, 2, 2));
+	__m128 Vec2 = _mm_shuffle_ps(Temp2, Temp2, _MM_SHUFFLE(2, 2, 2, 0));
+
+	// m[1][3]
+	// m[0][3]
+	// m[0][3]
+	// m[0][3]
+	__m128 Temp3 = _mm_shuffle_ps(in[1], in[0], _MM_SHUFFLE(3, 3, 3, 3));
+	__m128 Vec3 = _mm_shuffle_ps(Temp3, Temp3, _MM_SHUFFLE(2, 2, 2, 0));
+
+	// col0
+	// + (Vec1[0] * Fac0[0] - Vec2[0] * Fac1[0] + Vec3[0] * Fac2[0]),
+	// - (Vec1[1] * Fac0[1] - Vec2[1] * Fac1[1] + Vec3[1] * Fac2[1]),
+	// + (Vec1[2] * Fac0[2] - Vec2[2] * Fac1[2] + Vec3[2] * Fac2[2]),
+	// - (Vec1[3] * Fac0[3] - Vec2[3] * Fac1[3] + Vec3[3] * Fac2[3]),
+	__m128 Mul00 = _mm_mul_ps(Vec1, Fac0);
+	__m128 Mul01 = _mm_mul_ps(Vec2, Fac1);
+	__m128 Mul02 = _mm_mul_ps(Vec3, Fac2);
+	__m128 Sub00 = _mm_sub_ps(Mul00, Mul01);
+	__m128 Add00 = _mm_add_ps(Sub00, Mul02);
+	__m128 Inv0 = _mm_mul_ps(SignB, Add00);
+
+	// col1
+	// - (Vec0[0] * Fac0[0] - Vec2[0] * Fac3[0] + Vec3[0] * Fac4[0]),
+	// + (Vec0[0] * Fac0[1] - Vec2[1] * Fac3[1] + Vec3[1] * Fac4[1]),
+	// - (Vec0[0] * Fac0[2] - Vec2[2] * Fac3[2] + Vec3[2] * Fac4[2]),
+	// + (Vec0[0] * Fac0[3] - Vec2[3] * Fac3[3] + Vec3[3] * Fac4[3]),
+	__m128 Mul03 = _mm_mul_ps(Vec0, Fac0);
+	__m128 Mul04 = _mm_mul_ps(Vec2, Fac3);
+	__m128 Mul05 = _mm_mul_ps(Vec3, Fac4);
+	__m128 Sub01 = _mm_sub_ps(Mul03, Mul04);
+	__m128 Add01 = _mm_add_ps(Sub01, Mul05);
+	__m128 Inv1 = _mm_mul_ps(SignA, Add01);
+
+	// col2
+	// + (Vec0[0] * Fac1[0] - Vec1[0] * Fac3[0] + Vec3[0] * Fac5[0]),
+	// - (Vec0[0] * Fac1[1] - Vec1[1] * Fac3[1] + Vec3[1] * Fac5[1]),
+	// + (Vec0[0] * Fac1[2] - Vec1[2] * Fac3[2] + Vec3[2] * Fac5[2]),
+	// - (Vec0[0] * Fac1[3] - Vec1[3] * Fac3[3] + Vec3[3] * Fac5[3]),
+	__m128 Mul06 = _mm_mul_ps(Vec0, Fac1);
+	__m128 Mul07 = _mm_mul_ps(Vec1, Fac3);
+	__m128 Mul08 = _mm_mul_ps(Vec3, Fac5);
+	__m128 Sub02 = _mm_sub_ps(Mul06, Mul07);
+	__m128 Add02 = _mm_add_ps(Sub02, Mul08);
+	__m128 Inv2 = _mm_mul_ps(SignB, Add02);
+
+	// col3
+	// - (Vec1[0] * Fac2[0] - Vec1[0] * Fac4[0] + Vec2[0] * Fac5[0]),
+	// + (Vec1[0] * Fac2[1] - Vec1[1] * Fac4[1] + Vec2[1] * Fac5[1]),
+	// - (Vec1[0] * Fac2[2] - Vec1[2] * Fac4[2] + Vec2[2] * Fac5[2]),
+	// + (Vec1[0] * Fac2[3] - Vec1[3] * Fac4[3] + Vec2[3] * Fac5[3]));
+	__m128 Mul09 = _mm_mul_ps(Vec0, Fac2);
+	__m128 Mul10 = _mm_mul_ps(Vec1, Fac4);
+	__m128 Mul11 = _mm_mul_ps(Vec2, Fac5);
+	__m128 Sub03 = _mm_sub_ps(Mul09, Mul10);
+	__m128 Add03 = _mm_add_ps(Sub03, Mul11);
+	__m128 Inv3 = _mm_mul_ps(SignA, Add03);
+
+	__m128 Row0 = _mm_shuffle_ps(Inv0, Inv1, _MM_SHUFFLE(0, 0, 0, 0));
+	__m128 Row1 = _mm_shuffle_ps(Inv2, Inv3, _MM_SHUFFLE(0, 0, 0, 0));
+	__m128 Row2 = _mm_shuffle_ps(Row0, Row1, _MM_SHUFFLE(2, 0, 2, 0));
+
+	//	valType Determinant = m[0][0] * Inverse[0][0] 
+	//						+ m[0][1] * Inverse[1][0] 
+	//						+ m[0][2] * Inverse[2][0] 
+	//						+ m[0][3] * Inverse[3][0];
+	__m128 Det0 = _mm_dot_ps(in[0], Row2);
+	__m128 Rcp0 = _mm_div_ps(one, Det0);
+	//__m128 Rcp0 = _mm_rcp_ps(Det0);
+
+	//	Inverse /= Determinant;
+	out[0] = _mm_mul_ps(Inv0, Rcp0);
+	out[1] = _mm_mul_ps(Inv1, Rcp0);
+	out[2] = _mm_mul_ps(Inv2, Rcp0);
+	out[3] = _mm_mul_ps(Inv3, Rcp0);
+}
+
+inline void _mm_inverse_fast_ps(__m128 const in[4], __m128 out[4])
+{
+	__m128 Fac0;
+	{
+		//	valType SubFactor00 = m[2][2] * m[3][3] - m[3][2] * m[2][3];
+		//	valType SubFactor00 = m[2][2] * m[3][3] - m[3][2] * m[2][3];
+		//	valType SubFactor06 = m[1][2] * m[3][3] - m[3][2] * m[1][3];
+		//	valType SubFactor13 = m[1][2] * m[2][3] - m[2][2] * m[1][3];
+
+		__m128 Swp0a = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(3, 3, 3, 3));
+		__m128 Swp0b = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(2, 2, 2, 2));
+
+		__m128 Swp00 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(2, 2, 2, 2));
+		__m128 Swp01 = _mm_shuffle_ps(Swp0a, Swp0a, _MM_SHUFFLE(2, 0, 0, 0));
+		__m128 Swp02 = _mm_shuffle_ps(Swp0b, Swp0b, _MM_SHUFFLE(2, 0, 0, 0));
+		__m128 Swp03 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(3, 3, 3, 3));
+
+		__m128 Mul00 = _mm_mul_ps(Swp00, Swp01);
+		__m128 Mul01 = _mm_mul_ps(Swp02, Swp03);
+		Fac0 = _mm_sub_ps(Mul00, Mul01);
+
+		bool stop = true;
+	}
+
+	__m128 Fac1;
+	{
+		//	valType SubFactor01 = m[2][1] * m[3][3] - m[3][1] * m[2][3];
+		//	valType SubFactor01 = m[2][1] * m[3][3] - m[3][1] * m[2][3];
+		//	valType SubFactor07 = m[1][1] * m[3][3] - m[3][1] * m[1][3];
+		//	valType SubFactor14 = m[1][1] * m[2][3] - m[2][1] * m[1][3];
+
+		__m128 Swp0a = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(3, 3, 3, 3));
+		__m128 Swp0b = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(1, 1, 1, 1));
+
+		__m128 Swp00 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(1, 1, 1, 1));
+		__m128 Swp01 = _mm_shuffle_ps(Swp0a, Swp0a, _MM_SHUFFLE(2, 0, 0, 0));
+		__m128 Swp02 = _mm_shuffle_ps(Swp0b, Swp0b, _MM_SHUFFLE(2, 0, 0, 0));
+		__m128 Swp03 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(3, 3, 3, 3));
+
+		__m128 Mul00 = _mm_mul_ps(Swp00, Swp01);
+		__m128 Mul01 = _mm_mul_ps(Swp02, Swp03);
+		Fac1 = _mm_sub_ps(Mul00, Mul01);
+
+		bool stop = true;
+	}
+
+
+	__m128 Fac2;
+	{
+		//	valType SubFactor02 = m[2][1] * m[3][2] - m[3][1] * m[2][2];
+		//	valType SubFactor02 = m[2][1] * m[3][2] - m[3][1] * m[2][2];
+		//	valType SubFactor08 = m[1][1] * m[3][2] - m[3][1] * m[1][2];
+		//	valType SubFactor15 = m[1][1] * m[2][2] - m[2][1] * m[1][2];
+
+		__m128 Swp0a = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(2, 2, 2, 2));
+		__m128 Swp0b = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(1, 1, 1, 1));
+
+		__m128 Swp00 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(1, 1, 1, 1));
+		__m128 Swp01 = _mm_shuffle_ps(Swp0a, Swp0a, _MM_SHUFFLE(2, 0, 0, 0));
+		__m128 Swp02 = _mm_shuffle_ps(Swp0b, Swp0b, _MM_SHUFFLE(2, 0, 0, 0));
+		__m128 Swp03 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(2, 2, 2, 2));
+
+		__m128 Mul00 = _mm_mul_ps(Swp00, Swp01);
+		__m128 Mul01 = _mm_mul_ps(Swp02, Swp03);
+		Fac2 = _mm_sub_ps(Mul00, Mul01);
+
+		bool stop = true;
+	}
+
+	__m128 Fac3;
+	{
+		//	valType SubFactor03 = m[2][0] * m[3][3] - m[3][0] * m[2][3];
+		//	valType SubFactor03 = m[2][0] * m[3][3] - m[3][0] * m[2][3];
+		//	valType SubFactor09 = m[1][0] * m[3][3] - m[3][0] * m[1][3];
+		//	valType SubFactor16 = m[1][0] * m[2][3] - m[2][0] * m[1][3];
+
+		__m128 Swp0a = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(3, 3, 3, 3));
+		__m128 Swp0b = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(0, 0, 0, 0));
+
+		__m128 Swp00 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(0, 0, 0, 0));
+		__m128 Swp01 = _mm_shuffle_ps(Swp0a, Swp0a, _MM_SHUFFLE(2, 0, 0, 0));
+		__m128 Swp02 = _mm_shuffle_ps(Swp0b, Swp0b, _MM_SHUFFLE(2, 0, 0, 0));
+		__m128 Swp03 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(3, 3, 3, 3));
+
+		__m128 Mul00 = _mm_mul_ps(Swp00, Swp01);
+		__m128 Mul01 = _mm_mul_ps(Swp02, Swp03);
+		Fac3 = _mm_sub_ps(Mul00, Mul01);
+
+		bool stop = true;
+	}
+
+	__m128 Fac4;
+	{
+		//	valType SubFactor04 = m[2][0] * m[3][2] - m[3][0] * m[2][2];
+		//	valType SubFactor04 = m[2][0] * m[3][2] - m[3][0] * m[2][2];
+		//	valType SubFactor10 = m[1][0] * m[3][2] - m[3][0] * m[1][2];
+		//	valType SubFactor17 = m[1][0] * m[2][2] - m[2][0] * m[1][2];
+
+		__m128 Swp0a = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(2, 2, 2, 2));
+		__m128 Swp0b = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(0, 0, 0, 0));
+
+		__m128 Swp00 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(0, 0, 0, 0));
+		__m128 Swp01 = _mm_shuffle_ps(Swp0a, Swp0a, _MM_SHUFFLE(2, 0, 0, 0));
+		__m128 Swp02 = _mm_shuffle_ps(Swp0b, Swp0b, _MM_SHUFFLE(2, 0, 0, 0));
+		__m128 Swp03 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(2, 2, 2, 2));
+
+		__m128 Mul00 = _mm_mul_ps(Swp00, Swp01);
+		__m128 Mul01 = _mm_mul_ps(Swp02, Swp03);
+		Fac4 = _mm_sub_ps(Mul00, Mul01);
+
+		bool stop = true;
+	}
+
+	__m128 Fac5;
+	{
+		//	valType SubFactor05 = m[2][0] * m[3][1] - m[3][0] * m[2][1];
+		//	valType SubFactor05 = m[2][0] * m[3][1] - m[3][0] * m[2][1];
+		//	valType SubFactor12 = m[1][0] * m[3][1] - m[3][0] * m[1][1];
+		//	valType SubFactor18 = m[1][0] * m[2][1] - m[2][0] * m[1][1];
+
+		__m128 Swp0a = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(1, 1, 1, 1));
+		__m128 Swp0b = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(0, 0, 0, 0));
+
+		__m128 Swp00 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(0, 0, 0, 0));
+		__m128 Swp01 = _mm_shuffle_ps(Swp0a, Swp0a, _MM_SHUFFLE(2, 0, 0, 0));
+		__m128 Swp02 = _mm_shuffle_ps(Swp0b, Swp0b, _MM_SHUFFLE(2, 0, 0, 0));
+		__m128 Swp03 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(1, 1, 1, 1));
+
+		__m128 Mul00 = _mm_mul_ps(Swp00, Swp01);
+		__m128 Mul01 = _mm_mul_ps(Swp02, Swp03);
+		Fac5 = _mm_sub_ps(Mul00, Mul01);
+
+		bool stop = true;
+	}
+
+	__m128 SignA = _mm_set_ps( 1.0f,-1.0f, 1.0f,-1.0f);
+	__m128 SignB = _mm_set_ps(-1.0f, 1.0f,-1.0f, 1.0f);
+
+	// m[1][0]
+	// m[0][0]
+	// m[0][0]
+	// m[0][0]
+	__m128 Temp0 = _mm_shuffle_ps(in[1], in[0], _MM_SHUFFLE(0, 0, 0, 0));
+	__m128 Vec0 = _mm_shuffle_ps(Temp0, Temp0, _MM_SHUFFLE(2, 2, 2, 0));
+
+	// m[1][1]
+	// m[0][1]
+	// m[0][1]
+	// m[0][1]
+	__m128 Temp1 = _mm_shuffle_ps(in[1], in[0], _MM_SHUFFLE(1, 1, 1, 1));
+	__m128 Vec1 = _mm_shuffle_ps(Temp1, Temp1, _MM_SHUFFLE(2, 2, 2, 0));
+
+	// m[1][2]
+	// m[0][2]
+	// m[0][2]
+	// m[0][2]
+	__m128 Temp2 = _mm_shuffle_ps(in[1], in[0], _MM_SHUFFLE(2, 2, 2, 2));
+	__m128 Vec2 = _mm_shuffle_ps(Temp2, Temp2, _MM_SHUFFLE(2, 2, 2, 0));
+
+	// m[1][3]
+	// m[0][3]
+	// m[0][3]
+	// m[0][3]
+	__m128 Temp3 = _mm_shuffle_ps(in[1], in[0], _MM_SHUFFLE(3, 3, 3, 3));
+	__m128 Vec3 = _mm_shuffle_ps(Temp3, Temp3, _MM_SHUFFLE(2, 2, 2, 0));
+
+	// col0
+	// + (Vec1[0] * Fac0[0] - Vec2[0] * Fac1[0] + Vec3[0] * Fac2[0]),
+	// - (Vec1[1] * Fac0[1] - Vec2[1] * Fac1[1] + Vec3[1] * Fac2[1]),
+	// + (Vec1[2] * Fac0[2] - Vec2[2] * Fac1[2] + Vec3[2] * Fac2[2]),
+	// - (Vec1[3] * Fac0[3] - Vec2[3] * Fac1[3] + Vec3[3] * Fac2[3]),
+	__m128 Mul00 = _mm_mul_ps(Vec1, Fac0);
+	__m128 Mul01 = _mm_mul_ps(Vec2, Fac1);
+	__m128 Mul02 = _mm_mul_ps(Vec3, Fac2);
+	__m128 Sub00 = _mm_sub_ps(Mul00, Mul01);
+	__m128 Add00 = _mm_add_ps(Sub00, Mul02);
+	__m128 Inv0 = _mm_mul_ps(SignB, Add00);
+
+	// col1
+	// - (Vec0[0] * Fac0[0] - Vec2[0] * Fac3[0] + Vec3[0] * Fac4[0]),
+	// + (Vec0[0] * Fac0[1] - Vec2[1] * Fac3[1] + Vec3[1] * Fac4[1]),
+	// - (Vec0[0] * Fac0[2] - Vec2[2] * Fac3[2] + Vec3[2] * Fac4[2]),
+	// + (Vec0[0] * Fac0[3] - Vec2[3] * Fac3[3] + Vec3[3] * Fac4[3]),
+	__m128 Mul03 = _mm_mul_ps(Vec0, Fac0);
+	__m128 Mul04 = _mm_mul_ps(Vec2, Fac3);
+	__m128 Mul05 = _mm_mul_ps(Vec3, Fac4);
+	__m128 Sub01 = _mm_sub_ps(Mul03, Mul04);
+	__m128 Add01 = _mm_add_ps(Sub01, Mul05);
+	__m128 Inv1 = _mm_mul_ps(SignA, Add01);
+
+	// col2
+	// + (Vec0[0] * Fac1[0] - Vec1[0] * Fac3[0] + Vec3[0] * Fac5[0]),
+	// - (Vec0[0] * Fac1[1] - Vec1[1] * Fac3[1] + Vec3[1] * Fac5[1]),
+	// + (Vec0[0] * Fac1[2] - Vec1[2] * Fac3[2] + Vec3[2] * Fac5[2]),
+	// - (Vec0[0] * Fac1[3] - Vec1[3] * Fac3[3] + Vec3[3] * Fac5[3]),
+	__m128 Mul06 = _mm_mul_ps(Vec0, Fac1);
+	__m128 Mul07 = _mm_mul_ps(Vec1, Fac3);
+	__m128 Mul08 = _mm_mul_ps(Vec3, Fac5);
+	__m128 Sub02 = _mm_sub_ps(Mul06, Mul07);
+	__m128 Add02 = _mm_add_ps(Sub02, Mul08);
+	__m128 Inv2 = _mm_mul_ps(SignB, Add02);
+
+	// col3
+	// - (Vec1[0] * Fac2[0] - Vec1[0] * Fac4[0] + Vec2[0] * Fac5[0]),
+	// + (Vec1[0] * Fac2[1] - Vec1[1] * Fac4[1] + Vec2[1] * Fac5[1]),
+	// - (Vec1[0] * Fac2[2] - Vec1[2] * Fac4[2] + Vec2[2] * Fac5[2]),
+	// + (Vec1[0] * Fac2[3] - Vec1[3] * Fac4[3] + Vec2[3] * Fac5[3]));
+	__m128 Mul09 = _mm_mul_ps(Vec0, Fac2);
+	__m128 Mul10 = _mm_mul_ps(Vec1, Fac4);
+	__m128 Mul11 = _mm_mul_ps(Vec2, Fac5);
+	__m128 Sub03 = _mm_sub_ps(Mul09, Mul10);
+	__m128 Add03 = _mm_add_ps(Sub03, Mul11);
+	__m128 Inv3 = _mm_mul_ps(SignA, Add03);
+
+	__m128 Row0 = _mm_shuffle_ps(Inv0, Inv1, _MM_SHUFFLE(0, 0, 0, 0));
+	__m128 Row1 = _mm_shuffle_ps(Inv2, Inv3, _MM_SHUFFLE(0, 0, 0, 0));
+	__m128 Row2 = _mm_shuffle_ps(Row0, Row1, _MM_SHUFFLE(2, 0, 2, 0));
+
+	//	valType Determinant = m[0][0] * Inverse[0][0] 
+	//						+ m[0][1] * Inverse[1][0] 
+	//						+ m[0][2] * Inverse[2][0] 
+	//						+ m[0][3] * Inverse[3][0];
+	__m128 Det0 = _mm_dot_ps(in[0], Row2);
+	__m128 Rcp0 = _mm_rcp_ps(Det0);
+	//__m128 Rcp0 = _mm_div_ps(one, Det0);
+	//	Inverse /= Determinant;
+	out[0] = _mm_mul_ps(Inv0, Rcp0);
+	out[1] = _mm_mul_ps(Inv1, Rcp0);
+	out[2] = _mm_mul_ps(Inv2, Rcp0);
+	out[3] = _mm_mul_ps(Inv3, Rcp0);
+}
+
+
+void _mm_rotate_ps(__m128 const in[4], float Angle, float const v[3], __m128 out[4])
+{
+	float a = glm::radians(Angle);
+    float c = cos(a);
+    float s = sin(a);
+
+	glm::vec4 AxisA(v[0], v[1], v[2], float(0));
+	__m128 AxisB = _mm_set_ps(AxisA.w, AxisA.z, AxisA.y, AxisA.x);
+    __m128 AxisC = _mm_nrm_ps(AxisB);
+
+	__m128 Cos0 = _mm_set_ss(c);
+	__m128 CosA = _mm_shuffle_ps(Cos0, Cos0, _MM_SHUFFLE(0, 0, 0, 0));
+	__m128 Sin0 = _mm_set_ss(s);
+	__m128 SinA = _mm_shuffle_ps(Sin0, Sin0, _MM_SHUFFLE(0, 0, 0, 0));
+
+	// detail::tvec3<valType> temp = (valType(1) - c) * axis;
+	__m128 Temp0 = _mm_sub_ps(one, CosA);
+	__m128 Temp1 = _mm_mul_ps(Temp0, AxisC);
+	
+	//Rotate[0][0] = c + temp[0] * axis[0];
+	//Rotate[0][1] = 0 + temp[0] * axis[1] + s * axis[2];
+	//Rotate[0][2] = 0 + temp[0] * axis[2] - s * axis[1];
+	__m128 Axis0 = _mm_shuffle_ps(AxisC, AxisC, _MM_SHUFFLE(0, 0, 0, 0));
+	__m128 TmpA0 = _mm_mul_ps(Axis0, AxisC);
+	__m128 CosA0 = _mm_shuffle_ps(Cos0, Cos0, _MM_SHUFFLE(1, 1, 1, 0));
+	__m128 TmpA1 = _mm_add_ps(CosA0, TmpA0);
+	__m128 SinA0 = SinA;//_mm_set_ps(0.0f, s, -s, 0.0f);
+	__m128 TmpA2 = _mm_shuffle_ps(AxisC, AxisC, _MM_SHUFFLE(3, 1, 2, 3));
+	__m128 TmpA3 = _mm_mul_ps(SinA0, TmpA2);
+	__m128 TmpA4 = _mm_add_ps(TmpA1, TmpA3);
+
+	//Rotate[1][0] = 0 + temp[1] * axis[0] - s * axis[2];
+	//Rotate[1][1] = c + temp[1] * axis[1];
+	//Rotate[1][2] = 0 + temp[1] * axis[2] + s * axis[0];
+	__m128 Axis1 = _mm_shuffle_ps(AxisC, AxisC, _MM_SHUFFLE(1, 1, 1, 1));
+	__m128 TmpB0 = _mm_mul_ps(Axis1, AxisC);
+	__m128 CosA1 = _mm_shuffle_ps(Cos0, Cos0, _MM_SHUFFLE(1, 1, 0, 1));
+	__m128 TmpB1 = _mm_add_ps(CosA1, TmpB0);
+	__m128 SinB0 = SinA;//_mm_set_ps(-s, 0.0f, s, 0.0f);
+	__m128 TmpB2 = _mm_shuffle_ps(AxisC, AxisC, _MM_SHUFFLE(3, 0, 3, 2));
+	__m128 TmpB3 = _mm_mul_ps(SinA0, TmpB2);
+	__m128 TmpB4 = _mm_add_ps(TmpB1, TmpB3);
+
+    //Rotate[2][0] = 0 + temp[2] * axis[0] + s * axis[1];
+    //Rotate[2][1] = 0 + temp[2] * axis[1] - s * axis[0];
+    //Rotate[2][2] = c + temp[2] * axis[2];
+	__m128 Axis2 = _mm_shuffle_ps(AxisC, AxisC, _MM_SHUFFLE(2, 2, 2, 2));
+	__m128 TmpC0 = _mm_mul_ps(Axis2, AxisC);
+	__m128 CosA2 = _mm_shuffle_ps(Cos0, Cos0, _MM_SHUFFLE(1, 0, 1, 1));
+	__m128 TmpC1 = _mm_add_ps(CosA2, TmpC0);
+	__m128 SinC0 = SinA;//_mm_set_ps(s, -s, 0.0f, 0.0f);
+	__m128 TmpC2 = _mm_shuffle_ps(AxisC, AxisC, _MM_SHUFFLE(3, 3, 0, 1));
+	__m128 TmpC3 = _mm_mul_ps(SinA0, TmpC2);
+	__m128 TmpC4 = _mm_add_ps(TmpC1, TmpC3);
+
+	__m128 Result[4];
+	Result[0] = TmpA4;
+	Result[1] = TmpB4;
+	Result[2] = TmpC4;
+	Result[2] = _mm_set_ps(1, 0, 0, 0);
+
+	//detail::tmat4x4<valType> Result(detail::tmat4x4<valType>::null);
+	//Result[0] = m[0] * Rotate[0][0] + m[1] * Rotate[0][1] + m[2] * Rotate[0][2];
+	//Result[1] = m[0] * Rotate[1][0] + m[1] * Rotate[1][1] + m[2] * Rotate[1][2];
+	//Result[2] = m[0] * Rotate[2][0] + m[1] * Rotate[2][1] + m[2] * Rotate[2][2];
+	//Result[3] = m[3];
+	//return Result;
+	_mm_mul_ps(in, Result, out);
+}

glm/core/intrinsic_vector_relational.hpp

@@ -0,0 +1,18 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2010 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2009-06-09
+// Updated : 2009-06-09
+// Licence : This source is under MIT License
+// File    : glm/core/intrinsic_vector_relational.hpp
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#ifndef GLM_DETAIL_INTRINSIC_VECTOR_RELATIONAL_INCLUDED
+#define GLM_DETAIL_INTRINSIC_VECTOR_RELATIONAL_INCLUDED
+
+#include <xmmintrin.h>
+#include <emmintrin.h>
+
+#include "intrinsic_vector_relational.inl"
+
+#endif//GLM_DETAIL_INTRINSIC_VECTOR_RELATIONAL_INCLUDED

glm/core/intrinsic_vector_relational.inl

@@ -0,0 +1,347 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2010 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2009-06-09
+// Updated : 2009-06-09
+// Licence : This source is under MIT License
+// File    : glm/core/intrinsic_vector_relational.inl
+///////////////////////////////////////////////////////////////////////////////////////////////////
+//
+//// lessThan
+//template <typename valType>
+//inline typename detail::tvec2<valType>::bool_type lessThan
+//(
+//	detail::tvec2<valType> const & x, 
+//	detail::tvec2<valType> const & y
+//)
+//{
+//	GLM_STATIC_ASSERT(
+//		detail::type<valType>::is_float || 
+//		detail::type<valType>::is_int || 
+//		detail::type<valType>::is_uint);
+//
+//    return typename detail::tvec2<bool>::bool_type(x.x < y.x, x.y < y.y);
+//}
+//
+//template <typename valType>
+//inline typename detail::tvec3<valType>::bool_type lessThan
+//(
+//	detail::tvec3<valType> const & x, 
+//	detail::tvec3<valType> const & y
+//)
+//{
+//	GLM_STATIC_ASSERT(
+//		detail::type<valType>::is_float || 
+//		detail::type<valType>::is_int || 
+//		detail::type<valType>::is_uint);
+//	
+//	return typename detail::tvec3<bool>::bool_type(x.x < y.x, x.y < y.y, x.z < y.z);
+//}
+//
+//template <typename valType>
+//inline typename detail::tvec4<valType>::bool_type lessThan
+//(
+//	detail::tvec4<valType> const & x, 
+//	detail::tvec4<valType> const & y
+//)
+//{
+//	GLM_STATIC_ASSERT(
+//		detail::type<valType>::is_float || 
+//		detail::type<valType>::is_int || 
+//		detail::type<valType>::is_uint);
+//
+//	return typename detail::tvec4<bool>::bool_type(x.x < y.x, x.y < y.y, x.z < y.z, x.w < y.w);
+//}
+//
+//// lessThanEqual
+//template <typename valType>
+//inline typename detail::tvec2<valType>::bool_type lessThanEqual
+//(
+//	detail::tvec2<valType> const & x, 
+//	detail::tvec2<valType> const & y
+//)
+//{
+//	GLM_STATIC_ASSERT(
+//		detail::type<valType>::is_float || 
+//		detail::type<valType>::is_int || 
+//		detail::type<valType>::is_uint);
+//
+//	return typename detail::tvec2<bool>::bool_type(x.x <= y.x, x.y <= y.y);
+//}
+//
+//template <typename valType>
+//inline typename detail::tvec3<valType>::bool_type lessThanEqual
+//(
+//	detail::tvec3<valType> const & x, 
+//	detail::tvec3<valType> const & y
+//)
+//{
+//	GLM_STATIC_ASSERT(
+//		detail::type<valType>::is_float || 
+//		detail::type<valType>::is_int || 
+//		detail::type<valType>::is_uint);
+//	
+//	return typename detail::tvec3<bool>::bool_type(x.x <= y.x, x.y <= y.y, x.z <= y.z);
+//}
+//
+//template <typename valType>
+//inline typename detail::tvec4<valType>::bool_type lessThanEqual
+//(
+//	detail::tvec4<valType> const & x, 
+//	detail::tvec4<valType> const & y
+//)
+//{
+//	GLM_STATIC_ASSERT(
+//		detail::type<valType>::is_float || 
+//		detail::type<valType>::is_int || 
+//		detail::type<valType>::is_uint);
+//	
+//	return typename detail::tvec4<bool>::bool_type(x.x <= y.x, x.y <= y.y, x.z <= y.z, x.w <= y.w);
+//}
+//
+//// greaterThan
+//template <typename valType>
+//inline typename detail::tvec2<valType>::bool_type greaterThan
+//(
+//	detail::tvec2<valType> const & x, 
+//	detail::tvec2<valType> const & y
+//)
+//{
+//	GLM_STATIC_ASSERT(
+//		detail::type<valType>::is_float || 
+//		detail::type<valType>::is_int || 
+//		detail::type<valType>::is_uint);
+//
+//	return typename detail::tvec2<bool>::bool_type(x.x > y.x, x.y > y.y);
+//}
+//
+//template <typename valType>
+//inline typename detail::tvec3<valType>::bool_type greaterThan
+//(
+//	detail::tvec3<valType> const & x, 
+//	detail::tvec3<valType> const & y
+//)
+//{
+//	GLM_STATIC_ASSERT(
+//		detail::type<valType>::is_float || 
+//		detail::type<valType>::is_int || 
+//		detail::type<valType>::is_uint);
+//	
+//	return typename detail::tvec3<bool>::bool_type(x.x > y.x, x.y > y.y, x.z > y.z);
+//}
+//
+//template <typename valType>
+//inline typename detail::tvec4<valType>::bool_type greaterThan
+//(
+//	detail::tvec4<valType> const & x, 
+//	detail::tvec4<valType> const & y
+//)
+//{
+//	GLM_STATIC_ASSERT(
+//		detail::type<valType>::is_float || 
+//		detail::type<valType>::is_int || 
+//		detail::type<valType>::is_uint);
+//	
+//	return typename detail::tvec4<bool>::bool_type(x.x > y.x, x.y > y.y, x.z > y.z, x.w > y.w);
+//}
+//
+//// greaterThanEqual
+//template <typename valType>
+//inline typename detail::tvec2<valType>::bool_type greaterThanEqual
+//(
+//	detail::tvec2<valType> const & x, 
+//	detail::tvec2<valType> const & y
+//)
+//{
+//	GLM_STATIC_ASSERT(
+//		detail::type<valType>::is_float || 
+//		detail::type<valType>::is_int || 
+//		detail::type<valType>::is_uint);
+//
+//	return typename detail::tvec2<bool>::bool_type(x.x >= y.x, x.y >= y.y);
+//}
+//
+//template <typename valType>
+//inline typename detail::tvec3<valType>::bool_type greaterThanEqual
+//(
+//	detail::tvec3<valType> const & x, 
+//	detail::tvec3<valType> const & y
+//)
+//{
+//	GLM_STATIC_ASSERT(
+//		detail::type<valType>::is_float || 
+//		detail::type<valType>::is_int || 
+//		detail::type<valType>::is_uint);
+//
+//	return typename detail::tvec3<bool>::bool_type(x.x >= y.x, x.y >= y.y, x.z >= y.z);
+//}
+//
+//template <typename valType>
+//inline typename detail::tvec4<valType>::bool_type greaterThanEqual
+//(
+//	detail::tvec4<valType> const & x, 
+//	detail::tvec4<valType> const & y
+//)
+//{
+//	GLM_STATIC_ASSERT(
+//		detail::type<valType>::is_float || 
+//		detail::type<valType>::is_int || 
+//		detail::type<valType>::is_uint);
+//
+//	return typename detail::tvec4<bool>::bool_type(x.x >= y.x, x.y >= y.y, x.z >= y.z, x.w >= y.w);
+//}
+//
+//// equal
+//template <typename valType>
+//inline typename detail::tvec2<valType>::bool_type equal
+//(
+//	detail::tvec2<valType> const & x, 
+//	detail::tvec2<valType> const & y
+//)
+//{
+//	GLM_STATIC_ASSERT(
+//		detail::type<valType>::is_float || 
+//		detail::type<valType>::is_int || 
+//		detail::type<valType>::is_uint || 
+//		detail::type<valType>::is_bool);
+//
+//	return typename detail::tvec2<valType>::bool_type(x.x == y.x, x.y == y.y);
+//}
+//
+//template <typename valType>
+//inline typename detail::tvec3<valType>::bool_type equal
+//(
+//	detail::tvec3<valType> const & x, 
+//	detail::tvec3<valType> const & y
+//)
+//{
+//	GLM_STATIC_ASSERT(
+//		detail::type<valType>::is_float || 
+//		detail::type<valType>::is_int || 
+//		detail::type<valType>::is_uint || 
+//		detail::type<valType>::is_bool);
+//
+//	return typename detail::tvec3<valType>::bool_type(x.x == y.x, x.y == y.y, x.z == y.z);
+//}
+//
+//template <typename valType>
+//inline typename detail::tvec4<valType>::bool_type equal
+//(
+//	detail::tvec4<valType> const & x, 
+//	detail::tvec4<valType> const & y
+//)
+//{
+//	GLM_STATIC_ASSERT(
+//		detail::type<valType>::is_float || 
+//		detail::type<valType>::is_int || 
+//		detail::type<valType>::is_uint || 
+//		detail::type<valType>::is_bool);
+//
+//	return typename detail::tvec4<valType>::bool_type(x.x == y.x, x.y == y.y, x.z == y.z, x.w == y.w);
+//}
+//
+//// notEqual
+//template <typename valType>
+//inline typename detail::tvec2<valType>::bool_type notEqual
+//(
+//	detail::tvec2<valType> const & x, 
+//	detail::tvec2<valType> const & y
+//)
+//{
+//	GLM_STATIC_ASSERT(
+//		detail::type<valType>::is_float || 
+//		detail::type<valType>::is_int || 
+//		detail::type<valType>::is_uint || 
+//		detail::type<valType>::is_bool);
+//
+//	return typename detail::tvec2<valType>::bool_type(x.x != y.x, x.y != y.y);
+//}
+//
+//template <typename valType>
+//inline typename detail::tvec3<valType>::bool_type notEqual
+//(
+//	detail::tvec3<valType> const & x, 
+//	detail::tvec3<valType> const & y
+//)
+//{
+//	GLM_STATIC_ASSERT(
+//		detail::type<valType>::is_float || 
+//		detail::type<valType>::is_int || 
+//		detail::type<valType>::is_uint || 
+//		detail::type<valType>::is_bool);
+//
+//	return typename detail::tvec3<valType>::bool_type(x.x != y.x, x.y != y.y, x.z != y.z);
+//}
+//
+//template <typename valType>
+//inline typename detail::tvec4<valType>::bool_type notEqual
+//(
+//	detail::tvec4<valType> const & x, 
+//	detail::tvec4<valType> const & y
+//)
+//{
+//	GLM_STATIC_ASSERT(
+//		detail::type<valType>::is_float || 
+//		detail::type<valType>::is_int || 
+//		detail::type<valType>::is_uint || 
+//		detail::type<valType>::is_bool);
+//
+//	return typename detail::tvec4<valType>::bool_type(x.x != y.x, x.y != y.y, x.z != y.z, x.w != y.w);
+//}
+//
+//// any
+//inline bool any(detail::tvec2<bool> const & x)
+//{
+//	return x.x || x.y;
+//}
+//
+//inline bool any(detail::tvec3<bool> const & x)
+//{
+//    return x.x || x.y || x.z;
+//}
+//
+//inline bool any(detail::tvec4<bool> const & x)
+//{
+//    return x.x || x.y || x.z || x.w;
+//}
+//
+//// all
+//inline bool all(const detail::tvec2<bool>& x)
+//{
+//    return x.x && x.y;
+//}
+//
+//inline bool all(const detail::tvec3<bool>& x)
+//{
+//    return x.x && x.y && x.z;
+//}
+//
+//inline bool all(const detail::tvec4<bool>& x)
+//{
+//    return x.x && x.y && x.z && x.w;
+//}
+//
+//// not
+//inline detail::tvec2<bool>::bool_type not_
+//(
+//	detail::tvec2<bool> const & v
+//)
+//{
+//    return detail::tvec2<bool>::bool_type(!v.x, !v.y);
+//}
+//
+//inline detail::tvec3<bool>::bool_type not_
+//(
+//	detail::tvec3<bool> const & v
+//)
+//{
+//    return detail::tvec3<bool>::bool_type(!v.x, !v.y, !v.z);
+//}
+//
+//inline detail::tvec4<bool>::bool_type not_
+//(
+//	detail::tvec4<bool> const & v
+//)
+//{
+//    return detail::tvec4<bool>::bool_type(!v.x, !v.y, !v.z, !v.w);
+//}

glm/core/type.hpp

@@ -0,0 +1,283 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2010 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2008-01-08
+// Updated : 2008-01-08
+// Licence : This source is under MIT License
+// File    : glm/core/type.hpp
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#ifndef glm_core_type
+#define glm_core_type
+
+#include "type_half.hpp"
+#include "type_float.hpp"
+#include "type_int.hpp"
+
+#include "type_gentype.hpp"
+
+#include "type_vec1.hpp"
+#include "type_vec2.hpp"
+#include "type_vec3.hpp"
+#include "type_vec4.hpp"
+
+#include "type_mat2x2.hpp"
+#include "type_mat2x3.hpp"
+#include "type_mat2x4.hpp"
+#include "type_mat3x2.hpp"
+#include "type_mat3x3.hpp"
+#include "type_mat3x4.hpp"
+#include "type_mat4x2.hpp"
+#include "type_mat4x3.hpp"
+#include "type_mat4x4.hpp"
+
+namespace glm{
+namespace core{
+namespace type
+{
+	//////////////////////////
+	// Float definition
+
+#if(defined(GLM_PRECISION) && GLM_PRECISION & GLM_PRECISION_HIGHP_FLOAT)
+	typedef precision::highp_vec2		vec2;
+	typedef precision::highp_vec3		vec3;
+	typedef precision::highp_vec4		vec4;
+	typedef precision::highp_mat2x2		mat2x2;
+	typedef precision::highp_mat2x3		mat2x3;
+	typedef precision::highp_mat2x4		mat2x4;
+	typedef precision::highp_mat3x2		mat3x2;
+	typedef precision::highp_mat3x3		mat3x3;
+	typedef precision::highp_mat3x4		mat3x4;
+	typedef precision::highp_mat4x2		mat4x2;
+	typedef precision::highp_mat4x3		mat4x3;
+	typedef precision::highp_mat4x4		mat4x4;
+#elif(defined(GLM_PRECISION) && GLM_PRECISION & GLM_PRECISION_MEDIUMP_FLOAT)
+	typedef precision::mediump_vec2		vec2;
+	typedef precision::mediump_vec3		vec3;
+	typedef precision::mediump_vec4		vec4;
+	typedef precision::mediump_mat2x2	mat2x2;
+	typedef precision::mediump_mat2x3	mat2x3;
+	typedef precision::mediump_mat2x4	mat2x4;
+	typedef precision::mediump_mat3x2	mat3x2;
+	typedef precision::mediump_mat3x3	mat3x3;
+	typedef precision::mediump_mat3x4	mat3x4;
+	typedef precision::mediump_mat4x2	mat4x2;
+	typedef precision::mediump_mat4x3	mat4x3;
+	typedef precision::mediump_mat4x4	mat4x4;
+#elif(defined(GLM_PRECISION) && GLM_PRECISION & GLM_PRECISION_LOWP_FLOAT)
+	typedef precision::lowp_vec2			vec2;
+	typedef precision::lowp_vec3			vec3;
+	typedef precision::lowp_vec4			vec4;
+	typedef precision::lowp_mat2x2			mat2x2;
+	typedef precision::lowp_mat2x3			mat2x3;
+	typedef precision::lowp_mat2x4			mat2x4;
+	typedef precision::lowp_mat3x2			mat3x2;
+	typedef precision::lowp_mat3x3			mat3x3;
+	typedef precision::lowp_mat3x4			mat3x4;
+	typedef precision::lowp_mat4x2			mat4x2;
+	typedef precision::lowp_mat4x3			mat4x3;
+	typedef precision::lowp_mat4x4			mat4x4;
+#else
+	//! 2 components vector of floating-point numbers. 
+	//! From GLSL 1.30.8 specification, section 4.1.5 Vectors.
+	typedef precision::mediump_vec2		vec2;
+
+	//! 3 components vector of floating-point numbers. 
+	//! From GLSL 1.30.8 specification, section 4.1.5 Vectors.
+	typedef precision::mediump_vec3		vec3;
+
+	//! 4 components vector of floating-point numbers. 
+	//! From GLSL 1.30.8 specification, section 4.1.5 Vectors.
+	typedef precision::mediump_vec4		vec4;
+
+	//! 2 columns of 2 components matrix of floating-point numbers. 
+	//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices)
+	typedef precision::mediump_mat2x2		mat2x2;
+
+	//! 2 columns of 3 components matrix of floating-point numbers. 
+	//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices)
+	typedef precision::mediump_mat2x3		mat2x3;
+
+	//! 2 columns of 4 components matrix of floating-point numbers. 
+	//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices)
+	typedef precision::mediump_mat2x4		mat2x4;
+
+	//! 3 columns of 2 components matrix of floating-point numbers. 
+	//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices)
+	typedef precision::mediump_mat3x2		mat3x2;
+
+	//! 3 columns of 3 components matrix of floating-point numbers. 
+	//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices)
+	typedef precision::mediump_mat3x3		mat3x3;
+
+	//! 3 columns of 4 components matrix of floating-point numbers. 
+	//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices)
+	typedef precision::mediump_mat3x4		mat3x4;
+
+	//! 4 columns of 2 components matrix of floating-point numbers. 
+	//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices)
+	typedef precision::mediump_mat4x2		mat4x2;
+
+	//! 4 columns of 3 components matrix of floating-point numbers. 
+	//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices)
+	typedef precision::mediump_mat4x3		mat4x3;
+
+	//! 4 columns of 4 components matrix of floating-point numbers. 
+	//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices)
+	typedef precision::mediump_mat4x4		mat4x4;
+
+#endif//GLM_PRECISION
+
+	//! 2 columns of 2 components matrix of floating-point numbers. 
+	//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices)
+	typedef mat2x2							mat2;
+
+	//! 3 columns of 3 components matrix of floating-point numbers. 
+	//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices)
+	typedef mat3x3							mat3;
+
+	//! 4 columns of 4 components matrix of floating-point numbers. 
+	//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices)
+	typedef mat4x4							mat4;
+
+	//////////////////////////
+	// Signed integer definition
+
+#if(defined(GLM_PRECISION) && GLM_PRECISION & GLM_PRECISION_HIGHP_INT)
+	typedef precision::highp_ivec2			ivec2;
+	typedef precision::highp_ivec3			ivec3;
+	typedef precision::highp_ivec4			ivec4;
+#elif(defined(GLM_PRECISION) && GLM_PRECISION & GLM_PRECISION_MEDIUMP_INT)
+	typedef precision::mediump_ivec2		ivec2;
+	typedef precision::mediump_ivec3		ivec3;
+	typedef precision::mediump_ivec4		ivec4;
+#elif(defined(GLM_PRECISION) && GLM_PRECISION & GLM_PRECISION_LOWP_INT)
+	typedef precision::lowp_ivec2			ivec2;
+	typedef precision::lowp_ivec3			ivec3;
+	typedef precision::lowp_ivec4			ivec4;
+#else
+	//! 2 components vector of signed integer numbers. 
+	//! From GLSL 1.30.8 specification, section 4.1.5 Vectors.
+	typedef precision::mediump_ivec2		ivec2;
+
+	//! 3 components vector of signed integer numbers. 
+	//! From GLSL 1.30.8 specification, section 4.1.5 Vectors.
+	typedef precision::mediump_ivec3		ivec3;
+
+	//! 4 components vector of signed integer numbers. 
+	//! From GLSL 1.30.8 specification, section 4.1.5 Vectors.
+	typedef precision::mediump_ivec4		ivec4;
+#endif//GLM_PRECISION
+
+	//////////////////////////
+	// Unsigned integer definition
+
+#if(defined(GLM_PRECISION) && GLM_PRECISION & GLM_PRECISION_HIGHP_UINT)
+	typedef precision::highp_uvec2			uvec2;
+	typedef precision::highp_uvec3			uvec3;
+	typedef precision::highp_uvec4			uvec4;
+#elif(defined(GLM_PRECISION) && GLM_PRECISION & GLM_PRECISION_MEDIUMP_UINT)
+	typedef precision::mediump_uvec2		uvec2;
+	typedef precision::mediump_uvec3		uvec3;
+	typedef precision::mediump_uvec4		uvec4;
+#elif(defined(GLM_PRECISION) && GLM_PRECISION & GLM_PRECISION_LOWP_UINT)
+	typedef precision::lowp_uvec2			uvec2;
+	typedef precision::lowp_uvec3			uvec3;
+	typedef precision::lowp_uvec4			uvec4;
+#else
+	//! 2 components vector of unsigned integer numbers. 
+	//! From GLSL 1.30.8 specification, section 4.1.5 Vectors.
+	typedef precision::mediump_uvec2		uvec2;
+
+	//! 3 components vector of unsigned integer numbers. 
+	//! From GLSL 1.30.8 specification, section 4.1.5 Vectors.
+	typedef precision::mediump_uvec3		uvec3;
+
+	//! 4 components vector of unsigned integer numbers. 
+	//! From GLSL 1.30.8 specification, section 4.1.5 Vectors.
+	typedef precision::mediump_uvec4		uvec4;
+#endif//GLM_PRECISION
+
+	//////////////////////////
+	// Boolean definition
+
+	//! 2 components vector of boolean. 
+	//! From GLSL 1.30.8 specification, section 4.1.5 Vectors.
+	typedef detail::tvec2<bool>		bvec2;
+
+	//! 3 components vector of boolean. 
+	//! From GLSL 1.30.8 specification, section 4.1.5 Vectors.
+	typedef detail::tvec3<bool>		bvec3;
+
+	//! 4 components vector of boolean. 
+	//! From GLSL 1.30.8 specification, section 4.1.5 Vectors.
+	typedef detail::tvec4<bool>		bvec4;
+
+	//////////////////////////
+	// Double definition
+
+	//! Vector of 2 double-precision floating-point numbers. 
+	//! From GLSL 4.00.8 specification, section 4.1 Basic Types.
+	typedef detail::tvec2<double>	dvec2;
+
+	//! Vector of 3 double-precision floating-point numbers.
+	//! From GLSL 4.00.8 specification, section 4.1 Basic Types.
+	typedef detail::tvec3<double>	dvec3;
+
+	//! Vector of 4 double-precision floating-point numbers. 
+	//! From GLSL 4.00.8 specification, section 4.1 Basic Types.
+	typedef detail::tvec4<double>	dvec4;
+
+	//! 2 * 2 matrix of double-precision floating-point numbers. 
+	//! From GLSL 4.00.8 specification, section 4.1 Basic Types.
+	typedef detail::tmat2x2<double>	dmat2;
+
+	//! 3 * 3 matrix of double-precision floating-point numbers. 
+	//! From GLSL 4.00.8 specification, section 4.1 Basic Types.
+	typedef detail::tmat3x3<double>	dmat3;
+
+	//! 4 * 4 matrix of double-precision floating-point numbers.
+	//! From GLSL 4.00.8 specification, section 4.1 Basic Types.
+	typedef detail::tmat4x4<double>	dmat4;
+
+	//! 2 * 2 matrix of double-precision floating-point numbers. 
+	//! From GLSL 4.00.8 specification, section 4.1 Basic Types.
+	typedef detail::tmat2x2<double>	dmat2x2;
+
+	//! 2 * 3 matrix of double-precision floating-point numbers. 
+	//! From GLSL 4.00.8 specification, section 4.1 Basic Types.
+	typedef detail::tmat2x3<double>	dmat2x3;
+
+	//! 2 * 4 matrix of double-precision floating-point numbers. 
+	//! From GLSL 4.00.8 specification, section 4.1 Basic Types.
+	typedef detail::tmat2x4<double>	dmat2x4;
+
+	//! 3 * 2 matrix of double-precision floating-point numbers. 
+	//! From GLSL 4.00.8 specification, section 4.1 Basic Types.
+	typedef detail::tmat3x2<double>	dmat3x2;
+
+	//! 3 * 3 matrix of double-precision floating-point numbers. 
+	//! From GLSL 4.00.8 specification, section 4.1 Basic Types.
+	typedef detail::tmat3x3<double>	dmat3x3;
+
+	//! 3 * 4 matrix of double-precision floating-point numbers. 
+	//! From GLSL 4.00.8 specification, section 4.1 Basic Types.
+	typedef detail::tmat3x4<double>	dmat3x4;
+
+	//! 4 * 2 matrix of double-precision floating-point numbers. 
+	//! From GLSL 4.00.8 specification, section 4.1 Basic Types.
+	typedef detail::tmat4x2<double>	dmat4x2;
+
+	//! 4 * 3 matrix of double-precision floating-point numbers. 
+	//! From GLSL 4.00.8 specification, section 4.1 Basic Types.
+	typedef detail::tmat4x3<double>	dmat4x3;
+
+	//! 4 * 4 matrix of double-precision floating-point numbers. 
+	//! From GLSL 4.00.8 specification, section 4.1 Basic Types.
+	typedef detail::tmat4x4<double>	dmat4x4;
+
+}//namespace type
+}//namespace core
+}//namespace glm
+
+#endif//glm_core_type

glm/core/type_float.hpp

@@ -0,0 +1,72 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2010 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2008-08-22
+// Updated : 2010-02-08
+// Licence : This source is under MIT License
+// File    : glm/core/type_float.hpp
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#ifndef glm_core_type_float
+#define glm_core_type_float
+
+#include "type_half.hpp"
+#include "../setup.hpp"
+
+namespace glm
+{
+	namespace detail
+	{
+		GLM_DETAIL_IS_FLOAT(detail::thalf);
+		GLM_DETAIL_IS_FLOAT(float);
+		GLM_DETAIL_IS_FLOAT(double);
+		GLM_DETAIL_IS_FLOAT(long double);
+	}
+	//namespace detail
+
+	namespace core{
+	namespace type{
+
+	namespace precision
+	{
+#ifdef GLM_USE_HALF_SCALAR
+		typedef detail::thalf		lowp_float_t;
+#else//GLM_USE_HALF_SCALAR
+		typedef float				lowp_float_t;
+#endif//GLM_USE_HALF_SCALAR
+		typedef float				mediump_float_t;
+		typedef double				highp_float_t;
+
+		//! Low precision floating-point numbers. 
+		//! There is no garanty on the actual precision.
+		//! From GLSL 1.30.8 specification
+		typedef lowp_float_t		lowp_float;
+		//! Medium precision floating-point numbers.
+		//! There is no garanty on the actual precision.
+		//! From GLSL 1.30.8 specification
+		typedef mediump_float_t		mediump_float;
+		//! High precision floating-point numbers.
+		//! There is no garanty on the actual precision.
+		//! From GLSL 1.30.8 specification
+		typedef highp_float_t		highp_float;
+	}
+	//namespace precision
+
+#ifndef GLM_PRECISION 
+	typedef precision::mediump_float		float_t;
+#elif(GLM_PRECISION & GLM_PRECISION_HIGHP_FLOAT)
+	typedef precision::highp_float			float_t;
+#elif(GLM_PRECISION & GLM_PRECISION_MEDIUMP_FLOAT)
+	typedef precision::mediump_float		float_t;
+#elif(GLM_PRECISION & GLM_PRECISION_LOWP_FLOAT)
+	typedef precision::lowp_float			float_t;
+#else
+	#	pragma message("GLM message: Precisson undefined for float numbers.");
+	typedef precision::mediump_float		float_t;
+#endif//GLM_PRECISION
+
+	}//namespace type
+	}//namespace core
+}//namespace glm
+
+#endif//glm_core_type_float

glm/core/type_gentype.hpp

@@ -0,0 +1,150 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2010 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2008-10-05
+// Updated : 2010-01-26
+// Licence : This source is under MIT License
+// File    : glm/core/type_gentype.hpp
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#ifndef glm_core_type_gentype
+#define glm_core_type_gentype
+
+#include "type_size.hpp"
+
+namespace glm
+{
+	enum profile
+	{
+		nice,
+		fast,
+		simd
+	};
+
+namespace detail
+{
+	template
+	<
+		typename VALTYPE, 
+		template <typename> class TYPE
+	>
+	struct genType
+	{
+	public:
+		enum ctor{null};
+
+		typedef VALTYPE value_type;
+		typedef VALTYPE & value_reference;
+		typedef VALTYPE * value_pointer;
+		typedef VALTYPE const * value_const_pointer;
+		typedef TYPE<bool> bool_type;
+
+		typedef sizeType size_type;
+		static bool is_vector();
+		static bool is_matrix();
+		
+		typedef TYPE<VALTYPE> type;
+		typedef TYPE<VALTYPE> * pointer;
+		typedef TYPE<VALTYPE> const * const_pointer;
+		typedef TYPE<VALTYPE> const * const const_pointer_const;
+		typedef TYPE<VALTYPE> * const pointer_const;
+		typedef TYPE<VALTYPE> & reference;
+		typedef TYPE<VALTYPE> const & const_reference;
+		typedef TYPE<VALTYPE> const & param_type;
+
+		//////////////////////////////////////
+		// Address (Implementation details)
+
+		value_const_pointer value_address() const{return value_pointer(this);}
+		value_pointer value_address(){return value_pointer(this);}
+
+	//protected:
+	//	enum kind
+	//	{
+	//		GEN_TYPE,
+	//		VEC_TYPE,
+	//		MAT_TYPE
+	//	};
+
+	//	typedef typename TYPE::kind kind;
+	};
+
+	template
+	<
+		typename VALTYPE, 
+		template <typename> class TYPE
+	>
+	bool genType<VALTYPE, TYPE>::is_vector()
+	{
+		return true;
+	}
+/*
+	template <typename valTypeT, unsigned int colT, unsigned int rowT, profile proT = nice>
+	class base
+	{
+	public:
+		//////////////////////////////////////
+		// Traits
+
+		typedef sizeType							size_type;
+		typedef valTypeT							value_type;
+
+		typedef base<value_type, colT, rowT>		class_type;
+
+		typedef base<bool, colT, rowT>				bool_type;
+		typedef base<value_type, rowT, 1>			col_type;
+		typedef base<value_type, colT, 1>			row_type;
+		typedef base<value_type, rowT, colT>		transpose_type;
+
+		static size_type							col_size();
+		static size_type							row_size();
+		static size_type							value_size();
+		static bool									is_scalar();
+		static bool									is_vector();
+		static bool									is_matrix();
+
+	private:
+		// Data 
+		col_type value[colT];		
+
+	public:
+		//////////////////////////////////////
+		// Constructors
+		base();
+		base(class_type const & m);
+
+		explicit base(value_type const & x);
+		explicit base(value_type const * const x);
+		explicit base(col_type const * const x);
+
+		//////////////////////////////////////
+		// Conversions
+		template <typename vU, uint cU, uint rU, profile pU>
+		explicit base(base<vU, cU, rU, pU> const & m);
+
+		//////////////////////////////////////
+		// Accesses
+		col_type& operator[](size_type i);
+		col_type const & operator[](size_type i) const;
+
+		//////////////////////////////////////
+		// Unary updatable operators
+		class_type& operator=  (class_type const & x);
+		class_type& operator+= (value_type const & x);
+		class_type& operator+= (class_type const & x);
+		class_type& operator-= (value_type const & x);
+		class_type& operator-= (class_type const & x);
+		class_type& operator*= (value_type const & x);
+		class_type& operator*= (class_type const & x);
+		class_type& operator/= (value_type const & x);
+		class_type& operator/= (class_type const & x);
+		class_type& operator++ ();
+		class_type& operator-- ();
+	};
+*/
+	}//namespace detail
+}//namespace glm
+
+//#include "type_gentype.inl"
+
+#endif//glm_core_type_gentype

glm/core/type_gentype.inl

@@ -0,0 +1,347 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2010 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2008-10-05
+// Updated : 2008-10-05
+// Licence : This source is under MIT License
+// File    : glm/core/type_gentype.inl
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+namespace glm{
+namespace detail{
+
+/////////////////////////////////
+// Static functions
+
+template <typename vT, uint cT, uint rT, profile pT>
+typename base<vT, cT, rT, pT>::size_type base<vT, cT, rT, pT>::col_size()
+{
+	return cT;
+}
+
+template <typename vT, uint cT, uint rT, profile pT>
+typename base<vT, cT, rT, pT>::size_type base<vT, cT, rT, pT>::row_size()
+{
+	return rT;
+}
+
+template <typename vT, uint cT, uint rT, profile pT>
+typename base<vT, cT, rT, pT>::size_type base<vT, cT, rT, pT>::value_size()
+{
+	return rT * cT;
+}
+
+template <typename vT, uint cT, uint rT, profile pT>
+bool base<vT, cT, rT, pT>::is_scalar()
+{
+	return rT == 1 && cT == 1;
+}
+
+template <typename vT, uint cT, uint rT, profile pT>
+bool base<vT, cT, rT, pT>::is_vector()
+{
+	return rT == 1;
+}
+
+template <typename vT, uint cT, uint rT, profile pT>
+bool base<vT, cT, rT, pT>::is_matrix()
+{
+	return rT != 1;
+}
+
+/////////////////////////////////
+// Constructor
+
+template <typename vT, uint cT, uint rT, profile pT>
+base<vT, cT, rT, pT>::base()
+{
+	memset(&this->value, 0, cT * rT * sizeof(vT));
+}
+
+template <typename vT, uint cT, uint rT, profile pT>
+base<vT, cT, rT, pT>::base
+(
+	typename base<vT, cT, rT, pT>::class_type const & m
+)
+{
+	for
+	(
+		typename genType<vT, cT, rT, pT>::size_type i = typename base<vT, cT, rT, pT>::size_type(0);
+		i < base<vT, cT, rT, pT>::col_size();
+		++i
+	)
+	{
+		this->value[i] = m[i];
+	}
+}
+
+template <typename vT, uint cT, uint rT, profile pT>
+base<vT, cT, rT, pT>::base
+(
+	typename base<vT, cT, rT, pT>::value_type const & x
+)
+{
+	if(rT == 1) // vector
+	{
+		for
+		(
+			typename base<vT, cT, rT, pT>::size_type i = typename base<vT, cT, rT, pT>::size_type(0);
+			i < base<vT, cT, rT, pT>::col_size();
+			++i
+		)
+		{
+			this->value[i][rT] = x;
+		}
+	}
+	else // matrix
+	{
+		memset(&this->value, 0, cT * rT * sizeof(vT));
+
+		typename base<vT, cT, rT, pT>::size_type stop = cT < rT ? cT : rT;
+
+		for
+		(
+			typename base<vT, cT, rT, pT>::size_type i = typename base<vT, cT, rT, pT>::size_type(0);
+			i < stop;
+			++i
+		)
+		{
+			this->value[i][i] = x;
+		}
+	}
+}
+
+template <typename vT, uint cT, uint rT, profile pT>
+base<vT, cT, rT, pT>::base
+(
+	typename base<vT, cT, rT, pT>::value_type const * const x
+)
+{
+	memcpy(&this->value, &x.value, cT * rT * sizeof(vT));
+}
+
+template <typename vT, uint cT, uint rT, profile pT>
+base<vT, cT, rT, pT>::base
+(
+	typename base<vT, cT, rT, pT>::col_type const * const x
+)
+{
+	for
+	(
+		typename base<vT, cT, rT, pT>::size_type i = typename base<vT, cT, rT, pT>::size_type(0);
+		i < base<vT, cT, rT, pT>::col_size();
+		++i
+	)
+	{
+		this->value[i] = x[i];
+	}
+}
+
+template <typename vT, uint cT, uint rT, profile pT>
+template <typename vU, uint cU, uint rU, profile pU>
+base<vT, cT, rT, pT>::base
+(
+	base<vU, cU, rU, pU> const & m
+)
+{
+	for
+	(
+		typename base<vT, cT, rT, pT>::size_type i = typename base<vT, cT, rT, pT>::size_type(0);
+		i < base<vT, cT, rT, pT>::col_size();
+		++i
+	)
+	{
+		this->value[i] = base<vT, cT, rT, pT>(m[i]);
+	}
+}
+
+//////////////////////////////////////
+// Accesses
+
+template <typename vT, uint cT, uint rT, profile pT>
+typename base<vT, cT, rT, pT>::col_type& base<vT, cT, rT, pT>::operator[]
+(
+	typename base<vT, cT, rT, pT>::size_type i
+)
+{
+	return this->value[i];
+}
+
+template <typename vT, uint cT, uint rT, profile pT>
+typename base<vT, cT, rT, pT>::col_type const & base<vT, cT, rT, pT>::operator[]
+(
+	typename base<vT, cT, rT, pT>::size_type i
+) const
+{
+	return this->value[i];
+}
+
+//////////////////////////////////////
+// Unary updatable operators
+
+template <typename vT, uint cT, uint rT, profile pT>
+typename base<vT, cT, rT, pT>::class_type& base<vT, cT, rT, pT>::operator= 
+(
+	typename base<vT, cT, rT, pT>::class_type const & x
+)
+{
+	memcpy(&this->value, &x.value, cT * rT * sizeof(vT));
+	return *this;
+}
+
+template <typename vT, uint cT, uint rT, profile pT>
+typename base<vT, cT, rT, pT>::class_type& base<vT, cT, rT, pT>::operator+= 
+(
+	typename base<vT, cT, rT, pT>::value_type const & x
+)
+{
+	typename base<vT, cT, rT, pT>::size_type stop_col = x.col_size();
+	typename base<vT, cT, rT, pT>::size_type stop_row = x.row_size();
+
+	for(typename base<vT, cT, rT, pT>::size_type j = 0; j < stop_col; ++j)
+	for(typename base<vT, cT, rT, pT>::size_type i = 0; i < stop_row; ++i)
+		this->value[j][i] += x;
+
+	return *this;
+}
+
+template <typename vT, uint cT, uint rT, profile pT>
+typename base<vT, cT, rT, pT>::class_type& base<vT, cT, rT, pT>::operator+= 
+(
+	typename base<vT, cT, rT, pT>::class_type const & x
+)
+{
+	typename base<vT, cT, rT, pT>::size_type stop_col = x.col_size();
+	typename base<vT, cT, rT, pT>::size_type stop_row = x.row_size();
+
+	for(typename base<vT, cT, rT, pT>::size_type j = 0; j < stop_col; ++j)
+	for(typename base<vT, cT, rT, pT>::size_type i = 0; i < stop_row; ++i)
+		this->value[j][i] += x[j][i];
+
+	return *this;
+}
+
+template <typename vT, uint cT, uint rT, profile pT>
+typename base<vT, cT, rT, pT>::class_type& base<vT, cT, rT, pT>::operator-= 
+(
+	typename base<vT, cT, rT, pT>::value_type const & x
+)
+{
+	typename base<vT, cT, rT, pT>::size_type stop_col = x.col_size();
+	typename base<vT, cT, rT, pT>::size_type stop_row = x.row_size();
+
+	for(typename base<vT, cT, rT, pT>::size_type j = 0; j < stop_col; ++j)
+	for(typename base<vT, cT, rT, pT>::size_type i = 0; i < stop_row; ++i)
+		this->value[j][i] -= x;
+
+	return *this;
+}
+
+template <typename vT, uint cT, uint rT, profile pT>
+typename base<vT, cT, rT, pT>::class_type& base<vT, cT, rT, pT>::operator-= 
+(
+	typename base<vT, cT, rT, pT>::class_type const & x
+)
+{
+	typename base<vT, cT, rT, pT>::size_type stop_col = x.col_size();
+	typename base<vT, cT, rT, pT>::size_type stop_row = x.row_size();
+
+	for(typename base<vT, cT, rT, pT>::size_type j = 0; j < stop_col; ++j)
+	for(typename base<vT, cT, rT, pT>::size_type i = 0; i < stop_row; ++i)
+		this->value[j][i] -= x[j][i];
+
+	return *this;
+}
+
+template <typename vT, uint cT, uint rT, profile pT>
+typename base<vT, cT, rT, pT>::class_type& base<vT, cT, rT, pT>::operator*= 
+(
+	typename base<vT, cT, rT, pT>::value_type const & x
+)
+{
+	typename base<vT, cT, rT, pT>::size_type stop_col = x.col_size();
+	typename base<vT, cT, rT, pT>::size_type stop_row = x.row_size();
+
+	for(typename base<vT, cT, rT, pT>::size_type j = 0; j < stop_col; ++j)
+	for(typename base<vT, cT, rT, pT>::size_type i = 0; i < stop_row; ++i)
+		this->value[j][i] *= x;
+
+	return *this;
+}
+
+template <typename vT, uint cT, uint rT, profile pT>
+typename base<vT, cT, rT, pT>::class_type& base<vT, cT, rT, pT>::operator*= 
+(
+	typename base<vT, cT, rT, pT>::class_type const & x
+)
+{
+	typename base<vT, cT, rT, pT>::size_type stop_col = x.col_size();
+	typename base<vT, cT, rT, pT>::size_type stop_row = x.row_size();
+
+	for(typename base<vT, cT, rT, pT>::size_type j = 0; j < stop_col; ++j)
+	for(typename base<vT, cT, rT, pT>::size_type i = 0; i < stop_row; ++i)
+		this->value[j][i] *= x[j][i];
+
+	return *this;
+}
+
+template <typename vT, uint cT, uint rT, profile pT>
+typename base<vT, cT, rT, pT>::class_type& base<vT, cT, rT, pT>::operator/= 
+(
+	typename base<vT, cT, rT, pT>::value_type const & x
+)
+{
+	typename base<vT, cT, rT, pT>::size_type stop_col = x.col_size();
+	typename base<vT, cT, rT, pT>::size_type stop_row = x.row_size();
+
+	for(typename base<vT, cT, rT, pT>::size_type j = 0; j < stop_col; ++j)
+	for(typename base<vT, cT, rT, pT>::size_type i = 0; i < stop_row; ++i)
+		this->value[j][i] /= x;
+
+	return *this;
+}
+
+template <typename vT, uint cT, uint rT, profile pT>
+typename base<vT, cT, rT, pT>::class_type& base<vT, cT, rT, pT>::operator/= 
+(
+	typename base<vT, cT, rT, pT>::class_type const & x
+)
+{
+	typename base<vT, cT, rT, pT>::size_type stop_col = x.col_size();
+	typename base<vT, cT, rT, pT>::size_type stop_row = x.row_size();
+
+	for(typename base<vT, cT, rT, pT>::size_type j = 0; j < stop_col; ++j)
+	for(typename base<vT, cT, rT, pT>::size_type i = 0; i < stop_row; ++i)
+		this->value[j][i] /= x[j][i];
+
+	return *this;
+}
+
+template <typename vT, uint cT, uint rT, profile pT>
+typename base<vT, cT, rT, pT>::class_type& base<vT, cT, rT, pT>::operator++ ()
+{
+	typename base<vT, cT, rT, pT>::size_type stop_col = col_size();
+	typename base<vT, cT, rT, pT>::size_type stop_row = row_size();
+
+	for(typename base<vT, cT, rT, pT>::size_type j = 0; j < stop_col; ++j)
+	for(typename base<vT, cT, rT, pT>::size_type i = 0; i < stop_row; ++i)
+		++this->value[j][i];
+
+	return *this;
+}
+
+template <typename vT, uint cT, uint rT, profile pT>
+typename base<vT, cT, rT, pT>::class_type& base<vT, cT, rT, pT>::operator-- ()
+{
+	typename base<vT, cT, rT, pT>::size_type stop_col = col_size();
+	typename base<vT, cT, rT, pT>::size_type stop_row = row_size();
+
+	for(typename base<vT, cT, rT, pT>::size_type j = 0; j < stop_col; ++j)
+	for(typename base<vT, cT, rT, pT>::size_type i = 0; i < stop_row; ++i)
+		--this->value[j][i];
+
+	return *this;
+}
+
+} //namespace detail
+} //namespace glm

glm/core/type_half.hpp

@@ -0,0 +1,85 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2010 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2008-08-17
+// Updated : 2010-02-17
+// Licence : This source is under MIT License
+// File    : glm/core/type_half.hpp
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#ifndef glm_core_type_half
+#define glm_core_type_half
+
+#include <cstdlib>
+
+namespace glm
+{
+	namespace test
+	{
+		bool main_type_half();
+
+	}//namespace test
+
+	namespace detail
+	{
+		typedef short hdata;
+
+		float toFloat32(hdata value);
+		hdata toFloat16(float const & value);
+
+		class thalf
+		{
+		public: 
+			// Constructors
+			thalf();
+			thalf(thalf const & s);
+			
+			template <typename U>
+			explicit thalf(U const & s);
+
+			// Cast
+			//operator float();
+			operator float() const;
+			//operator double();
+			//operator double() const;
+
+			// Unary updatable operators
+			thalf& operator= (thalf const & s);
+			thalf& operator+=(thalf const & s);
+			thalf& operator-=(thalf const & s);
+			thalf& operator*=(thalf const & s);
+			thalf& operator/=(thalf const & s);
+			thalf& operator++();
+			thalf& operator--();
+	
+			float toFloat() const{return toFloat32(data);}
+
+			hdata _data() const{return data;}
+
+		private:
+			hdata data;
+		};
+
+		thalf operator+ (thalf const & s1, thalf const & s2);
+
+		thalf operator- (thalf const & s1, thalf const & s2);
+
+		thalf operator* (thalf const & s1, thalf const & s2);
+
+		thalf operator/ (thalf const & s1, thalf const & s2);
+
+		// Unary constant operators
+		thalf operator- (thalf const & s);
+
+		thalf operator-- (thalf const & s, int);
+
+		thalf operator++ (thalf const & s, int);
+
+	}//namespace detail
+
+
+}//namespace glm
+
+#include "type_half.inl"
+
+#endif//glm_core_type_half

glm/core/type_half.inl

@@ -0,0 +1,357 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2010 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2008-08-17
+// Updated : 2009-11-12
+// Licence : This source is under MIT License
+// File    : glm/core/type_half.inl
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Copyright:
+// This half implementation is based on OpenEXR which is Copyright (c) 2002, 
+// Industrial Light & Magic, a division of Lucas Digital Ltd. LLC
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#include "_detail.hpp"
+
+namespace glm{
+namespace detail
+{
+	inline float overflow()
+	{
+		volatile float f = 1e10;
+
+		for(int i = 0; i < 10; ++i)	
+			f *= f;             // this will overflow before
+								// the for­loop terminates
+		return f;
+	}
+
+	inline float toFloat32(hdata value)
+	{
+		int s = (value >> 15) & 0x00000001;
+		int e = (value >> 10) & 0x0000001f;
+		int m =  value        & 0x000003ff;
+
+		if(e == 0)
+		{
+			if(m == 0)
+			{
+				//
+				// Plus or minus zero
+				//
+
+				detail::uif result;
+				result.i = s << 31;
+				return result.f;
+			}
+			else
+			{
+				//
+				// Denormalized number -- renormalize it
+				//
+
+				while(!(m & 0x00000400))
+				{
+					m <<= 1;
+					e -=  1;
+				}
+
+				e += 1;
+				m &= ~0x00000400;
+			}
+		}
+		else if(e == 31)
+		{
+			if(m == 0)
+			{
+				//
+				// Positive or negative infinity
+				//
+
+				uif result;
+				result.i = (s << 31) | 0x7f800000;
+				return result.f;
+			}
+			else
+			{
+				//
+				// Nan -- preserve sign and significand bits
+				//
+
+				uif result;
+				result.i = (s << 31) | 0x7f800000 | (m << 13);
+				return result.f;
+			}
+		}
+
+		//
+		// Normalized number
+		//
+
+		e = e + (127 - 15);
+		m = m << 13;
+
+		//
+		// Assemble s, e and m.
+		//
+
+		uif Result;
+		Result.i = (s << 31) | (e << 23) | m;
+		return Result.f;
+	}
+
+	inline hdata toFloat16(float const & f)
+	{
+		uif Entry;
+		Entry.f = f;
+		int i = Entry.i;
+
+		//
+		// Our floating point number, f, is represented by the bit
+		// pattern in integer i.  Disassemble that bit pattern into
+		// the sign, s, the exponent, e, and the significand, m.
+		// Shift s into the position where it will go in in the
+		// resulting half number.
+		// Adjust e, accounting for the different exponent bias
+		// of float and half (127 versus 15).
+		//
+
+		register int s =  (i >> 16) & 0x00008000;
+		register int e = ((i >> 23) & 0x000000ff) - (127 - 15);
+		register int m =   i        & 0x007fffff;
+
+		//
+		// Now reassemble s, e and m into a half:
+		//
+
+		if(e <= 0)
+		{
+			if(e < -10)
+			{
+				//
+				// E is less than -10.  The absolute value of f is
+				// less than half_MIN (f may be a small normalized
+				// float, a denormalized float or a zero).
+				//
+				// We convert f to a _halfGTX zero.
+				//
+
+				return 0;
+			}
+
+			//
+			// E is between -10 and 0.  F is a normalized float,
+			// whose magnitude is less than __half_NRM_MIN.
+			//
+			// We convert f to a denormalized _halfGTX.
+			// 
+
+			m = (m | 0x00800000) >> (1 - e);
+
+			//
+			// Round to nearest, round "0.5" up.
+			//
+			// Rounding may cause the significand to overflow and make
+			// our number normalized.  Because of the way a half's bits
+			// are laid out, we don't have to treat this case separately;
+			// the code below will handle it correctly.
+			// 
+
+			if(m & 0x00001000) 
+				m += 0x00002000;
+
+			//
+			// Assemble the _halfGTX from s, e (zero) and m.
+			//
+
+			return hdata(s | (m >> 13));
+		}
+		else if(e == 0xff - (127 - 15))
+		{
+			if(m == 0)
+			{
+				//
+				// F is an infinity; convert f to a half
+				// infinity with the same sign as f.
+				//
+
+				return hdata(s | 0x7c00);
+			}
+			else
+			{
+				//
+				// F is a NAN; we produce a half NAN that preserves
+				// the sign bit and the 10 leftmost bits of the
+				// significand of f, with one exception: If the 10
+				// leftmost bits are all zero, the NAN would turn 
+				// into an infinity, so we have to set at least one
+				// bit in the significand.
+				//
+
+				m >>= 13;
+
+				return hdata(s | 0x7c00 | m | (m == 0));
+			}
+		}
+		else
+		{
+			//
+			// E is greater than zero.  F is a normalized float.
+			// We try to convert f to a normalized half.
+			//
+
+			//
+			// Round to nearest, round "0.5" up
+			//
+
+			if(m &  0x00001000)
+			{
+				m += 0x00002000;
+
+				if(m & 0x00800000)
+				{
+					m =  0;     // overflow in significand,
+					e += 1;     // adjust exponent
+				}
+			}
+
+			//
+			// Handle exponent overflow
+			//
+
+			if (e > 30)
+			{
+				overflow();        // Cause a hardware floating point overflow;
+
+				return hdata(s | 0x7c00);
+				// if this returns, the half becomes an
+			}   // infinity with the same sign as f.
+
+			//
+			// Assemble the half from s, e and m.
+			//
+
+			return hdata(s | (e << 10) | (m >> 13));
+		}
+	}
+
+	inline thalf::thalf() :
+		data(0)
+	{}
+
+	inline thalf::thalf(thalf const & s) :
+		data(s.data)
+	{}
+
+	template <typename U>
+	inline thalf::thalf(U const & s) :
+		data(toFloat16(float(s)))
+	{}
+
+	// Cast
+	//inline half::operator float()
+	//{
+	//	return toFloat();
+	//}
+
+	inline thalf::operator float() const 
+	{
+		return toFloat();
+	}
+
+	//inline half::operator double()
+	//{
+	//	return double(toFloat());
+	//}
+
+	//inline half::operator double() const
+	//{
+	//	return double(toFloat());
+	//}
+
+	// Unary updatable operators
+	inline thalf& thalf::operator= (thalf const & s)
+	{
+		data = s.data;
+		return *this;
+	}
+
+	inline thalf& thalf::operator+=(thalf const & s)
+	{
+		data = toFloat16(toFloat32(data) + toFloat32(s.data));
+		return *this;
+	}
+
+	inline thalf& thalf::operator-=(thalf const & s)
+	{
+		data = toFloat16(toFloat32(data) - toFloat32(s.data));
+		return *this;
+	}
+
+	inline thalf& thalf::operator*=(thalf const & s)
+	{
+		data = toFloat16(toFloat32(data) * toFloat32(s.data));		
+		return *this;
+	}
+
+	inline thalf& thalf::operator/=(thalf const & s)
+	{
+		data = toFloat16(toFloat32(data) / toFloat32(s.data));
+		return *this;
+	}
+
+	inline thalf& thalf::operator++()
+	{
+		float Casted = toFloat32(data);
+		data = toFloat16(++Casted);
+		return *this;
+	}
+
+	inline thalf& thalf::operator--()
+	{
+		float Casted = toFloat32(data);
+		data = toFloat16(--Casted);
+		return *this;
+	}
+
+	//////////////////////////////////////
+	// Binary arithmetic operators
+
+	inline detail::thalf operator+ (detail::thalf const & s1, detail::thalf const & s2)
+	{
+		return detail::thalf(float(s1) + float(s2));
+	}
+
+	inline detail::thalf operator- (detail::thalf const & s1, detail::thalf const & s2)
+	{
+		return detail::thalf(float(s1) - float(s2));
+	}
+
+	inline detail::thalf operator* (detail::thalf const & s1, detail::thalf const & s2)
+	{
+		return detail::thalf(float(s1) * float(s2));
+	}
+
+	inline detail::thalf operator/ (detail::thalf const & s1, detail::thalf const & s2)
+	{
+		return detail::thalf(float(s1) / float(s2));
+	}
+
+	// Unary constant operators
+	inline detail::thalf operator- (detail::thalf const & s)
+	{
+		return detail::thalf(-float(s));
+	}
+
+	inline detail::thalf operator-- (detail::thalf const & s, int)
+	{
+		return detail::thalf(float(s) - 1.0f);
+	}
+
+	inline detail::thalf operator++ (detail::thalf const & s, int)
+	{
+		return detail::thalf(float(s) + 1.0f);
+	}
+
+}//namespace detail
+}//namespace glm

glm/core/type_int.hpp

@@ -0,0 +1,130 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2010 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2008-08-22
+// Updated : 2008-09-17
+// Licence : This source is under MIT License
+// File    : glm/core/type_int.hpp
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#ifndef glm_core_type_int
+#define glm_core_type_int
+
+#include "../setup.hpp"
+#include "_detail.hpp"
+
+namespace glm
+{
+	namespace detail
+	{
+#if defined(GLM_COMPILER) && (GLM_COMPILER & GLM_COMPILER_VC)
+		typedef signed __int64						highp_int_t;
+		typedef unsigned __int64					highp_uint_t;
+#elif(defined(GLM_COMPILER) && (GLM_COMPILER & GLM_COMPILER_GCC))
+		__extension__ typedef signed long long		highp_int_t;
+		__extension__ typedef unsigned long long	highp_uint_t;
+//#	if GLM_MODEL == GLM_MODEL_64
+//		typedef signed long							highp_int_t;
+//		typedef unsigned long						highp_uint_t;
+//#   elif GLM_MODEL == GLM_MODEL_32
+//		__extension__ typedef signed long long		highp_int_t;
+//		__extension__ typedef unsigned long long	highp_uint_t;
+//#	endif//GLM_MODEL
+#elif(defined(GLM_COMPILER_BC))
+		typedef Int64								highp_int_t;
+		typedef Uint64								highp_uint_t;
+#else
+		typedef signed long	long					highp_int_t;
+		typedef unsigned long long					highp_uint_t;
+#endif//GLM_COMPILER
+
+		GLM_DETAIL_IS_INT(signed char);
+		GLM_DETAIL_IS_INT(signed short);
+		GLM_DETAIL_IS_INT(signed int);
+		GLM_DETAIL_IS_INT(signed long);
+		GLM_DETAIL_IS_INT(highp_int_t);
+
+		GLM_DETAIL_IS_UINT(unsigned char);
+		GLM_DETAIL_IS_UINT(unsigned short);
+		GLM_DETAIL_IS_UINT(unsigned int);
+		GLM_DETAIL_IS_UINT(unsigned long);
+		GLM_DETAIL_IS_UINT(highp_uint_t);
+
+		typedef signed short			lowp_int_t;
+		typedef signed int				mediump_int_t;
+		typedef detail::highp_int_t		highp_int_t;
+
+		typedef unsigned short			lowp_uint_t;
+		typedef unsigned int			mediump_uint_t;
+		typedef detail::highp_uint_t	highp_uint_t;
+	}
+	//namespace detail
+
+	namespace core{
+	namespace type{
+
+	namespace precision
+	{
+		//! Low precision signed integer. 
+		//! There is no garanty on the actual precision.
+		//! From GLSL 1.30.8 specification.
+		typedef detail::lowp_int_t				lowp_int;
+		//! Medium precision signed integer. 
+		//! There is no garanty on the actual precision.
+		//! From GLSL 1.30.8 specification.
+		typedef detail::mediump_int_t			mediump_int;
+		//! High precision signed integer.
+		//! There is no garanty on the actual precision.
+		//! From GLSL 1.30.8 specification.
+		typedef detail::highp_int_t				highp_int;
+
+		//! Low precision unsigned integer. 
+		//! There is no garanty on the actual precision.
+		//! From GLSL 1.30.8 specification.
+		typedef detail::lowp_uint_t				lowp_uint;
+		//! Medium precision unsigned integer. 
+		//! There is no garanty on the actual precision.
+		//! From GLSL 1.30.8 specification.
+		typedef detail::mediump_uint_t			mediump_uint;
+		//! High precision unsigned integer. 
+		//! There is no garanty on the actual precision.
+		//! From GLSL 1.30.8 specification.
+		typedef detail::highp_uint_t			highp_uint;
+	}
+	//namespace precision
+
+#ifndef GLM_PRECISION 
+	typedef precision::mediump_int				int_t;
+#elif(GLM_PRECISION & GLM_PRECISION_HIGHP_INT)
+	typedef precision::highp_int				int_t;
+#elif(GLM_PRECISION & GLM_PRECISION_MEDIUMP_INT)
+	typedef precision::mediump_int				int_t;
+#elif(GLM_PRECISION & GLM_PRECISION_LOWP_INT)
+	typedef precision::lowp_int					int_t;
+#else
+	typedef mediump_int							int_t;
+#	pragma message("GLM message: Precisson undefined for signed integer number.");
+#endif//GLM_PRECISION
+
+#ifndef GLM_PRECISION 
+	typedef precision::mediump_uint				uint_t;
+#elif(GLM_PRECISION & GLM_PRECISION_HIGHP_UINT)
+	typedef precision::highp_uint				uint_t;
+#elif(GLM_PRECISION & GLM_PRECISION_MEDIUMP_UINT)
+	typedef precision::mediump_uint				uint_t;
+#elif(GLM_PRECISION & GLM_PRECISION_LOWP_UINT)
+	typedef precision::lowp_uint				uint_t;
+#else
+	typedef precision::mediump_uint				uint_t;
+#	pragma message("GLM message: Precisson undefined for unsigned integer number.");
+#endif//GLM_PRECISION
+
+	//! Unsigned integer. 
+	//! From GLSL 1.30.8 specification section 4.1.3 Integers.
+	typedef uint_t								uint;
+
+	}//namespace type
+	}//namespace core
+}//namespace glm
+
+#endif//glm_core_type_int

glm/core/type_mat.hpp

@@ -0,0 +1,56 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2010 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2010-01-26
+// Updated : 2010-01-26
+// Licence : This source is under MIT License
+// File    : glm/core/type_mat.hpp
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#ifndef glm_core_type_mat
+#define glm_core_type_mat
+
+#include "type_gentype.hpp"
+
+namespace glm{
+namespace detail
+{
+	//template 
+	//<
+	//	typename T, 
+	//	template <typename> class C, 
+	//	template <typename> class R
+	//>
+	//struct matType
+	//{
+	//	enum ctor{null};
+	//	typedef T value_type;
+	//	typedef std::size_t size_type;
+	//	typedef C<T> col_type;
+	//	typedef R<T> row_type;
+	//	static size_type const col_size;
+	//	static size_type const row_size;
+	//};
+
+	//template 
+	//<
+	//	typename T, 
+	//	template <typename> class C, 
+	//	template <typename> class R
+	//>
+	//typename matType<T, C, R>::size_type const 
+	//matType<T, C, R>::col_size = matType<T, C, R>::col_type::value_size;
+
+	//template 
+	//<
+	//	typename T, 
+	//	template <typename> class C, 
+	//	template <typename> class R
+	//>
+	//typename matType<T, C, R>::size_type const 
+	//matType<T, C, R>::row_size = matType<T, C, R>::row_type::value_size;
+
+}//namespace detail
+}//namespace glm
+
+#endif//glm_core_type_mat

glm/core/type_mat2x2.hpp

@@ -0,0 +1,245 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2010 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2005-01-27
+// Updated : 2010-02-11
+// Licence : This source is under MIT License
+// File    : glm/core/type_mat2x2.hpp
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#ifndef glm_core_type_mat2x2
+#define glm_core_type_mat2x2
+
+#include "type_mat.hpp"
+
+namespace glm
+{
+	namespace test
+	{
+		void main_mat2x2();
+	}//namespace test
+
+	namespace detail
+	{
+		template <typename T> struct tvec1;
+		template <typename T> struct tvec2;
+		template <typename T> struct tvec3;
+		template <typename T> struct tvec4;
+		template <typename T> struct tmat2x2;
+		template <typename T> struct tmat2x3;
+		template <typename T> struct tmat2x4;
+		template <typename T> struct tmat3x2;
+		template <typename T> struct tmat3x3;
+		template <typename T> struct tmat3x4;
+		template <typename T> struct tmat4x2;
+		template <typename T> struct tmat4x3;
+		template <typename T> struct tmat4x4;
+
+		//!< \brief Template for 2 * 2 matrix of floating-point numbers.
+		template <typename T> 
+		struct tmat2x2
+		{
+			enum ctor{null};
+			typedef T value_type;
+			typedef std::size_t size_type;
+			typedef tvec2<T> col_type;
+			typedef tvec2<T> row_type;
+			static size_type col_size();
+			static size_type row_size();
+
+			typedef tmat2x2<T> type;
+			typedef tmat2x2<T> transpose_type;
+
+		public:
+			// Implementation detail
+			tmat2x2<T> _inverse() const;
+
+		private:
+			// Data 
+			col_type value[2];
+
+		public:
+			// Constructors
+			tmat2x2();
+			tmat2x2(
+				tmat2x2 const & m);
+
+			explicit tmat2x2(
+				ctor Null);
+			explicit tmat2x2(
+				value_type const & x);
+			explicit tmat2x2(
+				value_type const & x1, value_type const & y1, 
+				value_type const & x2, value_type const & y2);
+			explicit tmat2x2(
+				col_type const & v1, 
+				col_type const & v2);
+
+			// Conversions
+			template <typename U> 
+			explicit tmat2x2(tmat2x2<U> const & m);
+
+			explicit tmat2x2(tmat3x3<T> const & x);
+			explicit tmat2x2(tmat4x4<T> const & x);
+			explicit tmat2x2(tmat2x3<T> const & x);
+			explicit tmat2x2(tmat3x2<T> const & x);
+			explicit tmat2x2(tmat2x4<T> const & x);
+			explicit tmat2x2(tmat4x2<T> const & x);
+			explicit tmat2x2(tmat3x4<T> const & x);
+			explicit tmat2x2(tmat4x3<T> const & x);
+
+			//////////////////////////////////////
+			// Accesses
+
+			col_type & operator[](size_type i);
+			col_type const & operator[](size_type i) const;
+
+			// Unary updatable operators
+			tmat2x2<T> & operator=(tmat2x2<T> const & m);
+			template <typename U> 
+			tmat2x2<T> & operator=(tmat2x2<U> const & m);
+			template <typename U> 
+			tmat2x2<T> & operator+=(U const & s);
+			template <typename U> 
+			tmat2x2<T> & operator+=(tmat2x2<U> const & m);
+			template <typename U> 
+			tmat2x2<T> & operator-=(U const & s);
+			template <typename U> 
+			tmat2x2<T> & operator-=(tmat2x2<U> const & m);
+			template <typename U> 
+			tmat2x2<T> & operator*=(U const & s);
+			template <typename U> 
+			tmat2x2<T> & operator*=(tmat2x2<U> const & m);
+			template <typename U> 
+			tmat2x2<T> & operator/=(U const & s);
+			template <typename U> 
+			tmat2x2<T> & operator/=(tmat2x2<U> const & m);
+			tmat2x2<T> & operator++();
+			tmat2x2<T> & operator--();
+		};
+
+		// Binary operators
+		template <typename T> 
+		tmat2x2<T> operator+ (
+			tmat2x2<T> const & m, 
+			typename tmat2x2<T>::value_type const & s);
+
+		template <typename T> 
+		tmat2x2<T> operator+ (
+			typename tmat2x2<T>::value_type const & s, 
+			tmat2x2<T> const & m);
+
+		template <typename T> 
+		tmat2x2<T> operator+ (
+			tmat2x2<T> const & m1, 
+			tmat2x2<T> const & m2);
+	    
+		template <typename T> 
+		tmat2x2<T> operator- (
+			tmat2x2<T> const & m, 
+			typename tmat2x2<T>::value_type const & s);
+
+		template <typename T> 
+		tmat2x2<T> operator- (
+			typename tmat2x2<T>::value_type const & s, 
+			tmat2x2<T> const & m);
+
+		template <typename T> 
+		tmat2x2<T> operator- (
+			tmat2x2<T> const & m1, 
+			tmat2x2<T> const & m2);
+
+		template <typename T> 
+		tmat2x2<T> operator* (
+			tmat2x2<T> const & m, 
+			typename tmat2x2<T>::value_type const & s);
+
+		template <typename T> 
+		tmat2x2<T> operator* (
+			typename tmat2x2<T>::value_type const & s, 
+			tmat2x2<T> const & m);
+
+		template <typename T> 
+		typename tmat2x2<T>::row_type operator* (
+			tmat2x2<T> const & m, 
+			typename tmat2x2<T>::col_type const & s);
+
+		template <typename T> 
+		typename tmat2x2<T>::col_type operator* (
+			typename tmat2x2<T>::row_type, 
+			tmat2x2<T> const & m);
+
+		template <typename T> 
+		tmat2x2<T> operator* (
+			tmat2x2<T> const & m1, 
+			tmat2x2<T> const & m2);
+
+		template <typename T> 
+		tmat2x2<T> operator/ (
+			tmat2x2<T> const & m, 
+			typename tmat2x2<T>::value_type const & s);
+
+		template <typename T> 
+		tmat2x2<T> operator/ (
+			typename tmat2x2<T>::value_type const & s,
+			tmat2x2<T> const & m);
+
+		template <typename T> 
+		typename tmat2x2<T>::row_type operator/ (
+			tmat2x2<T> const & m, 
+			typename tmat2x2<T>::col_type const & v);
+
+		template <typename T> 
+		typename tmat2x2<T>::col_type operator/ (
+			typename tmat2x2<T>::row_type & v, 
+			tmat2x2<T> const & m);
+
+		template <typename T> 
+		tmat2x2<T> operator/ (
+			tmat2x2<T> const & m1, 
+			tmat2x2<T> const & m2);
+
+		// Unary constant operators
+		template <typename T> 
+		tmat2x2<T> const operator-  (
+			tmat2x2<T> const & m);
+
+		template <typename T> 
+		tmat2x2<T> const operator-- (
+			tmat2x2<T> const & m, 
+			int);
+
+		template <typename T> 
+		tmat2x2<T> const operator++ (
+			tmat2x2<T> const & m, 
+			int);
+
+	} //namespace detail
+
+	namespace core{
+	namespace type{
+
+	namespace precision
+	{
+		//! 2 columns of 2 components matrix of low precision floating-point numbers.
+		//! There is no garanty on the actual precision.
+		//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices and section 4.5 Precision and Precision Qualifiers)
+		typedef detail::tmat2x2<lowp_float>		lowp_mat2x2;
+		//! 2 columns of 2 components matrix of medium precision floating-point numbers. 
+		//! There is no garanty on the actual precision.
+		//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices and section 4.5 Precision and Precision Qualifiers)
+		typedef detail::tmat2x2<mediump_float>	mediump_mat2x2;
+		//! 2 columns of 2 components matrix of high precision floating-point numbers. 
+		//! There is no garanty on the actual precision. 
+		//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices and section 4.5 Precision and Precision Qualifiers)
+		typedef detail::tmat2x2<highp_float>	highp_mat2x2;
+	}
+	//namespace precision
+
+	}//namespace type
+	}//namespace core
+} //namespace glm
+
+#include "type_mat2x2.inl"
+
+#endif //glm_core_type_mat2x2