Updated to GLM 0.9.B

CMakeLists.txt

@@ -0,0 +1,12 @@
+cmake_minimum_required(VERSION 2.6 FATAL_ERROR)
+cmake_policy(VERSION 2.6)
+
+project(glm)
+
+add_definitions(-D_CRT_SECURE_NO_WARNINGS)
+
+add_subdirectory(glm)
+add_subdirectory(doc)
+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

@@ -1,3 +1,17 @@
+body
+{
+	background-color:#fff8f0;
+	width:100%;
+}
+
+table
+{
+	background-color:#ffffff;
+	width:800px;
+	margin-left:auto;
+	margin-right:auto;
+}
+
 table.principale
 {
 	background-color:#ff8000;
@@ -112,7 +126,29 @@ img.menu-img
 
 div.paragraph
 {
-    text-indent:32px;   
+    /*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

doc/doxyfile

@@ -1,4 +1,4 @@
-# Doxyfile 1.6.1
+# Doxyfile 1.6.2
 
 # This file describes the settings to be used by the documentation system
 # doxygen (www.doxygen.org) for a project
@@ -31,7 +31,7 @@ PROJECT_NAME           = GLM
 # This could be handy for archiving the generated documentation or 
 # if some version control system is used.
 
-PROJECT_NUMBER         = "Version 0.8.4"
+PROJECT_NUMBER         = "Version 0.9.A.1"
 
 # The OUTPUT_DIRECTORY tag is used to specify the (relative or absolute) 
 # base path where the generated documentation will be put. 
@@ -397,6 +397,12 @@ HIDE_SCOPE_NAMES       = YES
 
 SHOW_INCLUDE_FILES     = NO
 
+# If the FORCE_LOCAL_INCLUDES tag is set to YES then Doxygen 
+# will list include files with double quotes in the documentation 
+# rather than with sharp brackets.
+
+FORCE_LOCAL_INCLUDES   = NO
+
 # If the INLINE_INFO tag is set to YES (the default) then a tag [inline] 
 # is inserted in the documentation for inline members.
 
@@ -584,7 +590,7 @@ WARN_LOGFILE           =
 # directories like "/usr/src/myproject". Separate the files or directories 
 # with spaces.
 
-INPUT                  = ../../include/glm
+INPUT                  = ../glm
 
 # This tag can be used to specify the character encoding of the source files 
 # that doxygen parses. Internally doxygen uses the UTF-8 encoding, which is 
@@ -810,6 +816,12 @@ HTML_FOOTER            =
 
 HTML_STYLESHEET        = 
 
+# If the HTML_TIMESTAMP tag is set to YES then the footer of each generated HTML 
+# page will contain the date and time when the page was generated. Setting 
+# this to NO can help when comparing the output of multiple runs.
+
+HTML_TIMESTAMP         = NO
+
 # If the HTML_ALIGN_MEMBERS tag is set to YES, the members of classes, 
 # files or namespaces will be aligned in HTML using tables. If set to 
 # NO a bullet list will be used.
@@ -911,7 +923,7 @@ QCH_FILE               =
 # Qt Help Project output. For more information please see 
 # http://doc.trolltech.com/qthelpproject.html#namespace
 
-QHP_NAMESPACE          = 
+QHP_NAMESPACE          = org.doxygen.Project
 
 # The QHP_VIRTUAL_FOLDER tag specifies the namespace to use when generating 
 # Qt Help Project output. For more information please see 
@@ -943,6 +955,23 @@ QHP_SECT_FILTER_ATTRS  =
 
 QHG_LOCATION           = 
 
+# If the GENERATE_ECLIPSEHELP tag is set to YES, additional index files  
+# will be generated, which together with the HTML files, form an Eclipse help  
+# plugin. To install this plugin and make it available under the help contents 
+# menu in Eclipse, the contents of the directory containing the HTML and XML 
+# files needs to be copied into the plugins directory of eclipse. The name of 
+# the directory within the plugins directory should be the same as 
+# the ECLIPSE_DOC_ID value. After copying Eclipse needs to be restarted before
+# the help appears.
+
+GENERATE_ECLIPSEHELP   = NO
+
+# A unique identifier for the eclipse help plugin. When installing the plugin 
+# the directory name containing the HTML and XML files should also have 
+# this name.
+
+ECLIPSE_DOC_ID         = org.doxygen.Project
+
 # The DISABLE_INDEX tag can be used to turn on/off the condensed index at 
 # top of each HTML page. The value NO (the default) enables the index and 
 # the value YES disables it.
@@ -983,15 +1012,26 @@ TREEVIEW_WIDTH         = 250
 
 FORMULA_FONTSIZE       = 10
 
-# When the SEARCHENGINE tag is enable doxygen will generate a search box
+# When the SEARCHENGINE tag is enabled doxygen will generate a search box
 # for the HTML output. The underlying search engine uses javascript 
 # and DHTML and should work on any modern browser. Note that when using
-# HTML help (GENERATE_HTMLHELP) or Qt help (GENERATE_QHP) 
+# HTML help (GENERATE_HTMLHELP), Qt help (GENERATE_QHP), or docsets
-# there is already a search function so this one should typically 
+# (GENERATE_DOCSET) there is already a search function so this one should 
-# be disabled.
+# typically be disabled. For large projects the javascript based search engine 
+# can be slow, then enabling SERVER_BASED_SEARCH may provide a better solution.
 
 SEARCHENGINE           = NO
 
+# When the SERVER_BASED_SEARCH tag is enabled the search engine will be
+# implemented using a PHP enabled web server instead of at the web client
+# using Javascript. Doxygen will generate the search PHP script and index 
+# file to put on the web server. The advantage of the server
+# based approach is that it scales better to large projects and allows
+# full text search. The disadvances is that it is more difficult to setup 
+# and does not have live searching capabilities.
+
+SERVER_BASED_SEARCH    = NO
+
 #---------------------------------------------------------------------------
 # configuration options related to the LaTeX output
 #---------------------------------------------------------------------------
@@ -1009,6 +1049,9 @@ LATEX_OUTPUT           = latex
 
 # The LATEX_CMD_NAME tag can be used to specify the LaTeX command name to be 
 # invoked. If left blank `latex' will be used as the default command name. 
+# Note that when enabling USE_PDFLATEX this option is only used for 
+# generating bitmaps for formulas in the HTML output, but not in the 
+# Makefile that is written to the output directory.
 
 LATEX_CMD_NAME         = latex
 

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

@@ -1,5 +1,5 @@
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-// OpenGL Mathematics Copyright (c) 2005 - 2009 G-Truc Creation (www.g-truc.net)
+// OpenGL Mathematics Copyright (c) 2005 - 2010 G-Truc Creation (www.g-truc.net)
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 // Created : 2008-07-24
 // Updated : 2008-08-31

glm/core/_swizzle.hpp

@@ -1,5 +1,5 @@
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-// OpenGL Mathematics Copyright (c) 2005 - 2009 G-Truc Creation (www.g-truc.net)
+// OpenGL Mathematics Copyright (c) 2005 - 2010 G-Truc Creation (www.g-truc.net)
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 // Created : 2006-04-20
 // Updated : 2008-08-22

glm/core/_swizzle.inl

@@ -1,5 +1,5 @@
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-// OpenGL Mathematics Copyright (c) 2005 - 2009 G-Truc Creation (www.g-truc.net)
+// OpenGL Mathematics Copyright (c) 2005 - 2010 G-Truc Creation (www.g-truc.net)
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 // Created : 2006-04-27
 // Updated : 2006-04-27

glm/core/func_common.hpp

@@ -1,10 +1,10 @@
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-// OpenGL Mathematics Copyright (c) 2005 - 2009 G-Truc Creation (www.g-truc.net)
+// OpenGL Mathematics Copyright (c) 2005 - 2010 G-Truc Creation (www.g-truc.net)
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 // Created : 2008-03-08
-// Updated : 2008-03-08
+// Updated : 2010-01-26
 // Licence : This source is under MIT License
-// File    : glm/core/func_common.h
+// File    : glm/core/func_common.hpp
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 #ifndef glm_core_func_common
@@ -72,10 +72,18 @@ namespace glm
 	//! 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 genTypeT, typename genTypeU> 
+    template <typename genType> 
-	genTypeT mod(
+	genType mod(
-		genTypeT const & x, 
+		genType const & x, 
-		genTypeU const & y);
+		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
@@ -89,26 +97,42 @@ namespace glm
 
     //! Returns y if y < x; otherwise, it returns x.
 	//! (From GLSL 1.30.08 specification, section 8.3)
-	template <typename genUIFTypeT, typename genUIFTypeU> 
+	template <typename genType> 
-	genUIFTypeT min(
+	genType min(
-		genUIFTypeT const & x, 
+		genType const & x, 
-		genUIFTypeU const & y);
+		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 genUIFTypeT, typename genUIFTypeU> 
+	template <typename genType> 
-	genUIFTypeT max(
+	genType max(
-		genUIFTypeT const & x, 
+		genType const & x, 
-		genUIFTypeU const & y);
+		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 genUIFTypeT, typename genUIFTypeU> 
+	template <typename genType> 
-	genUIFTypeT clamp(
+	genType clamp(
-		genUIFTypeT const & x, 
+		genType const & x, 
-		genUIFTypeU const & minVal, 
+		genType const & minVal, 
-		genUIFTypeU const & maxVal); 
+		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 
@@ -139,8 +163,15 @@ namespace glm
 
 	//! Returns 0.0 if x < edge, otherwise it returns 1.0.
 	//! (From GLSL 1.30.08 specification, section 8.3)
-	template <typename genTypeT, typename genTypeU> 
+	template <typename genType> 
-	genTypeU step(genTypeT const & edge, genTypeU const & x);
+	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
@@ -152,8 +183,17 @@ namespace glm
 	//! return t * t * (3 – 2 * t);
 	//! Results are undefined if edge0 >= edge1.
 	//! (From GLSL 1.30.08 specification, section 8.3)
-	template <typename genTypeT, typename genTypeU> 
+	template <typename genType> 
-	genTypeU smoothstep(genTypeT const & edge0, genTypeT const & edge1, genTypeU const & x);
+	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
@@ -173,6 +213,55 @@ namespace glm
 	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

glm/core/func_exponential.hpp

@@ -1,10 +1,10 @@
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-// OpenGL Mathematics Copyright (c) 2005 - 2009 G-Truc Creation (www.g-truc.net)
+// OpenGL Mathematics Copyright (c) 2005 - 2010 G-Truc Creation (www.g-truc.net)
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 // Created : 2008-08-08
-// Updated : 2008-09-06
+// Updated : 2010-02-04
 // Licence : This source is under MIT License
-// File    : glm/core/func_exponential.h
+// File    : glm/core/func_exponential.hpp
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 #ifndef glm_core_func_exponential

glm/core/func_exponential.inl

@@ -1,8 +1,8 @@
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-// OpenGL Mathematics Copyright (c) 2005 - 2009 G-Truc Creation (www.g-truc.net)
+// OpenGL Mathematics Copyright (c) 2005 - 2010 G-Truc Creation (www.g-truc.net)
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 // Created : 2008-08-03
-// Updated : 2008-09-06
+// Updated : 2010-02-04
 // Licence : This source is under MIT License
 // File    : glm/core/func_exponential.inl
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -26,39 +26,39 @@ namespace glm
         return ::std::pow(x, y);
     }
 
-    template <typename valType>
+    template <typename T>
-    inline detail::tvec2<valType> pow
+    inline detail::tvec2<T> pow
 	(
-		detail::tvec2<valType> const & x, 
+		detail::tvec2<T> const & x, 
-		detail::tvec2<valType> const & y
+		detail::tvec2<T> const & y
 	)
     {
-        return detail::tvec2<valType>(
+        return detail::tvec2<T>(
             pow(x.x, y.x),
             pow(x.y, y.y));
     }
 
-    template <typename valType>
+    template <typename T>
-    inline detail::tvec3<valType> pow
+    inline detail::tvec3<T> pow
 	(
-		detail::tvec3<valType> const & x, 
+		detail::tvec3<T> const & x, 
-		detail::tvec3<valType> const & y
+		detail::tvec3<T> const & y
 	)
     {
-        return detail::tvec3<valType>(
+        return detail::tvec3<T>(
             pow(x.x, y.x),
             pow(x.y, y.y),
             pow(x.z, y.z));
     }
 
-    template <typename valType>
+    template <typename T>
-    inline detail::tvec4<valType> pow
+    inline detail::tvec4<T> pow
 	(
-		detail::tvec4<valType> const & x, 
+		detail::tvec4<T> const & x, 
-		detail::tvec4<valType> const & y
+		detail::tvec4<T> const & y
 	)
     {
-        return detail::tvec4<valType>(
+        return detail::tvec4<T>(
             pow(x.x, y.x),
             pow(x.y, y.y),
             pow(x.z, y.z),
@@ -77,36 +77,36 @@ namespace glm
         return ::std::exp(x);
     }
 
-    template <typename valType>
+    template <typename T>
-    inline detail::tvec2<valType> exp
+    inline detail::tvec2<T> exp
 	(
-		detail::tvec2<valType> const & x
+		detail::tvec2<T> const & x
 	)
     {
-        return detail::tvec2<valType>(
+        return detail::tvec2<T>(
             exp(x.x),
             exp(x.y));
     }
 
-    template <typename valType>
+    template <typename T>
-    inline detail::tvec3<valType> exp
+    inline detail::tvec3<T> exp
 	(
-		detail::tvec3<valType> const & x
+		detail::tvec3<T> const & x
 	)
     {
-        return detail::tvec3<valType>(
+        return detail::tvec3<T>(
             exp(x.x),
             exp(x.y),
             exp(x.z));
     }
 
-    template <typename valType>
+    template <typename T>
-    inline detail::tvec4<valType> exp
+    inline detail::tvec4<T> exp
 	(
-		detail::tvec4<valType> const & x
+		detail::tvec4<T> const & x
 	)
     {
-        return detail::tvec4<valType>(
+        return detail::tvec4<T>(
             exp(x.x),
             exp(x.y),
             exp(x.z),
@@ -125,36 +125,36 @@ namespace glm
         return ::std::log(x);
     }
 
-    template <typename valType>
+    template <typename T>
-    inline detail::tvec2<valType> log
+    inline detail::tvec2<T> log
 	(
-		detail::tvec2<valType> const & x
+		detail::tvec2<T> const & x
 	)
     {
-        return detail::tvec2<valType>(
+        return detail::tvec2<T>(
             log(x.x),
             log(x.y));
     }
 
-    template <typename valType>
+    template <typename T>
-    inline detail::tvec3<valType> log
+    inline detail::tvec3<T> log
 	(
-		detail::tvec3<valType> const & x
+		detail::tvec3<T> const & x
 	)
     {
-        return detail::tvec3<valType>(
+        return detail::tvec3<T>(
             log(x.x),
             log(x.y),
             log(x.z));
     }
 
-    template <typename valType>
+    template <typename T>
-    inline detail::tvec4<valType> log
+    inline detail::tvec4<T> log
 	(
-		detail::tvec4<valType> const & x
+		detail::tvec4<T> const & x
 	)
     {
-        return detail::tvec4<valType>(
+        return detail::tvec4<T>(
             log(x.x),
             log(x.y),
             log(x.z),
@@ -173,36 +173,36 @@ namespace glm
         return ::std::exp(genType(0.69314718055994530941723212145818) * x);
     }
 
-    template <typename valType>
+    template <typename T>
-    inline detail::tvec2<valType> exp2
+    inline detail::tvec2<T> exp2
 	(
-		detail::tvec2<valType> const & x
+		detail::tvec2<T> const & x
 	)
     {
-        return detail::tvec2<valType>(
+        return detail::tvec2<T>(
             exp2(x.x),
             exp2(x.y));
     }
 
-    template <typename valType>
+    template <typename T>
-    inline detail::tvec3<valType> exp2
+    inline detail::tvec3<T> exp2
 	(
-		detail::tvec3<valType> const & x
+		detail::tvec3<T> const & x
 	)
     {
-        return detail::tvec3<valType>(
+        return detail::tvec3<T>(
             exp2(x.x),
             exp2(x.y),
             exp2(x.z));
     }
 
-    template <typename valType>
+    template <typename T>
-    inline detail::tvec4<valType> exp2
+    inline detail::tvec4<T> exp2
 	(
-		detail::tvec4<valType> const & x
+		detail::tvec4<T> const & x
 	)
     {
-        return detail::tvec4<valType>(
+        return detail::tvec4<T>(
             exp2(x.x),
             exp2(x.y),
             exp2(x.z),
@@ -221,36 +221,36 @@ namespace glm
         return ::std::log(x) / genType(0.69314718055994530941723212145818);
     }
 
-    template <typename valType>
+    template <typename T>
-    inline detail::tvec2<valType> log2
+    inline detail::tvec2<T> log2
 	(
-		const detail::tvec2<valType>& x
+		detail::tvec2<T> const & x
 	)
     {
-        return detail::tvec2<valType>(
+        return detail::tvec2<T>(
             log2(x.x),
             log2(x.y));
     }
 
-    template <typename valType>
+    template <typename T>
-    inline detail::tvec3<valType> log2
+    inline detail::tvec3<T> log2
 	(
-		const detail::tvec3<valType>& x
+		detail::tvec3<T> const & x
 	)
     {
-        return detail::tvec3<valType>(
+        return detail::tvec3<T>(
             log2(x.x),
             log2(x.y),
             log2(x.z));
     }
 
-    template <typename valType>
+    template <typename T>
-    inline detail::tvec4<valType> log2
+    inline detail::tvec4<T> log2
 	(
-		detail::tvec4<valType> const & x
+		detail::tvec4<T> const & x
 	)
     {
-        return detail::tvec4<valType>(
+        return detail::tvec4<T>(
             log2(x.x),
             log2(x.y),
             log2(x.z),
@@ -269,36 +269,36 @@ namespace glm
         return genType(::std::sqrt(double(x)));
     }
 
-    template <typename valType>
+    template <typename T>
-    inline detail::tvec2<valType> sqrt
+    inline detail::tvec2<T> sqrt
 	(
-		detail::tvec2<valType> const & x
+		detail::tvec2<T> const & x
 	)
     {
-        return detail::tvec2<valType>(
+        return detail::tvec2<T>(
             sqrt(x.x),
             sqrt(x.y));
     }
 
-    template <typename valType>
+    template <typename T>
-    inline detail::tvec3<valType> sqrt
+    inline detail::tvec3<T> sqrt
 	(
-		detail::tvec3<valType> const & x
+		detail::tvec3<T> const & x
 	)
     {
-        return detail::tvec3<valType>(
+        return detail::tvec3<T>(
             sqrt(x.x),
             sqrt(x.y),
             sqrt(x.z));
     }
 
-    template <typename valType>
+    template <typename T>
-    inline detail::tvec4<valType> sqrt
+    inline detail::tvec4<T> sqrt
 	(
-		detail::tvec4<valType> const & x
+		detail::tvec4<T> const & x
 	)
     {
-        return detail::tvec4<valType>(
+        return detail::tvec4<T>(
             sqrt(x.x),
             sqrt(x.y),
             sqrt(x.z),
@@ -316,36 +316,36 @@ namespace glm
         return genType(1) / ::std::sqrt(x);
     }
 
-    template <typename valType>
+    template <typename T>
-    inline detail::tvec2<valType> inversesqrt
+    inline detail::tvec2<T> inversesqrt
 	(
-		detail::tvec2<valType> const & x
+		detail::tvec2<T> const & x
 	)
     {
-        return detail::tvec2<valType>(
+        return detail::tvec2<T>(
             inversesqrt(x.x),
             inversesqrt(x.y));
     }
 
-    template <typename valType>
+    template <typename T>
-    inline detail::tvec3<valType> inversesqrt
+    inline detail::tvec3<T> inversesqrt
 	(
-		detail::tvec3<valType> const & x
+		detail::tvec3<T> const & x
 	)
     {
-        return detail::tvec3<valType>(
+        return detail::tvec3<T>(
             inversesqrt(x.x),
             inversesqrt(x.y),
             inversesqrt(x.z));
     }
 
-    template <typename valType>
+    template <typename T>
-    inline detail::tvec4<valType> inversesqrt
+    inline detail::tvec4<T> inversesqrt
 	(
-		detail::tvec4<valType> const & x
+		detail::tvec4<T> const & x
 	)
     {
-        return detail::tvec4<valType>(
+        return detail::tvec4<T>(
             inversesqrt(x.x),
             inversesqrt(x.y),
             inversesqrt(x.z),

glm/core/func_geometric.hpp

@@ -1,10 +1,10 @@
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-// OpenGL Mathematics Copyright (c) 2005 - 2009 G-Truc Creation (www.g-truc.net)
+// OpenGL Mathematics Copyright (c) 2005 - 2010 G-Truc Creation (www.g-truc.net)
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 // Created : 2008-08-03
-// Updated : 2008-09-08
+// Updated : 2010-02-04
 // Licence : This source is under MIT License
-// File    : glm/core/func_geometric.h
+// File    : glm/core/func_geometric.hpp
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 #ifndef glm_core_func_geometric
@@ -24,45 +24,61 @@ namespace glm
 	//! 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); 
+	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);
+	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);
+	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 valType> 
+    template <typename T> 
-	detail::tvec3<valType> cross(detail::tvec3<valType> const & x, detail::tvec3<valType> const & y);
+	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);
+	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);
+	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);
+	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);
+	genType refract(
+		genType const & I, 
+		genType const & N, 
+		typename genType::value_type const & eta);
 
 	}//namespace geometric
 	}//namespace function

glm/core/func_geometric.inl

@@ -1,8 +1,8 @@
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-// OpenGL Mathematics Copyright (c) 2005 - 2009 G-Truc Creation (www.g-truc.net)
+// OpenGL Mathematics Copyright (c) 2005 - 2010 G-Truc Creation (www.g-truc.net)
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 // Created : 2008-08-03
-// Updated : 2008-09-08
+// Updated : 2010-02-04
 // Licence : This source is under MIT License
 // File    : glm/core/func_geometric.inl
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -26,39 +26,39 @@ namespace glm
         return sqrt(sqr);
     }
 
-	template <typename valType>
+	template <typename T>
-	inline typename detail::tvec2<valType>::value_type length
+	inline typename detail::tvec2<T>::value_type length
 	(
-		detail::tvec2<valType> const & x
+		detail::tvec2<T> const & v
 	)
     {
-		GLM_STATIC_ASSERT(detail::type<valType>::is_float);
+		GLM_STATIC_ASSERT(detail::type<T>::is_float);
 
-        valType sqr = x.x * x.x + x.y * x.y;
+        typename detail::tvec2<T>::value_type sqr = v.x * v.x + v.y * v.y;
         return sqrt(sqr);
     }
 
-    template <typename valType>
+    template <typename T>
-    inline typename detail::tvec3<valType>::value_type length
+    inline typename detail::tvec3<T>::value_type length
 	(
-		detail::tvec3<valType> const & x
+		detail::tvec3<T> const & v
 	)
     {
-		GLM_STATIC_ASSERT(detail::type<valType>::is_float);
+		GLM_STATIC_ASSERT(detail::type<T>::is_float);
 
-        valType sqr = x.x * x.x + x.y * x.y + x.z * x.z;
+        typename detail::tvec3<T>::value_type sqr = v.x * v.x + v.y * v.y + v.z * v.z;
         return sqrt(sqr);
     }
 
-    template <typename valType>
+    template <typename T>
-    inline typename detail::tvec4<valType>::value_type length
+    inline typename detail::tvec4<T>::value_type length
 	(
-		detail::tvec4<valType> const & x
+		detail::tvec4<T> const & v
 	)
     {
-		GLM_STATIC_ASSERT(detail::type<valType>::is_float);
+		GLM_STATIC_ASSERT(detail::type<T>::is_float);
 
-        valType sqr = x.x * x.x + x.y * x.y + x.z * x.z + x.w * x.w;
+        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);
     }
 
@@ -75,38 +75,38 @@ namespace glm
 		return length(p1 - p0);
     }
  
-	template <typename valType>
+	template <typename T>
-	inline typename detail::tvec2<valType>::value_type distance
+	inline typename detail::tvec2<T>::value_type distance
 	(
-		detail::tvec2<valType> const & p0,
+		detail::tvec2<T> const & p0,
-		detail::tvec2<valType> const & p1
+		detail::tvec2<T> const & p1
 	)
     {
-		GLM_STATIC_ASSERT(detail::type<valType>::is_float);
+		GLM_STATIC_ASSERT(detail::type<T>::is_float);
 
         return length(p1 - p0);
     }
 
-    template <typename valType>
+    template <typename T>
-    inline typename detail::tvec3<valType>::value_type distance
+    inline typename detail::tvec3<T>::value_type distance
 	(
-		detail::tvec3<valType> const & p0,
+		detail::tvec3<T> const & p0,
-		detail::tvec3<valType> const & p1
+		detail::tvec3<T> const & p1
 	)
     {
-		GLM_STATIC_ASSERT(detail::type<valType>::is_float);
+		GLM_STATIC_ASSERT(detail::type<T>::is_float);
 
 		return length(p1 - p0);
     }
 
-    template <typename valType>
+    template <typename T>
-    inline typename detail::tvec4<valType>::value_type distance
+    inline typename detail::tvec4<T>::value_type distance
 	(
-		detail::tvec4<valType> const & p0,
+		detail::tvec4<T> const & p0,
-		detail::tvec4<valType> const & p1
+		detail::tvec4<T> const & p1
 	)
     {
-		GLM_STATIC_ASSERT(detail::type<valType>::is_float);
+		GLM_STATIC_ASSERT(detail::type<T>::is_float);
 
 		return length(p1 - p0);
     }
@@ -124,26 +124,26 @@ namespace glm
 		return x * y;
 	}
 
-    template <typename valType>
+    template <typename T>
-	inline typename detail::tvec2<valType>::value_type dot
+	inline typename detail::tvec2<T>::value_type dot
 	(
-		detail::tvec2<valType> const & x, 
+		detail::tvec2<T> const & x, 
-		detail::tvec2<valType> const & y
+		detail::tvec2<T> const & y
 	)
     {
-		GLM_STATIC_ASSERT(detail::type<valType>::is_float);
+		GLM_STATIC_ASSERT(detail::type<T>::is_float);
 
 		return x.x * y.x + x.y * y.y;
     }
 
-    template <typename valType>
+    template <typename T>
-    inline valType dot
+    inline T dot
 	(
-		detail::tvec3<valType> const & x, 
+		detail::tvec3<T> const & x, 
-		detail::tvec3<valType> const & y
+		detail::tvec3<T> const & y
 	)
     {
-		GLM_STATIC_ASSERT(detail::type<valType>::is_float);
+		GLM_STATIC_ASSERT(detail::type<T>::is_float);
 
 		return x.x * y.x + x.y * y.y + x.z * y.z;
     }
@@ -164,29 +164,29 @@ namespace glm
 	    return Result;
     }
 */
-    template <typename valType>
+    template <typename T>
-    inline valType dot
+    inline T dot
 	(
-		detail::tvec4<valType> const & x, 
+		detail::tvec4<T> const & x, 
-		detail::tvec4<valType> const & y
+		detail::tvec4<T> const & y
 	)
     {
-		GLM_STATIC_ASSERT(detail::type<valType>::is_float);
+		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 valType>
+    template <typename T>
-    inline detail::tvec3<valType> cross
+    inline detail::tvec3<T> cross
 	(
-		detail::tvec3<valType> const & x, 
+		detail::tvec3<T> const & x, 
-		detail::tvec3<valType> const & y
+		detail::tvec3<T> const & y
 	)
     {
-		GLM_STATIC_ASSERT(detail::type<valType>::is_float);
+		GLM_STATIC_ASSERT(detail::type<T>::is_float);
 
-        return detail::tvec3<valType>(
+        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);
@@ -205,39 +205,39 @@ namespace glm
     }
 
     // According to issue 10 GLSL 1.10 specification, if length(x) == 0 then result is undefine and generate an error
-    template <typename valType>
+    template <typename T>
-    inline detail::tvec2<valType> normalize
+    inline detail::tvec2<T> normalize
 	(
-		detail::tvec2<valType> const & x
+		detail::tvec2<T> const & x
 	)
     {
-		GLM_STATIC_ASSERT(detail::type<valType>::is_float);
+		GLM_STATIC_ASSERT(detail::type<T>::is_float);
 		
-		valType sqr = x.x * x.x + x.y * x.y;
+		typename detail::tvec2<T>::value_type sqr = x.x * x.x + x.y * x.y;
 	    return x * inversesqrt(sqr);
     }
 
-    template <typename valType>
+    template <typename T>
-    inline detail::tvec3<valType> normalize
+    inline detail::tvec3<T> normalize
 	(
-		detail::tvec3<valType> const & x
+		detail::tvec3<T> const & x
 	)
     {
-        GLM_STATIC_ASSERT(detail::type<valType>::is_float);
+        GLM_STATIC_ASSERT(detail::type<T>::is_float);
 
-		valType sqr = x.x * x.x + x.y * x.y + x.z * x.z;
+		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 valType>
+    template <typename T>
-    inline detail::tvec4<valType> normalize
+    inline detail::tvec4<T> normalize
 	(
-		detail::tvec4<valType> const & x
+		detail::tvec4<T> const & x
 	)
     {
-        GLM_STATIC_ASSERT(detail::type<valType>::is_float);
+        GLM_STATIC_ASSERT(detail::type<T>::is_float);
 		
-		valType sqr = x.x * x.x + x.y * x.y + x.z * x.z + x.w * x.w;
+		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);
     }
 

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 % (detail::highp_uint_t(1) << detail::highp_uint_t(32)));
+			Carry = (Value64 % (detail::highp_uint_t(1) << detail::highp_uint_t(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) << detail::highp_int_t(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 & ((detail::highp_uint_t(1) << detail::highp_uint_t(32)) - detail::highp_uint_t(1)));
+			lsb = *(genUType*)&(Value64 >> detail::highp_uint_t(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 & ((detail::highp_uint_t(1) << detail::highp_uint_t(32)) - detail::highp_uint_t(1)));
+			lsb = *(genIType*)&(Value64 >> detail::highp_uint_t(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);
+			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);
+			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(Base[0], Insert[0], Offset, Bits),
+				bitfieldInsert(Base[1], Insert[1], Offset, Bits));
+		}
+
+		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(Base[0], Insert[0], Offset, Bits),
+				bitfieldInsert(Base[1], Insert[1], Offset, Bits),
+				bitfieldInsert(Base[2], Insert[2], Offset, Bits));
+		}
+
+		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(Base[0], Insert[0], Offset, Bits),
+				bitfieldInsert(Base[1], Insert[1], Offset, Bits),
+				bitfieldInsert(Base[2], Insert[2], Offset, Bits),
+				bitfieldInsert(Base[3], Insert[3], Offset, Bits));
+		}
+
+		// 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 |= (genIUType(1) << (sizeof(genIUType) * std::size_t(8)) - genIUType(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 genIUType>
+		inline int findLSB
+		(
+			genIUType const & Value
+		)
+		{
+			GLM_STATIC_ASSERT(std::numeric_limits<genIUType>::is_integer);
+			if(Value == 0)
+				return -1;
+
+			genIUType Bit;
+			for(Bit = genIUType(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 genIUType>
+		inline int findMSB
+		(
+			genIUType const & Value
+		)
+		{
+			GLM_STATIC_ASSERT(std::numeric_limits<genIUType>::is_integer);
+			if(Value == 0)
+				return -1;
+
+			genIUType bit = genIUType(-1);
+			for(genIUType 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

@@ -1,10 +1,10 @@
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-// OpenGL Mathematics Copyright (c) 2005 - 2009 G-Truc Creation (www.g-truc.net)
+// OpenGL Mathematics Copyright (c) 2005 - 2010 G-Truc Creation (www.g-truc.net)
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 // Created : 2008-08-03
-// Updated : 2008-08-03
+// Updated : 2010-02-04
 // Licence : This source is under MIT License
-// File    : glm/core/func_matrix.h
+// File    : glm/core/func_matrix.hpp
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 #ifndef glm_core_func_matrix
@@ -25,31 +25,60 @@ namespace glm
 	//! 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);
+	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);
+	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);
+	typename matType::transpose_type transpose(
+		matType const & x);
 	
-	//! Return the determinant of a matrix. 
+	//! Return the determinant of a mat2 matrix. 
-	//! (From GLSL 1.50.09 specification, section 8.5). genType: mat2, mat3, mat4.
+	//! (From GLSL 1.50.09 specification, section 8.5)..
-	template <typename genType> 
+	template <typename T> 
-	typename genType::value_type determinant(
+	typename detail::tmat2x2<T>::value_type determinant(
-		genType const & m);
+		detail::tmat2x2<T> const & m);
 
-	//! Return the inverse of a matrix. 
+	//! Return the determinant of a mat3 matrix. 
-	//! (From GLSL 1.40.07 specification, section 8.5). genType: mat2, mat3, mat4.
+	//! (From GLSL 1.50.09 specification, section 8.5).
-	template <typename genType> 
+	template <typename T> 
-	genType inverse(
+	typename detail::tmat3x3<T>::value_type determinant(
-		genType const & m);
+		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

glm/core/func_matrix.inl

@@ -1,8 +1,8 @@
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-// OpenGL Mathematics Copyright (c) 2005 - 2009 G-Truc Creation (www.g-truc.net)
+// OpenGL Mathematics Copyright (c) 2005 - 2010 G-Truc Creation (www.g-truc.net)
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 // Created : 2008-03-08
-// Updated : 2008-03-08
+// Updated : 2010-02-04
 // Licence : This source is under MIT License
 // File    : glm/core/func_matrix.inl
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -14,142 +14,6 @@ namespace glm
 	namespace matrix{
 
     // matrixCompMult
-/*
-    template <typename valType>
-    inline detail::tmat2x2<valType> matrixCompMult
-	(
-		detail::tmat2x2<valType> const & x, 
-		detail::tmat2x2<valType> const & y
-	)
-    {
-		GLM_STATIC_ASSERT(detail::type<valType>::is_float);
-
-        detail::tmat2x2<valType> result;
-		for(std::size_t i = 0; i < detail::tmat2x2<valType>::col_size(); ++i)
-			result[i] = x[i] * y[i];
-        return result;
-    }
-
-    template <typename valType>
-	inline detail::tmat3x3<valType> matrixCompMult
-	(
-		detail::tmat3x3<valType> const & x, 
-		detail::tmat3x3<valType> const & y
-	)
-    {
-		GLM_STATIC_ASSERT(detail::type<valType>::is_float);
-
-        detail::tmat3x3<valType> result;
-		for(std::size_t i = 0; i < detail::tmat3x3<valType>::col_size(); ++i)
-			result[i] = x[i] * y[i];
-        return result;
-    }
-
-    template <typename valType>
-    inline detail::tmat4x4<valType> matrixCompMult
-	(
-		detail::tmat4x4<valType> const & x, 
-		detail::tmat4x4<valType> const & y
-	)
-    {
-		GLM_STATIC_ASSERT(detail::type<valType>::is_float);
-
-        detail::tmat4x4<valType> result;
-		for(std::size_t i = 0; i < detail::tmat4x4<valType>::col_size(); ++i)
-			result[i] = x[i] * y[i];
-        return result;
-    }
-
-    template <typename valType>
-    inline detail::tmat2x3<valType> matrixCompMult
-	(
-		detail::tmat2x3<valType> const & x, 
-		detail::tmat2x3<valType> const & y
-	)
-    {
-		GLM_STATIC_ASSERT(detail::type<valType>::is_float);
-
-        detail::tmat2x3<valType> result;
-		for(std::size_t i = 0; i < detail::tmat2x3<valType>::col_size(); ++i)
-			result[i] = x[i] * y[i];
-        return result;
-    }
-
-    template <typename valType>
-    inline detail::tmat3x2<valType> matrixCompMult
-	(
-		detail::tmat3x2<valType> const & x, 
-		detail::tmat3x2<valType> const & y
-	)
-    {
-		GLM_STATIC_ASSERT(detail::type<valType>::is_float);
-
-        detail::tmat3x2<valType> result;
-		for(std::size_t i = 0; i < detail::tmat3x2<valType>::col_size(); ++i)
-			result[i] = x[i] * y[i];
-        return result;
-    }
-
-    template <typename valType>
-    inline detail::tmat2x4<valType> matrixCompMult
-	(
-		detail::tmat2x4<valType> const & x, 
-		detail::tmat2x4<valType> const & y
-	)
-    {
-		GLM_STATIC_ASSERT(detail::type<valType>::is_float);
-
-        detail::tmat2x4<valType> result;
-		for(std::size_t i = 0; i < detail::tmat2x4<valType>::col_size(); ++i)
-			result[i] = x[i] * y[i];
-        return result;
-    }
-
-    template <typename valType>
-    inline detail::tmat4x2<valType> matrixCompMult
-	(
-		detail::tmat4x2<valType> const & x, 
-		detail::tmat4x2<valType> const & y
-	)
-    {
-		GLM_STATIC_ASSERT(detail::type<valType>::is_float);
-
-        detail::tmat4x2<valType> result;
-		for(std::size_t i = 0; i < detail::tmat4x2<valType>::col_size(); ++i)
-			result[i] = x[i] * y[i];
-        return result;
-    }
-
-    template <typename valType>
-    inline detail::tmat3x4<valType> matrixCompMult
-	(
-		detail::tmat3x4<valType> const & x, 
-		detail::tmat3x4<valType> const & y
-	)
-    {
-		GLM_STATIC_ASSERT(detail::type<valType>::is_float);
-
-        detail::tmat3x4<valType> result;
-		for(std::size_t i = 0; i < detail::tmat3x4<valType>::col_size(); ++i)
-			result[i] = x[i] * y[i];
-        return result;
-    }
-
-    template <typename valType>
-    inline detail::tmat4x3<valType> matrixCompMult
-	(
-		detail::tmat4x3<valType> const & x, 
-		detail::tmat4x3<valType> const & y
-	)
-    {
-		GLM_STATIC_ASSERT(detail::type<valType>::is_float);
-
-        detail::tmat4x3<valType> result;
-		for(std::size_t i = 0; i < detail::tmat4x3<valType>::col_size(); ++i)
-			result[i] = x[i] * y[i];
-        return result;
-    }
-*/
     template <typename matType>
     inline matType matrixCompMult
 	(
@@ -159,23 +23,23 @@ namespace glm
     {
 		GLM_STATIC_ASSERT(detail::type<typename matType::value_type>::is_float);
 
-        matType result;
+        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 valType>
+    template <typename T>
-    inline detail::tmat2x2<valType> outerProduct
+    inline detail::tmat2x2<T> outerProduct
 	(
-		detail::tvec2<valType> const & c, 
+		detail::tvec2<T> const & c, 
-		detail::tvec2<valType> const & r
+		detail::tvec2<T> const & r
 	)
     {
-		GLM_STATIC_ASSERT(detail::type<valType>::is_float);
+		GLM_STATIC_ASSERT(detail::type<T>::is_float);
 
-		detail::tmat2x2<valType> m;
+		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];
@@ -183,46 +47,46 @@ namespace glm
         return m;
     }
 
-    template <typename valType>
+    template <typename T>
-    inline detail::tmat3x3<valType> outerProduct
+    inline detail::tmat3x3<T> outerProduct
 	(
-		detail::tvec3<valType> const & c, 
+		detail::tvec3<T> const & c, 
-		detail::tvec3<valType> const & r
+		detail::tvec3<T> const & r
 	)
     {
-		GLM_STATIC_ASSERT(detail::type<valType>::is_float);
+		GLM_STATIC_ASSERT(detail::type<T>::is_float);
 
-		detail::tmat3x3<valType> m;
+		detail::tmat3x3<T> m(detail::tmat3x3<T>::null);
-		for(typename detail::tmat3x3<valType>::size_type i = 0; i < detail::tmat3x3<valType>::col_size(); ++i)
+		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 valType>
+    template <typename T>
-    inline detail::tmat4x4<valType> outerProduct
+    inline detail::tmat4x4<T> outerProduct
 	(
-		detail::tvec4<valType> const & c, 
+		detail::tvec4<T> const & c, 
-		detail::tvec4<valType> const & r
+		detail::tvec4<T> const & r
 	)
     {
-		GLM_STATIC_ASSERT(detail::type<valType>::is_float);
+		GLM_STATIC_ASSERT(detail::type<T>::is_float);
 
-		detail::tmat4x4<valType> m;
+		detail::tmat4x4<T> m(detail::tmat4x4<T>::null);
-		for(typename detail::tmat4x4<valType>::size_type i = 0; i < detail::tmat4x4<valType>::col_size(); ++i)
+		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 valType>
+    template <typename T>
-	inline detail::tmat2x3<valType> outerProduct
+	inline detail::tmat2x3<T> outerProduct
 	(
-		detail::tvec3<valType> const & c, 
+		detail::tvec3<T> const & c, 
-		detail::tvec2<valType> const & r
+		detail::tvec2<T> const & r
 	)
 	{
-		GLM_STATIC_ASSERT(detail::type<valType>::is_float);
+		GLM_STATIC_ASSERT(detail::type<T>::is_float);
 
-		detail::tmat2x3<valType> m;
+		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;
@@ -232,16 +96,16 @@ namespace glm
 		return m;
 	}
 
-    template <typename valType>
+    template <typename T>
-	inline detail::tmat3x2<valType> outerProduct
+	inline detail::tmat3x2<T> outerProduct
 	(
-		detail::tvec2<valType> const & c, 
+		detail::tvec2<T> const & c, 
-		detail::tvec3<valType> const & r
+		detail::tvec3<T> const & r
 	)
 	{
-		GLM_STATIC_ASSERT(detail::type<valType>::is_float);
+		GLM_STATIC_ASSERT(detail::type<T>::is_float);
 
-		detail::tmat3x2<valType> m;
+		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;
@@ -251,16 +115,16 @@ namespace glm
 		return m;
 	}
 
-	template <typename valType>
+	template <typename T>
-	inline detail::tmat2x4<valType> outerProduct
+	inline detail::tmat2x4<T> outerProduct
 	(
-		detail::tvec2<valType> const & c, 
+		detail::tvec2<T> const & c, 
-		detail::tvec4<valType> const & r
+		detail::tvec4<T> const & r
 	)
 	{
-		GLM_STATIC_ASSERT(detail::type<valType>::is_float);
+		GLM_STATIC_ASSERT(detail::type<T>::is_float);
 
-		detail::tmat2x4<valType> m;
+		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;
@@ -272,16 +136,16 @@ namespace glm
 		return m;
 	}
 
-	template <typename valType>
+	template <typename T>
-	inline detail::tmat4x2<valType> outerProduct
+	inline detail::tmat4x2<T> outerProduct
 	(
-		detail::tvec4<valType> const & c, 
+		detail::tvec4<T> const & c, 
-		detail::tvec2<valType> const & r
+		detail::tvec2<T> const & r
 	)
 	{
-		GLM_STATIC_ASSERT(detail::type<valType>::is_float);
+		GLM_STATIC_ASSERT(detail::type<T>::is_float);
 
-		detail::tmat4x2<valType> m;
+		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;
@@ -293,16 +157,16 @@ namespace glm
 		return m;
 	}
 
-	template <typename valType>
+	template <typename T>
-	inline detail::tmat3x4<valType> outerProduct
+	inline detail::tmat3x4<T> outerProduct
 	(
-		detail::tvec4<valType> const & c, 
+		detail::tvec4<T> const & c, 
-		detail::tvec3<valType> const & r
+		detail::tvec3<T> const & r
 	)
 	{
-		GLM_STATIC_ASSERT(detail::type<valType>::is_float);
+		GLM_STATIC_ASSERT(detail::type<T>::is_float);
 
-		detail::tmat3x4<valType> m;
+		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;
@@ -318,16 +182,16 @@ namespace glm
 		return m;
 	}
 
-	template <typename valType>
+	template <typename T>
-	inline detail::tmat4x3<valType> outerProduct
+	inline detail::tmat4x3<T> outerProduct
 	(
-		detail::tvec3<valType> const & c, 
+		detail::tvec3<T> const & c, 
-		detail::tvec4<valType> const & r
+		detail::tvec4<T> const & r
 	)
 	{
-		GLM_STATIC_ASSERT(detail::type<valType>::is_float);
+		GLM_STATIC_ASSERT(detail::type<T>::is_float);
 
-		detail::tmat4x3<valType> m;
+		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;
@@ -343,15 +207,15 @@ namespace glm
 		return m;
 	}
 
-    template <typename valType>
+    template <typename T>
-    inline detail::tmat2x2<valType> transpose
+    inline detail::tmat2x2<T> transpose
 	(
-		detail::tmat2x2<valType> const & m
+		detail::tmat2x2<T> const & m
 	)
     {
-		GLM_STATIC_ASSERT(detail::type<valType>::is_float);
+		GLM_STATIC_ASSERT(detail::type<T>::is_float);
 
-        detail::tmat2x2<valType> result;
+        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];
@@ -359,15 +223,15 @@ namespace glm
         return result;
     }
 
-    template <typename valType>
+    template <typename T>
-    inline detail::tmat3x3<valType> transpose
+    inline detail::tmat3x3<T> transpose
 	(
-		detail::tmat3x3<valType> const & m
+		detail::tmat3x3<T> const & m
 	)
     {
-		GLM_STATIC_ASSERT(detail::type<valType>::is_float);
+		GLM_STATIC_ASSERT(detail::type<T>::is_float);
 
-        detail::tmat3x3<valType> result;
+        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];
@@ -382,15 +246,15 @@ namespace glm
         return result;
     }
 
-    template <typename valType>
+    template <typename T>
-    inline detail::tmat4x4<valType> transpose
+    inline detail::tmat4x4<T> transpose
 	(
-		detail::tmat4x4<valType> const & m
+		detail::tmat4x4<T> const & m
 	)
     {
-		GLM_STATIC_ASSERT(detail::type<valType>::is_float);
+		GLM_STATIC_ASSERT(detail::type<T>::is_float);
 
-        detail::tmat4x4<valType> result;
+        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];
@@ -413,15 +277,15 @@ namespace glm
         return result;
     }
 
-    template <typename valType>
+    template <typename T>
-    inline detail::tmat2x3<valType> transpose
+    inline detail::tmat2x3<T> transpose
 	(
-		detail::tmat3x2<valType> const & m
+		detail::tmat3x2<T> const & m
 	)
     {
-		GLM_STATIC_ASSERT(detail::type<valType>::is_float);
+		GLM_STATIC_ASSERT(detail::type<T>::is_float);
 
-        detail::tmat2x3<valType> result;
+        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];
@@ -431,15 +295,15 @@ namespace glm
         return result;
     }
 
-    template <typename valType>
+    template <typename T>
-    inline detail::tmat3x2<valType> transpose
+    inline detail::tmat3x2<T> transpose
 	(
-		detail::tmat2x3<valType> const & m
+		detail::tmat2x3<T> const & m
 	)
     {
-		GLM_STATIC_ASSERT(detail::type<valType>::is_float);
+		GLM_STATIC_ASSERT(detail::type<T>::is_float);
 
-        detail::tmat3x2<valType> result;
+        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];
@@ -449,15 +313,15 @@ namespace glm
         return result;
     }
 
-    template <typename valType>
+    template <typename T>
-	inline detail::tmat2x4<valType> transpose
+	inline detail::tmat2x4<T> transpose
 	(
-		detail::tmat4x2<valType> const & m
+		detail::tmat4x2<T> const & m
 	)
 	{
-		GLM_STATIC_ASSERT(detail::type<valType>::is_float);
+		GLM_STATIC_ASSERT(detail::type<T>::is_float);
 
-		detail::tmat2x4<valType> result;
+		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];
@@ -469,15 +333,15 @@ namespace glm
 		return result;
 	}
 
-    template <typename valType>
+    template <typename T>
-	inline detail::tmat4x2<valType> transpose
+	inline detail::tmat4x2<T> transpose
 	(
-		detail::tmat2x4<valType> const & m
+		detail::tmat2x4<T> const & m
 	)
 	{
-		GLM_STATIC_ASSERT(detail::type<valType>::is_float);
+		GLM_STATIC_ASSERT(detail::type<T>::is_float);
 
-        detail::tmat4x2<valType> result;
+        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];
@@ -489,15 +353,15 @@ namespace glm
         return result;
 	}
 
-    template <typename valType>
+    template <typename T>
-	inline detail::tmat3x4<valType> transpose
+	inline detail::tmat3x4<T> transpose
 	(
-		detail::tmat4x3<valType> const & m
+		detail::tmat4x3<T> const & m
 	)
 	{
-		GLM_STATIC_ASSERT(detail::type<valType>::is_float);
+		GLM_STATIC_ASSERT(detail::type<T>::is_float);
 
-		detail::tmat3x4<valType> result;
+		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];
@@ -513,15 +377,15 @@ namespace glm
 		return result;
 	}
 
-    template <typename valType>
+    template <typename T>
-	inline detail::tmat4x3<valType> transpose
+	inline detail::tmat4x3<T> transpose
 	(
-		detail::tmat3x4<valType> const & m
+		detail::tmat3x4<T> const & m
 	)
 	{
-		GLM_STATIC_ASSERT(detail::type<valType>::is_float);
+		GLM_STATIC_ASSERT(detail::type<T>::is_float);
 
-        detail::tmat4x3<valType> result;
+        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];
@@ -537,40 +401,41 @@ namespace glm
         return result;
 	}
 
-	template <typename valType>
+	template <typename T>
-	inline typename detail::tmat2x2<valType>::value_type determinant
+	inline typename detail::tmat2x2<T>::value_type determinant
 	(
-		detail::tmat2x2<valType> const & m
+		detail::tmat2x2<T> const & m
 	)
 	{
 		return m[0][0] * m[1][1] - m[1][0] * m[0][1];
 	}
 
-	template <typename valType>
+	template <typename T>
-	inline typename detail::tmat3x3<valType>::value_type determinant
+	inline typename detail::tmat3x3<T>::value_type determinant
 	(
-		detail::tmat3x3<valType> const & m
+		detail::tmat3x3<T> const & m
 	)
 	{
-		return m[0][0] * (m[1][1] * m[2][2] - m[2][1] * m[1][2])
+		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 valType>
+	template <typename T>
-	inline typename detail::tmat4x4<valType>::value_type determinant
+	inline typename detail::tmat4x4<T>::value_type determinant
 	(
-		detail::tmat4x4<valType> const & m
+		detail::tmat4x4<T> const & m
 	)
 	{
-		valType SubFactor00 = m[2][2] * m[3][3] - m[3][2] * m[2][3];
+		T SubFactor00 = m[2][2] * m[3][3] - m[3][2] * m[2][3];
-		valType SubFactor01 = m[2][1] * m[3][3] - m[3][1] * m[2][3];
+		T SubFactor01 = m[2][1] * m[3][3] - m[3][1] * m[2][3];
-		valType SubFactor02 = m[2][1] * m[3][2] - m[3][1] * m[2][2];
+		T SubFactor02 = m[2][1] * m[3][2] - m[3][1] * m[2][2];
-		valType SubFactor03 = m[2][0] * m[3][3] - m[3][0] * m[2][3];
+		T SubFactor03 = m[2][0] * m[3][3] - m[3][0] * m[2][3];
-		valType SubFactor04 = m[2][0] * m[3][2] - m[3][0] * m[2][2];
+		T SubFactor04 = m[2][0] * m[3][2] - m[3][0] * m[2][2];
-		valType SubFactor05 = m[2][0] * m[3][1] - m[3][0] * m[2][1];
+		T SubFactor05 = m[2][0] * m[3][1] - m[3][0] * m[2][1];
 
-		detail::tvec4<valType> DetCof(
+		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),
@@ -582,16 +447,16 @@ namespace glm
 			 + m[0][3] * DetCof[3];
 	}
 
-	template <typename valType> 
+	template <typename T> 
-	inline detail::tmat2x2<valType> inverse
+	inline detail::tmat2x2<T> inverse
 	(
-		detail::tmat2x2<valType> const & m
+		detail::tmat2x2<T> const & m
 	)
 	{
 		//valType Determinant = m[0][0] * m[1][1] - m[1][0] * m[0][1];
-		valType Determinant = determinant(m);
+		T Determinant = determinant(m);
 
-		detail::tmat2x2<valType> Inverse(
+		detail::tmat2x2<T> Inverse(
 			+ m[1][1] / Determinant,
 			- m[1][0] / Determinant,
 			- m[0][1] / Determinant, 
@@ -600,19 +465,19 @@ namespace glm
 		return Inverse;
 	}
 
-	template <typename valType> 
+	template <typename T> 
-	inline detail::tmat3x3<valType> inverse
+	inline detail::tmat3x3<T> inverse
 	(
-		detail::tmat3x3<valType> const & m
+		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]);
 
-		valType Determinant = determinant(m);
+		T Determinant = determinant(m);
 
-		detail::tmat3x3<valType> Inverse;
+		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]);
@@ -627,127 +492,61 @@ namespace glm
 		return Inverse;
 	}
 
-    template <typename valType> 
+	template <typename T> 
-    inline detail::tmat4x4<valType> inverseOgre
+	inline detail::tmat4x4<T> inverse
 	(
-		detail::tmat4x4<valType> const & m
+		detail::tmat4x4<T> const & m
 	)
 	{
-        valType m00 = m[0][0], m01 = m[0][1], m02 = m[0][2], m03 = m[0][3];
+		T Coef00 = m[2][2] * m[3][3] - m[3][2] * m[2][3];
-        valType m10 = m[1][0], m11 = m[1][1], m12 = m[1][2], m13 = m[1][3];
+		T Coef02 = m[1][2] * m[3][3] - m[3][2] * m[1][3];
-        valType m20 = m[2][0], m21 = m[2][1], m22 = m[2][2], m23 = m[2][3];
+		T Coef03 = m[1][2] * m[2][3] - m[2][2] * m[1][3];
-        valType m30 = m[3][0], m31 = m[3][1], m32 = m[3][2], m33 = m[3][3];
 
-        valType v0 = m20 * m31 - m21 * m30;
+		T Coef04 = m[2][1] * m[3][3] - m[3][1] * m[2][3];
-        valType v1 = m20 * m32 - m22 * m30;
+		T Coef06 = m[1][1] * m[3][3] - m[3][1] * m[1][3];
-        valType v2 = m20 * m33 - m23 * m30;
+		T Coef07 = m[1][1] * m[2][3] - m[2][1] * m[1][3];
-        valType v3 = m21 * m32 - m22 * m31;
-        valType v4 = m21 * m33 - m23 * m31;
-        valType v5 = m22 * m33 - m23 * m32;
 
-        valType t00 = + (v5 * m11 - v4 * m12 + v3 * m13);
+		T Coef08 = m[2][1] * m[3][2] - m[3][1] * m[2][2];
-        valType t10 = - (v5 * m10 - v2 * m12 + v1 * m13);
+		T Coef10 = m[1][1] * m[3][2] - m[3][1] * m[1][2];
-        valType t20 = + (v4 * m10 - v2 * m11 + v0 * m13);
+		T Coef11 = m[1][1] * m[2][2] - m[2][1] * m[1][2];
-        valType t30 = - (v3 * m10 - v1 * m11 + v0 * m12);
 
-        valType invDet = 1 / (t00 * m00 + t10 * m01 + t20 * m02 + t30 * m03);
+		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];
 
-        valType d00 = t00 * invDet;
+		T Coef16 = m[2][0] * m[3][2] - m[3][0] * m[2][2];
-        valType d10 = t10 * invDet;
+		T Coef18 = m[1][0] * m[3][2] - m[3][0] * m[1][2];
-        valType d20 = t20 * invDet;
+		T Coef19 = m[1][0] * m[2][2] - m[2][0] * m[1][2];
-        valType d30 = t30 * invDet;
 
-        valType d01 = - (v5 * m01 - v4 * m02 + v3 * m03) * invDet;
+		T Coef20 = m[2][0] * m[3][1] - m[3][0] * m[2][1];
-        valType d11 = + (v5 * m00 - v2 * m02 + v1 * m03) * invDet;
+		T Coef22 = m[1][0] * m[3][1] - m[3][0] * m[1][1];
-        valType d21 = - (v4 * m00 - v2 * m01 + v0 * m03) * invDet;
+		T Coef23 = m[1][0] * m[2][1] - m[2][0] * m[1][1];
-        valType d31 = + (v3 * m00 - v1 * m01 + v0 * m02) * invDet;
 
-        v0 = m10 * m31 - m11 * m30;
+		detail::tvec4<T> const SignA(+1, -1, +1, -1);
-        v1 = m10 * m32 - m12 * m30;
+		detail::tvec4<T> const SignB(-1, +1, -1, +1);
-        v2 = m10 * m33 - m13 * m30;
-        v3 = m11 * m32 - m12 * m31;
-        v4 = m11 * m33 - m13 * m31;
-        v5 = m12 * m33 - m13 * m32;
 
-        valType d02 = + (v5 * m01 - v4 * m02 + v3 * m03) * invDet;
+		detail::tvec4<T> Fac0(Coef00, Coef00, Coef02, Coef03);
-        valType d12 = - (v5 * m00 - v2 * m02 + v1 * m03) * invDet;
+		detail::tvec4<T> Fac1(Coef04, Coef04, Coef06, Coef07);
-        valType d22 = + (v4 * m00 - v2 * m01 + v0 * m03) * invDet;
+		detail::tvec4<T> Fac2(Coef08, Coef08, Coef10, Coef11);
-        valType d32 = - (v3 * m00 - v1 * m01 + v0 * m02) * invDet;
+		detail::tvec4<T> Fac3(Coef12, Coef12, Coef14, Coef15);
+		detail::tvec4<T> Fac4(Coef16, Coef16, Coef18, Coef19);
+		detail::tvec4<T> Fac5(Coef20, Coef20, Coef22, Coef23);
 
-        v0 = m21 * m10 - m20 * m11;
+		detail::tvec4<T> Vec0(m[1][0], m[0][0], m[0][0], m[0][0]);
-        v1 = m22 * m10 - m20 * m12;
+		detail::tvec4<T> Vec1(m[1][1], m[0][1], m[0][1], m[0][1]);
-        v2 = m23 * m10 - m20 * m13;
+		detail::tvec4<T> Vec2(m[1][2], m[0][2], m[0][2], m[0][2]);
-        v3 = m22 * m11 - m21 * m12;
+		detail::tvec4<T> Vec3(m[1][3], m[0][3], m[0][3], m[0][3]);
-        v4 = m23 * m11 - m21 * m13;
-        v5 = m23 * m12 - m22 * m13;
 
-        valType d03 = - (v5 * m01 - v4 * m02 + v3 * m03) * invDet;
+		detail::tvec4<T> Inv0 = SignA * (Vec1 * Fac0 - Vec2 * Fac1 + Vec3 * Fac2);
-        valType d13 = + (v5 * m00 - v2 * m02 + v1 * m03) * invDet;
+		detail::tvec4<T> Inv1 = SignB * (Vec0 * Fac0 - Vec2 * Fac3 + Vec3 * Fac4);
-        valType d23 = - (v4 * m00 - v2 * m01 + v0 * m03) * invDet;
+		detail::tvec4<T> Inv2 = SignA * (Vec0 * Fac1 - Vec1 * Fac3 + Vec3 * Fac5);
-        valType d33 = + (v3 * m00 - v1 * m01 + v0 * m02) * invDet;
+		detail::tvec4<T> Inv3 = SignB * (Vec0 * Fac2 - Vec1 * Fac4 + Vec2 * Fac5);
 
-        return detail::tmat4x4<valType>(
+		detail::tmat4x4<T> Inverse(Inv0, Inv1, Inv2, Inv3);
-            d00, d01, d02, d03,
-            d10, d11, d12, d13,
-            d20, d21, d22, d23,
-            d30, d31, d32, d33);
-    }
 
-	template <typename valType> 
+		detail::tvec4<T> Row0(Inverse[0][0], Inverse[1][0], Inverse[2][0], Inverse[3][0]);
-	inline detail::tmat4x4<valType> inverse
-	(
-		detail::tmat4x4<valType> const & m
-	)
-	{
-		valType Coef00 = m[2][2] * m[3][3] - m[3][2] * m[2][3];
-		valType Coef02 = m[1][2] * m[3][3] - m[3][2] * m[1][3];
-		valType Coef03 = m[1][2] * m[2][3] - m[2][2] * m[1][3];
 
-		valType Coef04 = m[2][1] * m[3][3] - m[3][1] * m[2][3];
+		T Determinant = glm::dot(m[0], Row0);
-		valType Coef06 = m[1][1] * m[3][3] - m[3][1] * m[1][3];
-		valType Coef07 = m[1][1] * m[2][3] - m[2][1] * m[1][3];
-
-		valType Coef08 = m[2][1] * m[3][2] - m[3][1] * m[2][2];
-		valType Coef10 = m[1][1] * m[3][2] - m[3][1] * m[1][2];
-		valType Coef11 = m[1][1] * m[2][2] - m[2][1] * m[1][2];
-
-		valType Coef12 = m[2][0] * m[3][3] - m[3][0] * m[2][3];
-		valType Coef14 = m[1][0] * m[3][3] - m[3][0] * m[1][3];
-		valType Coef15 = m[1][0] * m[2][3] - m[2][0] * m[1][3];
-
-		valType Coef16 = m[2][0] * m[3][2] - m[3][0] * m[2][2];
-		valType Coef18 = m[1][0] * m[3][2] - m[3][0] * m[1][2];
-		valType Coef19 = m[1][0] * m[2][2] - m[2][0] * m[1][2];
-
-		valType Coef20 = m[2][0] * m[3][1] - m[3][0] * m[2][1];
-		valType Coef22 = m[1][0] * m[3][1] - m[3][0] * m[1][1];
-		valType Coef23 = m[1][0] * m[2][1] - m[2][0] * m[1][1];
-
-		detail::tvec4<valType> const SignA(+1, -1, +1, -1);
-		detail::tvec4<valType> const SignB(-1, +1, -1, +1);
-
-		detail::tvec4<valType> Fac0(Coef00, Coef00, Coef02, Coef03);
-		detail::tvec4<valType> Fac1(Coef04, Coef04, Coef06, Coef07);
-		detail::tvec4<valType> Fac2(Coef08, Coef08, Coef10, Coef11);
-		detail::tvec4<valType> Fac3(Coef12, Coef12, Coef14, Coef15);
-		detail::tvec4<valType> Fac4(Coef16, Coef16, Coef18, Coef19);
-		detail::tvec4<valType> Fac5(Coef20, Coef20, Coef22, Coef23);
-
-		detail::tvec4<valType> Vec0(m[1][0], m[0][0], m[0][0], m[0][0]);
-		detail::tvec4<valType> Vec1(m[1][1], m[0][1], m[0][1], m[0][1]);
-		detail::tvec4<valType> Vec2(m[1][2], m[0][2], m[0][2], m[0][2]);
-		detail::tvec4<valType> Vec3(m[1][3], m[0][3], m[0][3], m[0][3]);
-
-		detail::tvec4<valType> Inv0 = SignA * (Vec1 * Fac0 - Vec2 * Fac1 + Vec3 * Fac2);
-		detail::tvec4<valType> Inv1 = SignB * (Vec0 * Fac0 - Vec2 * Fac3 + Vec3 * Fac4);
-		detail::tvec4<valType> Inv2 = SignA * (Vec0 * Fac1 - Vec1 * Fac3 + Vec3 * Fac5);
-		detail::tvec4<valType> Inv3 = SignB * (Vec0 * Fac2 - Vec1 * Fac4 + Vec2 * Fac5);
-
-		detail::tmat4x4<valType> Inverse(Inv0, Inv1, Inv2, Inv3);
-
-		detail::tvec4<valType> Row0(Inverse[0][0], Inverse[1][0], Inverse[2][0], Inverse[3][0]);
-
-		valType Determinant = glm::dot(m[0], Row0);
 
 		Inverse /= Determinant;
 	    

glm/core/func_noise.hpp

@@ -1,10 +1,10 @@
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-// OpenGL Mathematics Copyright (c) 2005 - 2009 G-Truc Creation (www.g-truc.net)
+// 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.h
+// File    : glm/core/func_noise.hpp
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 #ifndef glm_core_func_noise

glm/core/func_noise.inl

@@ -1,5 +1,5 @@
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-// OpenGL Mathematics Copyright (c) 2005 - 2009 G-Truc Creation (www.g-truc.net)
+// OpenGL Mathematics Copyright (c) 2005 - 2010 G-Truc Creation (www.g-truc.net)
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 // Created : 2008-08-01
 // Updated : 2008-09-23
@@ -26,38 +26,38 @@ namespace glm
 		return genType(int(iNbr / genType(65536)) % 32768) / genType(32767);
 	}
 
-	template <typename valType>
+	template <typename T>
-	inline typename detail::tvec2<valType>::value_type noise1
+	inline typename detail::tvec2<T>::value_type noise1
 	(
-		detail::tvec2<valType> const & x
+		detail::tvec2<T> const & x
 	)
 	{
-		valType tmp(0);
+		T tmp(0);
-		for(typename detail::tvec2<valType>::size_type i = 0; i < detail::tvec2<valType>::value_size(); ++i)
+		for(typename detail::tvec2<T>::size_type i = 0; i < detail::tvec2<T>::value_size(); ++i)
 			tmp += x[i];
 		return noise1(tmp);
 	}
 
-	template <typename valType>
+	template <typename T>
-	inline typename detail::tvec3<valType>::value_type noise1
+	inline typename detail::tvec3<T>::value_type noise1
 	(
-		detail::tvec3<valType> const & x
+		detail::tvec3<T> const & x
 	)
 	{
-		valType tmp(0);
+		T tmp(0);
-		for(typename detail::tvec3<valType>::size_type i = 0; i < detail::tvec3<valType>::value_size(); ++i)
+		for(typename detail::tvec3<T>::size_type i = 0; i < detail::tvec3<T>::value_size(); ++i)
 			tmp += x[i];
 		return noise1(tmp);
 	}
 
-	template <typename valType>
+	template <typename T>
-	inline typename detail::tvec4<valType>::value_type noise1
+	inline typename detail::tvec4<T>::value_type noise1
 	(
-		detail::tvec4<valType> const & x
+		detail::tvec4<T> const & x
 	)
 	{
-		valType tmp(0);
+		T tmp(0);
-		for(typename detail::tvec4<valType>::size_type i = 0; i < detail::tvec4<valType>::value_size(); ++i)
+		for(typename detail::tvec4<T>::size_type i = 0; i < detail::tvec4<T>::value_size(); ++i)
 			tmp += x[i];
 		return noise1(tmp);
 	}
@@ -78,59 +78,59 @@ namespace glm
 			noise1(f2));
 	}
 
-	template <typename valType>
+	template <typename T>
-	inline detail::tvec2<valType> noise2
+	inline detail::tvec2<T> noise2
 	(
-		detail::tvec2<valType> const & x
+		detail::tvec2<T> const & x
 	)
 	{
-		GLM_STATIC_ASSERT(detail::type<valType>::is_float);
+		GLM_STATIC_ASSERT(detail::type<T>::is_float);
 
-		valType f0(0);
+		T f0(0);
-		for(typename detail::tvec2<valType>::size_type i = 0; i < detail::tvec2<valType>::value_size(); ++i)
+		for(typename detail::tvec2<T>::size_type i = 0; i < detail::tvec2<T>::value_size(); ++i)
 			f0 += x[i];
 		
-		valType f1 = f0 * valType(1103515245) + valType(12345);
+		T f1 = f0 * T(1103515245) + T(12345);
-		valType f2 = f1 * valType(1103515245) + valType(12345);
+		T f2 = f1 * T(1103515245) + T(12345);
-		return detail::tvec2<valType>(
+		return detail::tvec2<T>(
 			noise1(f1),
 			noise1(f2));
 	}
 
-	template <typename valType>
+	template <typename T>
-	inline detail::tvec2<valType> noise2
+	inline detail::tvec2<T> noise2
 	(
-		detail::tvec3<valType> const & x
+		detail::tvec3<T> const & x
 	)
 	{
-		GLM_STATIC_ASSERT(detail::type<valType>::is_float);
+		GLM_STATIC_ASSERT(detail::type<T>::is_float);
 
-		valType f0(0);
+		T f0(0);
-		for(typename detail::tvec3<valType>::size_type i = 0; i < detail::tvec3<valType>::value_size(); ++i)
+		for(typename detail::tvec3<T>::size_type i = 0; i < detail::tvec3<T>::value_size(); ++i)
 			f0 += x[i];
 
-		valType f1 = f0 * valType(1103515245) + valType(12345);
+		T f1 = f0 * T(1103515245) + T(12345);
-		valType f2 = f1 * valType(1103515245) + valType(12345);
+		T f2 = f1 * T(1103515245) + T(12345);
-		return detail::tvec2<valType>(
+		return detail::tvec2<T>(
 			noise1(f1),
 			noise1(f2));
 	}
 
-	template <typename valType>
+	template <typename T>
-	inline detail::tvec2<valType> noise2
+	inline detail::tvec2<T> noise2
 	(
-		detail::tvec4<valType> const & x
+		detail::tvec4<T> const & x
 	)
 	{
-		GLM_STATIC_ASSERT(detail::type<valType>::is_float);
+		GLM_STATIC_ASSERT(detail::type<T>::is_float);
 
-		valType f0(0);
+		T f0(0);
-		for(typename detail::tvec4<valType>::size_type i = 0; i < detail::tvec4<valType>::value_size(); ++i)
+		for(typename detail::tvec4<T>::size_type i = 0; i < detail::tvec4<T>::value_size(); ++i)
 			f0 += x[i];
 		
-		valType f1 = f0 * valType(1103515245) + valType(12345);
+		T f1 = f0 * T(1103515245) + T(12345);
-		valType f2 = f1 * valType(1103515245) + valType(12345);
+		T f2 = f1 * T(1103515245) + T(12345);
-		return detail::tvec2<valType>(
+		return detail::tvec2<T>(
 			noise1(f1),
 			noise1(f2));
 	}
@@ -153,61 +153,61 @@ namespace glm
 			noise1(f3));
 	}
 
-	template <typename valType>
+	template <typename T>
-	inline detail::tvec3<valType> noise3
+	inline detail::tvec3<T> noise3
 	(
-		detail::tvec2<valType> const & x
+		detail::tvec2<T> const & x
 	)
 	{
-		GLM_STATIC_ASSERT(detail::type<valType>::is_float);
+		GLM_STATIC_ASSERT(detail::type<T>::is_float);
 
-		valType f0(0);
+		T f0(0);
-		for(typename detail::tvec2<valType>::size_type i = 0; i < detail::tvec2<valType>::value_size(); ++i)
+		for(typename detail::tvec2<T>::size_type i = 0; i < detail::tvec2<T>::value_size(); ++i)
 			f0 += x[i];
-		valType f1 = f0 * valType(1103515245) + valType(12345);
+		T f1 = f0 * T(1103515245) + T(12345);
-		valType f2 = f1 * valType(1103515245) + valType(12345);
+		T f2 = f1 * T(1103515245) + T(12345);
-		valType f3 = f2 * valType(1103515245) + valType(12345);
+		T f3 = f2 * T(1103515245) + T(12345);
-		return detail::tvec3<valType>(
+		return detail::tvec3<T>(
 			noise1(f1),
 			noise1(f2),
 			noise1(f3));
 	}
 
-	template <typename valType>
+	template <typename T>
-	inline detail::tvec3<valType> noise3
+	inline detail::tvec3<T> noise3
 	(
-		detail::tvec3<valType> const & x
+		detail::tvec3<T> const & x
 	)
 	{
-		GLM_STATIC_ASSERT(detail::type<valType>::is_float);
+		GLM_STATIC_ASSERT(detail::type<T>::is_float);
 
-		valType f0(0);
+		T f0(0);
-		for(typename detail::tvec3<valType>::size_type i = 0; i < detail::tvec3<valType>::value_size(); ++i)
+		for(typename detail::tvec3<T>::size_type i = 0; i < detail::tvec3<T>::value_size(); ++i)
 			f0 += x[i];
-		valType f1 = f0 * valType(1103515245) + valType(12345);
+		T f1 = f0 * T(1103515245) + T(12345);
-		valType f2 = f1 * valType(1103515245) + valType(12345);
+		T f2 = f1 * T(1103515245) + T(12345);
-		valType f3 = f2 * valType(1103515245) + valType(12345);
+		T f3 = f2 * T(1103515245) + T(12345);
-		return detail::tvec3<valType>(
+		return detail::tvec3<T>(
 			noise1(f1),
 			noise1(f2),
 			noise1(f3));
 	}
 
-	template <typename valType>
+	template <typename T>
-	inline detail::tvec3<valType> noise3
+	inline detail::tvec3<T> noise3
 	(
-		detail::tvec4<valType> const & x
+		detail::tvec4<T> const & x
 	)
 	{
-		GLM_STATIC_ASSERT(detail::type<valType>::is_float);
+		GLM_STATIC_ASSERT(detail::type<T>::is_float);
 
-		valType f0(0);
+		T f0(0);
-		for(typename detail::tvec4<valType>::size_type i = 0; i < detail::tvec4<valType>::value_size(); ++i)
+		for(typename detail::tvec4<T>::size_type i = 0; i < detail::tvec4<T>::value_size(); ++i)
 			f0 += x[i];
-		valType f1 = f0 * valType(1103515245) + valType(12345);
+		T f1 = f0 * T(1103515245) + T(12345);
-		valType f2 = f1 * valType(1103515245) + valType(12345);
+		T f2 = f1 * T(1103515245) + T(12345);
-		valType f3 = f2 * valType(1103515245) + valType(12345);
+		T f3 = f2 * T(1103515245) + T(12345);
-		return detail::tvec3<valType>(
+		return detail::tvec3<T>(
 			noise1(f1),
 			noise1(f2),
 			noise1(f3));
@@ -233,66 +233,66 @@ namespace glm
 			noise1(f4));
 	}
 
-	template <typename valType>
+	template <typename T>
-	inline detail::tvec4<valType> noise4
+	inline detail::tvec4<T> noise4
 	(
-		detail::tvec2<valType> const & x
+		detail::tvec2<T> const & x
 	)
 	{
-		GLM_STATIC_ASSERT(detail::type<valType>::is_float);
+		GLM_STATIC_ASSERT(detail::type<T>::is_float);
 
-		valType f0(0);
+		T f0(0);
-		for(typename detail::tvec2<valType>::size_type i = 0; i < detail::tvec2<valType>::value_size(); ++i)
+		for(typename detail::tvec2<T>::size_type i = 0; i < detail::tvec2<T>::value_size(); ++i)
 			f0 += x[i];
-		valType f1 = f0 * valType(1103515245) + valType(12345);
+		T f1 = f0 * T(1103515245) + T(12345);
-		valType f2 = f1 * valType(1103515245) + valType(12345);
+		T f2 = f1 * T(1103515245) + T(12345);
-		valType f3 = f2 * valType(1103515245) + valType(12345);
+		T f3 = f2 * T(1103515245) + T(12345);
-		valType f4 = f3 * valType(1103515245) + valType(12345);
+		T f4 = f3 * T(1103515245) + T(12345);
-		return detail::tvec4<valType>(
+		return detail::tvec4<T>(
 			noise1(f1),
 			noise1(f2),
 			noise1(f3),
 			noise1(f4));
 	}
 
-	template <typename valType>
+	template <typename T>
-	inline detail::tvec4<valType> noise4
+	inline detail::tvec4<T> noise4
 	(
-		detail::tvec3<valType> const & x
+		detail::tvec3<T> const & x
 	)
 	{
-		GLM_STATIC_ASSERT(detail::type<valType>::is_float);
+		GLM_STATIC_ASSERT(detail::type<T>::is_float);
 
-		valType f0(0);
+		T f0(0);
-		for(typename detail::tvec3<valType>::size_type i = 0; i < detail::tvec3<valType>::value_size(); ++i)
+		for(typename detail::tvec3<T>::size_type i = 0; i < detail::tvec3<T>::value_size()(); ++i)
 			f0 += x[i];
-		valType f1 = f0 * valType(1103515245) + valType(12345);
+		T f1 = f0 * T(1103515245) + T(12345);
-		valType f2 = f1 * valType(1103515245) + valType(12345);
+		T f2 = f1 * T(1103515245) + T(12345);
-		valType f3 = f2 * valType(1103515245) + valType(12345);
+		T f3 = f2 * T(1103515245) + T(12345);
-		valType f4 = f3 * valType(1103515245) + valType(12345);
+		T f4 = f3 * T(1103515245) + T(12345);
-		return detail::tvec4<valType>(
+		return detail::tvec4<T>(
 			noise1(f1),
 			noise1(f2),
 			noise1(f3),
 			noise1(f4));
 	}
 
-	template <typename valType>
+	template <typename T>
-	inline detail::tvec4<valType> noise4
+	inline detail::tvec4<T> noise4
 	(
-		detail::tvec4<valType> const & x
+		detail::tvec4<T> const & x
 	)
 	{
-		GLM_STATIC_ASSERT(detail::type<valType>::is_float);
+		GLM_STATIC_ASSERT(detail::type<T>::is_float);
 
-		valType f0(0);
+		T f0(0);
-		for(typename detail::tvec4<valType>::size_type i = 0; i < detail::tvec4<valType>::value_size(); ++i)
+		for(typename detail::tvec4<T>::size_type i = 0; i < detail::tvec4<T>::value_size()(); ++i)
 			f0 += x[i];
-		valType f1 = f0 * valType(1103515245) + valType(12345);
+		T f1 = f0 * T(1103515245) + T(12345);
-		valType f2 = f1 * valType(1103515245) + valType(12345);
+		T f2 = f1 * T(1103515245) + T(12345);
-		valType f3 = f2 * valType(1103515245) + valType(12345);
+		T f3 = f2 * T(1103515245) + T(12345);
-		valType f4 = f3 * valType(1103515245) + valType(12345);
+		T f4 = f3 * T(1103515245) + T(12345);
-		return detail::tvec4<valType>(
+		return detail::tvec4<T>(
 			noise1(f1),
 			noise1(f2),
 			noise1(f3),

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

@@ -1,10 +1,10 @@
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-// OpenGL Mathematics Copyright (c) 2005 - 2009 G-Truc Creation (www.g-truc.net)
+// 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.h
+// File    : glm/core/func_trigonometric.hpp
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 #ifndef glm_core_func_trigonometric

glm/core/func_trigonometric.inl

@@ -1,5 +1,5 @@
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-// OpenGL Mathematics Copyright (c) 2005 - 2009 G-Truc Creation (www.g-truc.net)
+// OpenGL Mathematics Copyright (c) 2005 - 2010 G-Truc Creation (www.g-truc.net)
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 // Created : 2008-08-03
 // Updated : 2008-09-14
@@ -26,36 +26,36 @@ namespace glm
         return degrees * (pi / genType(180));
     }
 
-    template <typename valType>
+    template <typename T>
-	inline detail::tvec2<valType> radians
+	inline detail::tvec2<T> radians
 	(
-		detail::tvec2<valType> const & degrees
+		detail::tvec2<T> const & degrees
 	)
     {
-        return detail::tvec2<valType>(
+        return detail::tvec2<T>(
             radians(degrees.x),
             radians(degrees.y));
     }
 
-    template <typename valType>
+    template <typename T>
-    inline detail::tvec3<valType> radians
+    inline detail::tvec3<T> radians
 	(
-		detail::tvec3<valType> const & degrees
+		detail::tvec3<T> const & degrees
 	)
     {
-        return detail::tvec3<valType>(
+        return detail::tvec3<T>(
             radians(degrees.x),
             radians(degrees.y),
             radians(degrees.z));
     }
 
-    template <typename valType>
+    template <typename T>
-    inline detail::tvec4<valType> radians
+    inline detail::tvec4<T> radians
 	(
-		detail::tvec4<valType> const & degrees
+		detail::tvec4<T> const & degrees
 	)
     {
-        return detail::tvec4<valType>(
+        return detail::tvec4<T>(
             radians(degrees.x),
             radians(degrees.y),
             radians(degrees.z),
@@ -75,36 +75,36 @@ namespace glm
         return radians * (genType(180) / pi);
     }
 
-    template <typename valType>
+    template <typename T>
-    inline detail::tvec2<valType> degrees
+    inline detail::tvec2<T> degrees
 	(
-		detail::tvec2<valType> const & radians
+		detail::tvec2<T> const & radians
 	)
     {
-        return detail::tvec2<valType>(
+        return detail::tvec2<T>(
             degrees(radians.x),
             degrees(radians.y));
     }
 
-    template <typename valType>
+    template <typename T>
-    inline detail::tvec3<valType> degrees
+    inline detail::tvec3<T> degrees
 	(	
-		detail::tvec3<valType> const & radians
+		detail::tvec3<T> const & radians
 	)
     {
-        return detail::tvec3<valType>(
+        return detail::tvec3<T>(
             degrees(radians.x),
             degrees(radians.y),
             degrees(radians.z));
     }
 
-    template <typename valType>
+    template <typename T>
-    inline detail::tvec4<valType> degrees
+    inline detail::tvec4<T> degrees
 	(
-		detail::tvec4<valType> const & radians
+		detail::tvec4<T> const & radians
 	)
     {
-        return detail::tvec4<valType>(
+        return detail::tvec4<T>(
             degrees(radians.x),
             degrees(radians.y),
             degrees(radians.z),
@@ -123,36 +123,36 @@ namespace glm
 		return ::std::sin(angle);
     }
 
-    template <typename valType>
+    template <typename T>
-    inline detail::tvec2<valType> sin
+    inline detail::tvec2<T> sin
 	(
-		detail::tvec2<valType> const & angle
+		detail::tvec2<T> const & angle
 	)
     {
-        return detail::tvec2<valType>(
+        return detail::tvec2<T>(
             sin(angle.x),
             sin(angle.y));
     }
 
-    template <typename valType>
+    template <typename T>
-    inline detail::tvec3<valType> sin
+    inline detail::tvec3<T> sin
 	(
-		detail::tvec3<valType> const & angle
+		detail::tvec3<T> const & angle
 	)
     {
-        return detail::tvec3<valType>(
+        return detail::tvec3<T>(
             sin(angle.x),
             sin(angle.y),
             sin(angle.z));
     }
 
-    template <typename valType>
+    template <typename T>
-    inline detail::tvec4<valType> sin
+    inline detail::tvec4<T> sin
 	(
-		detail::tvec4<valType> const & angle
+		detail::tvec4<T> const & angle
 	)
     {
-        return detail::tvec4<valType>(
+        return detail::tvec4<T>(
             sin(angle.x),
             sin(angle.y),
             sin(angle.z),
@@ -168,36 +168,36 @@ namespace glm
         return ::std::cos(angle);
     }
 
-    template <typename valType>
+    template <typename T>
-    inline detail::tvec2<valType> cos
+    inline detail::tvec2<T> cos
 	(
-		detail::tvec2<valType> const & angle
+		detail::tvec2<T> const & angle
 	)
     {
-        return detail::tvec2<valType>(
+        return detail::tvec2<T>(
             cos(angle.x),
             cos(angle.y));
     }
 
-    template <typename valType>
+    template <typename T>
-    inline detail::tvec3<valType> cos
+    inline detail::tvec3<T> cos
 	(
-		detail::tvec3<valType> const & angle
+		detail::tvec3<T> const & angle
 	)
     {
-        return detail::tvec3<valType>(
+        return detail::tvec3<T>(
             cos(angle.x),
             cos(angle.y),
             cos(angle.z));
     }
 
-    template <typename valType>
+    template <typename T>
-    inline detail::tvec4<valType> cos
+    inline detail::tvec4<T> cos
 	(	
-		detail::tvec4<valType> const & angle
+		detail::tvec4<T> const & angle
 	)
     {
-        return detail::tvec4<valType>(
+        return detail::tvec4<T>(
             cos(angle.x),
             cos(angle.y),
             cos(angle.z),
@@ -216,36 +216,36 @@ namespace glm
         return ::std::tan(angle);
     }
 
-    template <typename valType>
+    template <typename T>
-    inline detail::tvec2<valType> tan
+    inline detail::tvec2<T> tan
 	(
-		detail::tvec2<valType> const & angle
+		detail::tvec2<T> const & angle
 	)
     {
-        return detail::tvec2<valType>(
+        return detail::tvec2<T>(
             tan(angle.x),
             tan(angle.y));
     }
 
-    template <typename valType>
+    template <typename T>
-    inline detail::tvec3<valType> tan
+    inline detail::tvec3<T> tan
 	(
-		detail::tvec3<valType> const & angle
+		detail::tvec3<T> const & angle
 	)
     {
-        return detail::tvec3<valType>(
+        return detail::tvec3<T>(
             tan(angle.x),
             tan(angle.y),
             tan(angle.z));
     }
 
-    template <typename valType>
+    template <typename T>
-    inline detail::tvec4<valType> tan
+    inline detail::tvec4<T> tan
 	(
-		detail::tvec4<valType> const & angle
+		detail::tvec4<T> const & angle
 	)
     {
-        return detail::tvec4<valType>(
+        return detail::tvec4<T>(
             tan(angle.x),
             tan(angle.y),
             tan(angle.z),
@@ -264,36 +264,36 @@ namespace glm
         return ::std::asin(x);
     }
 
-    template <typename valType>
+    template <typename T>
-	inline detail::tvec2<valType> asin
+	inline detail::tvec2<T> asin
 	(
-		detail::tvec2<valType> const & x
+		detail::tvec2<T> const & x
 	)
     {
-        return detail::tvec2<valType>(
+        return detail::tvec2<T>(
             asin(x.x),
             asin(x.y));
     }
 
-    template <typename valType>
+    template <typename T>
-	inline detail::tvec3<valType> asin
+	inline detail::tvec3<T> asin
 	(
-		detail::tvec3<valType> const & x
+		detail::tvec3<T> const & x
 	)
     {
-        return detail::tvec3<valType>(
+        return detail::tvec3<T>(
             asin(x.x),
             asin(x.y),
             asin(x.z));
     }
 
-    template <typename valType>
+    template <typename T>
-	inline detail::tvec4<valType> asin
+	inline detail::tvec4<T> asin
 	(
-		detail::tvec4<valType> const & x
+		detail::tvec4<T> const & x
 	)
     {
-        return detail::tvec4<valType>(
+        return detail::tvec4<T>(
             asin(x.x),
             asin(x.y),
             asin(x.z),
@@ -312,36 +312,36 @@ namespace glm
         return ::std::acos(x);
     }
 
-    template <typename valType>
+    template <typename T>
-	inline detail::tvec2<valType> acos
+	inline detail::tvec2<T> acos
 	(
-		detail::tvec2<valType> const & x
+		detail::tvec2<T> const & x
 	)
     {
-        return detail::tvec2<valType>(
+        return detail::tvec2<T>(
             acos(x.x),
             acos(x.y));
     }
 
-    template <typename valType>
+    template <typename T>
-	inline detail::tvec3<valType> acos
+	inline detail::tvec3<T> acos
 	(
-		detail::tvec3<valType> const & x
+		detail::tvec3<T> const & x
 	)
     {
-        return detail::tvec3<valType>(
+        return detail::tvec3<T>(
             acos(x.x),
             acos(x.y),
             acos(x.z));
     }
 
-    template <typename valType>
+    template <typename T>
-	inline detail::tvec4<valType> acos
+	inline detail::tvec4<T> acos
 	(
-		detail::tvec4<valType> const & x
+		detail::tvec4<T> const & x
 	)
     {
-        return detail::tvec4<valType>(
+        return detail::tvec4<T>(
             acos(x.x),
             acos(x.y),
             acos(x.z),
@@ -361,39 +361,39 @@ namespace glm
         return ::std::atan2(y, x);
     }
 
-    template <typename valType>
+    template <typename T>
-    inline detail::tvec2<valType> atan
+    inline detail::tvec2<T> atan
 	(
-		detail::tvec2<valType> const & y, 
+		detail::tvec2<T> const & y, 
-		detail::tvec2<valType> const & x
+		detail::tvec2<T> const & x
 	)
     {
-        return detail::tvec2<valType>(
+        return detail::tvec2<T>(
             atan(y.x, x.x),
             atan(y.y, x.y));
     }
 
-    template <typename valType>
+    template <typename T>
-    inline detail::tvec3<valType> atan
+    inline detail::tvec3<T> atan
 	(
-		detail::tvec3<valType> const & y, 
+		detail::tvec3<T> const & y, 
-		detail::tvec3<valType> const & x
+		detail::tvec3<T> const & x
 	)
     {
-        return detail::tvec3<valType>(
+        return detail::tvec3<T>(
             atan(y.x, x.x),
             atan(y.y, x.y),
             atan(y.z, x.z));
     }
 
-    template <typename valType>
+    template <typename T>
-    inline detail::tvec4<valType> atan
+    inline detail::tvec4<T> atan
 	(
-		detail::tvec4<valType> const & y, 
+		detail::tvec4<T> const & y, 
-		detail::tvec4<valType> const & x
+		detail::tvec4<T> const & x
 	)
     {
-        return detail::tvec4<valType>(
+        return detail::tvec4<T>(
             atan(y.x, x.x),
             atan(y.y, x.y),
             atan(y.z, x.z),
@@ -411,36 +411,36 @@ namespace glm
         return ::std::atan(x);
     }
 
-    template <typename valType>
+    template <typename T>
-    inline detail::tvec2<valType> atan
+    inline detail::tvec2<T> atan
 	(
-		detail::tvec2<valType> const & x
+		detail::tvec2<T> const & x
 	)
     {
-        return detail::tvec2<valType>(
+        return detail::tvec2<T>(
             atan(x.x),
             atan(x.y));
     }
 
-    template <typename valType>
+    template <typename T>
-    inline detail::tvec3<valType> atan
+    inline detail::tvec3<T> atan
 	(
-		detail::tvec3<valType> const & x
+		detail::tvec3<T> const & x
 	)
     {
-        return detail::tvec3<valType>(
+        return detail::tvec3<T>(
             atan(x.x),
             atan(x.y),
             atan(x.z));
     }
 
-    template <typename valType>
+    template <typename T>
-    inline detail::tvec4<valType> atan
+    inline detail::tvec4<T> atan
 	(
-		detail::tvec4<valType> const & x
+		detail::tvec4<T> const & x
 	)
     {
-        return detail::tvec4<valType>(
+        return detail::tvec4<T>(
             atan(x.x),
             atan(x.y),
             atan(x.z),
@@ -459,36 +459,36 @@ namespace glm
 		return std::sinh(angle);
     }
 
-    template <typename valType> 
+    template <typename T> 
-    inline detail::tvec2<valType> sinh
+    inline detail::tvec2<T> sinh
 	(
-		detail::tvec2<valType> const & angle
+		detail::tvec2<T> const & angle
 	)
     {
-        return detail::tvec2<valType>(
+        return detail::tvec2<T>(
             sinh(angle.x),
             sinh(angle.y));
     }
 
-    template <typename valType> 
+    template <typename T> 
-    inline detail::tvec3<valType> sinh
+    inline detail::tvec3<T> sinh
 	(
-		detail::tvec3<valType> const & angle
+		detail::tvec3<T> const & angle
 	)
     {
-        return detail::tvec3<valType>(
+        return detail::tvec3<T>(
             sinh(angle.x),
             sinh(angle.y),
             sinh(angle.z));
     }
 
-    template <typename valType> 
+    template <typename T> 
-    inline detail::tvec4<valType> sinh
+    inline detail::tvec4<T> sinh
 	(
-		detail::tvec4<valType> const & angle
+		detail::tvec4<T> const & angle
 	)
     {
-        return detail::tvec4<valType>(
+        return detail::tvec4<T>(
             sinh(angle.x),
             sinh(angle.y),
             sinh(angle.z),
@@ -507,36 +507,36 @@ namespace glm
 		return std::cosh(angle);
     }
 
-    template <typename valType> 
+    template <typename T> 
-    inline detail::tvec2<valType> cosh
+    inline detail::tvec2<T> cosh
 	(
-		detail::tvec2<valType> const & angle
+		detail::tvec2<T> const & angle
 	)
     {
-        return detail::tvec2<valType>(
+        return detail::tvec2<T>(
             cosh(angle.x),
             cosh(angle.y));
     }
 
-    template <typename valType> 
+    template <typename T> 
-    inline detail::tvec3<valType> cosh
+    inline detail::tvec3<T> cosh
 	(
-		detail::tvec3<valType> const & angle
+		detail::tvec3<T> const & angle
 	)
     {
-        return detail::tvec3<valType>(
+        return detail::tvec3<T>(
             cosh(angle.x),
             cosh(angle.y),
             cosh(angle.z));
     }
 
-    template <typename valType> 
+    template <typename T> 
-    inline detail::tvec4<valType> cosh
+    inline detail::tvec4<T> cosh
 	(
-		detail::tvec4<valType> const & angle
+		detail::tvec4<T> const & angle
 	)
     {
-        return detail::tvec4<valType>(
+        return detail::tvec4<T>(
             cosh(angle.x),
             cosh(angle.y),
             cosh(angle.z),
@@ -555,36 +555,36 @@ namespace glm
 		return std::tanh(angle);
     }
 
-    template <typename valType> 
+    template <typename T> 
-    inline detail::tvec2<valType> tanh
+    inline detail::tvec2<T> tanh
 	(
-		detail::tvec2<valType> const & angle
+		detail::tvec2<T> const & angle
 	)
     {
-        return detail::tvec2<valType>(
+        return detail::tvec2<T>(
             tanh(angle.x),
             tanh(angle.y));
     }
 
-    template <typename valType> 
+    template <typename T> 
-    inline detail::tvec3<valType> tanh
+    inline detail::tvec3<T> tanh
 	(
-		detail::tvec3<valType> const & angle
+		detail::tvec3<T> const & angle
 	)
     {
-        return detail::tvec3<valType>(
+        return detail::tvec3<T>(
             tanh(angle.x),
             tanh(angle.y),
             tanh(angle.z));
     }
 
-    template <typename valType> 
+    template <typename T> 
-    inline detail::tvec4<valType> tanh
+    inline detail::tvec4<T> tanh
 	(
-		detail::tvec4<valType> const & angle
+		detail::tvec4<T> const & angle
 	)
     {
-        return detail::tvec4<valType>(
+        return detail::tvec4<T>(
             tanh(angle.x),
             tanh(angle.y),
             tanh(angle.z),
@@ -603,36 +603,36 @@ namespace glm
 		return (x < genType(0) ? genType(-1) : (x > genType(0) ? genType(1) : genType(0))) * log(abs(x) + sqrt(genType(1) + x * x));
     }
 
-    template <typename valType> 
+    template <typename T> 
-    inline detail::tvec2<valType> asinh
+    inline detail::tvec2<T> asinh
 	(
-		detail::tvec2<valType> const & x
+		detail::tvec2<T> const & x
 	)
     {
-        return detail::tvec2<valType>(
+        return detail::tvec2<T>(
             asinh(x.x),
             asinh(x.y));
     }
 
-    template <typename valType> 
+    template <typename T> 
-    inline detail::tvec3<valType> asinh
+    inline detail::tvec3<T> asinh
 	(
-		detail::tvec3<valType> const & x
+		detail::tvec3<T> const & x
 	)
     {
-        return detail::tvec3<valType>(
+        return detail::tvec3<T>(
             asinh(x.x),
             asinh(x.y),
             asinh(x.z));
     }
 
-    template <typename valType> 
+    template <typename T> 
-    inline detail::tvec4<valType> asinh
+    inline detail::tvec4<T> asinh
 	(
-		detail::tvec4<valType> const & x
+		detail::tvec4<T> const & x
 	)
     {
-        return detail::tvec4<valType>(
+        return detail::tvec4<T>(
             asinh(x.x),
             asinh(x.y),
             asinh(x.z),
@@ -653,36 +653,36 @@ namespace glm
 		return log(x + sqrt(x * x - genType(1)));
     }
 
-	template <typename valType> 
+	template <typename T> 
-	inline detail::tvec2<valType> acosh
+	inline detail::tvec2<T> acosh
 	(
-		detail::tvec2<valType> const & x
+		detail::tvec2<T> const & x
 	)
 	{
-		return detail::tvec2<valType>(
+		return detail::tvec2<T>(
 			acosh(x.x),
 			acosh(x.y));
 	}
 
-    template <typename valType> 
+    template <typename T> 
-    inline detail::tvec3<valType> acosh
+    inline detail::tvec3<T> acosh
 	(
-		detail::tvec3<valType> const & x
+		detail::tvec3<T> const & x
 	)
     {
-        return detail::tvec3<valType>(
+        return detail::tvec3<T>(
             acosh(x.x),
             acosh(x.y),
             acosh(x.z));
     }
 
-    template <typename valType> 
+    template <typename T> 
-    inline detail::tvec4<valType> acosh
+    inline detail::tvec4<T> acosh
 	(
-		detail::tvec4<valType> const & x
+		detail::tvec4<T> const & x
 	)
     {
-        return detail::tvec4<valType>(
+        return detail::tvec4<T>(
             acosh(x.x),
             acosh(x.y),
             acosh(x.z),
@@ -703,36 +703,36 @@ namespace glm
 		return genType(0.5) * log((genType(1) + x) / (genType(1) - x));
     }
 
-    template <typename valType> 
+    template <typename T> 
-    inline detail::tvec2<valType> atanh
+    inline detail::tvec2<T> atanh
 	(
-		detail::tvec2<valType> const & x
+		detail::tvec2<T> const & x
 	)
     {
-        return detail::tvec2<valType>(
+        return detail::tvec2<T>(
             atanh(x.x),
             atanh(x.y));
     }
 
-    template <typename valType> 
+    template <typename T> 
-    inline detail::tvec3<valType> atanh
+    inline detail::tvec3<T> atanh
 	(
-		detail::tvec3<valType> const & x
+		detail::tvec3<T> const & x
 	)
     {
-        return detail::tvec3<valType>(
+        return detail::tvec3<T>(
             atanh(x.x),
             atanh(x.y),
             atanh(x.z));
     }
 
-    template <typename valType> 
+    template <typename T> 
-    inline detail::tvec4<valType> atanh
+    inline detail::tvec4<T> atanh
 	(
-		detail::tvec4<valType> const & x
+		detail::tvec4<T> const & x
 	)
     {
-        return detail::tvec4<valType>(
+        return detail::tvec4<T>(
             atanh(x.x),
             atanh(x.y),
             atanh(x.z),

glm/core/func_vector_relational.hpp

@@ -1,10 +1,10 @@
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-// OpenGL Mathematics Copyright (c) 2005 - 2009 G-Truc Creation (www.g-truc.net)
+// 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.h
+// File    : glm/core/func_vector_relational.hpp
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 #ifndef glm_core_func_vector_relational
@@ -18,53 +18,164 @@ namespace glm
 
 	namespace core{
 	namespace function{
-	//! Define vector relational functions from Section 8.3 of GLSL 1.30.8 specification. Included in glm namespace.
+	//! Define vector relational functions from Section 8.3 of GLSL 1.30.8 specification. 
-	namespace vector_relational{
+	//! Included in glm namespace.
-
+	namespace vector_relational
-	//! Returns the component-wise compare of x < y.
+	{
+		//! Returns the component-wise comparison result of x < y.
 		//! (From GLSL 1.30.08 specification, section 8.6)
-	template <typename vecType> 
+		template <typename T, template <typename> class vecType> 
-	typename vecType::bool_type lessThan(vecType const & x, vecType const & y);
+		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);
 
-	//! Returns the component-wise compare of x <= y.
+			typename vecType<bool>::bool_type Result(vecType<bool>::null);
-	//! (From GLSL 1.30.08 specification, section 8.6)
+			for(typename vecType<bool>::size_type i = 0; i < vecType<bool>::value_size(); ++i)
-    template <typename vecType> 
+				Result[i] = x[i] < y[i];
-	typename vecType::bool_type lessThanEqual(vecType const & x, vecType const & y);
+			return Result;
+		}
 
-	//! Returns the component-wise compare of x > y.
+		//! Returns the component-wise comparison of result x <= y.
 		//! (From GLSL 1.30.08 specification, section 8.6)
-    template <typename vecType> 
+		template <typename T, template <typename> class vecType> 
-	typename vecType::bool_type greaterThan(vecType const & x, vecType const & y);
+		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);
 
-	//! Returns the component-wise compare of x >= y.
+			typename vecType<bool>::bool_type Result(vecType<bool>::null);
-	//! (From GLSL 1.30.08 specification, section 8.6)
+			for(typename vecType<bool>::size_type i = 0; i < vecType<bool>::value_size(); ++i)
-    template <typename vecType> 
+				Result[i] = x[i] <= y[i];
-	typename vecType::bool_type greaterThanEqual(vecType const & x, vecType const & y);
+			return Result;
+		}
 
-	//! Returns the component-wise compare of x == y.
+		//! Returns the component-wise comparison of result x > y.
 		//! (From GLSL 1.30.08 specification, section 8.6)
-    template <typename vecType> 
+		template <typename T, template <typename> class vecType> 
-	typename vecType::bool_type equal(vecType const & x, vecType const & y);
+		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);
 
-	//! Returns the component-wise compare of x != y.
+			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 vecType> 
+		template <typename T, template <typename> class vecType> 
-	typename vecType::bool_type notEqual(vecType const & x, vecType const & y);
+		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 <typename vecType> 
+		template <template <typename> class vecType> 
-	bool any(vecType const & x);
+		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 <typename vecType> 
+		template <template <typename> class vecType> 
-	bool all(vecType const & x);
+		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 <typename vecType> 
+		template <template <typename> class vecType> 
-	typename vecType::bool_type not_(vecType const & x);
+		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

glm/core/func_vector_relational.inl

@@ -1,5 +1,5 @@
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-// OpenGL Mathematics Copyright (c) 2005 - 2009 G-Truc Creation (www.g-truc.net)
+// OpenGL Mathematics Copyright (c) 2005 - 2010 G-Truc Creation (www.g-truc.net)
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 // Created : 2008-08-03
 // Updated : 2008-09-14
@@ -13,345 +13,6 @@ namespace glm
 	namespace function{
 	namespace vector_relational{
 
-    // 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);
-    }
-
 	}//namespace vector_relational
 	}//namespace function
 	}//namespace core

glm/core/hint.hpp

@@ -1,10 +1,10 @@
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-// OpenGL Mathematics Copyright (c) 2005 - 2009 G-Truc Creation (www.g-truc.net)
+// 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.h
+// File    : glm/core/hint.hpp
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 #ifndef glm_core_type

glm/core/intrinsic_common.hpp

@@ -1,5 +1,5 @@
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-// OpenGL Mathematics Copyright (c) 2005 - 2009 G-Truc Creation (www.g-truc.net)
+// OpenGL Mathematics Copyright (c) 2005 - 2010 G-Truc Creation (www.g-truc.net)
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 // Created : 2009-05-11
 // Updated : 2009-05-11

glm/core/intrinsic_common.inl

@@ -1,5 +1,5 @@
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-// OpenGL Mathematics Copyright (c) 2005 - 2009 G-Truc Creation (www.g-truc.net)
+// OpenGL Mathematics Copyright (c) 2005 - 2010 G-Truc Creation (www.g-truc.net)
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 // Created : 2009-05-08
 // Updated : 2009-05-08

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

@@ -1,5 +1,5 @@
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-// OpenGL Mathematics Copyright (c) 2005 - 2009 G-Truc Creation (www.g-truc.net)
+// OpenGL Mathematics Copyright (c) 2005 - 2010 G-Truc Creation (www.g-truc.net)
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 // Created : 2009-05-08
 // Updated : 2009-05-08

glm/core/intrinsic_geometric.inl

@@ -1,5 +1,5 @@
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-// OpenGL Mathematics Copyright (c) 2005 - 2009 G-Truc Creation (www.g-truc.net)
+// OpenGL Mathematics Copyright (c) 2005 - 2010 G-Truc Creation (www.g-truc.net)
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 // Created : 2009-05-08
 // Updated : 2009-05-08

glm/core/intrinsic_matrix.hpp

@@ -1,5 +1,5 @@
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-// OpenGL Mathematics Copyright (c) 2005 - 2009 G-Truc Creation (www.g-truc.net)
+// OpenGL Mathematics Copyright (c) 2005 - 2010 G-Truc Creation (www.g-truc.net)
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 // Created : 2009-06-05
 // Updated : 2009-06-05

glm/core/intrinsic_matrix.inl

@@ -1,5 +1,5 @@
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-// OpenGL Mathematics Copyright (c) 2005 - 2009 G-Truc Creation (www.g-truc.net)
+// OpenGL Mathematics Copyright (c) 2005 - 2010 G-Truc Creation (www.g-truc.net)
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 // Created : 2009-06-05
 // Updated : 2009-06-05

glm/core/intrinsic_vector_relational.hpp

@@ -1,5 +1,5 @@
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-// OpenGL Mathematics Copyright (c) 2005 - 2009 G-Truc Creation (www.g-truc.net)
+// OpenGL Mathematics Copyright (c) 2005 - 2010 G-Truc Creation (www.g-truc.net)
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 // Created : 2009-06-09
 // Updated : 2009-06-09

glm/core/intrinsic_vector_relational.inl

@@ -1,5 +1,5 @@
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-// OpenGL Mathematics Copyright (c) 2005 - 2009 G-Truc Creation (www.g-truc.net)
+// OpenGL Mathematics Copyright (c) 2005 - 2010 G-Truc Creation (www.g-truc.net)
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 // Created : 2009-06-09
 // Updated : 2009-06-09

glm/core/type.hpp

@@ -1,10 +1,10 @@
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-// OpenGL Mathematics Copyright (c) 2005 - 2009 G-Truc Creation (www.g-truc.net)
+// 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.h
+// File    : glm/core/type.hpp
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 #ifndef glm_core_type
@@ -31,4 +31,253 @@
 #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

@@ -1,8 +1,8 @@
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-// OpenGL Mathematics Copyright (c) 2005 - 2009 G-Truc Creation (www.g-truc.net)
+// OpenGL Mathematics Copyright (c) 2005 - 2010 G-Truc Creation (www.g-truc.net)
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 // Created : 2008-08-22
-// Updated : 2008-09-17
+// Updated : 2010-02-08
 // Licence : This source is under MIT License
 // File    : glm/core/type_float.hpp
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -26,7 +26,6 @@ namespace glm
 
 	namespace core{
 	namespace type{
-	namespace scalar{
 
 	namespace precision
 	{
@@ -54,19 +53,18 @@ namespace glm
 	//namespace precision
 
 #ifndef GLM_PRECISION 
-	typedef precision::mediump_float_t		float_t;
+	typedef precision::mediump_float		float_t;
 #elif(GLM_PRECISION & GLM_PRECISION_HIGHP_FLOAT)
-	typedef precision::highp_float_t		float_t;
+	typedef precision::highp_float			float_t;
 #elif(GLM_PRECISION & GLM_PRECISION_MEDIUMP_FLOAT)
-	typedef precision::mediump_float_t		float_t;
+	typedef precision::mediump_float		float_t;
 #elif(GLM_PRECISION & GLM_PRECISION_LOWP_FLOAT)
-	typedef precision::lowp_float_t			float_t;
+	typedef precision::lowp_float			float_t;
 #else
 	#	pragma message("GLM message: Precisson undefined for float numbers.");
-	typedef precision::mediump_float_t		float_t;
+	typedef precision::mediump_float		float_t;
 #endif//GLM_PRECISION
 
-	}//namespace scalar
 	}//namespace type
 	}//namespace core
 }//namespace glm

glm/core/type_gentype.hpp

@@ -1,10 +1,10 @@
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-// OpenGL Mathematics Copyright (c) 2005 - 2009 G-Truc Creation (www.g-truc.net)
+// OpenGL Mathematics Copyright (c) 2005 - 2010 G-Truc Creation (www.g-truc.net)
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 // Created : 2008-10-05
-// Updated : 2008-10-05
+// Updated : 2010-01-26
 // Licence : This source is under MIT License
-// File    : glm/core/type_gentype.h
+// File    : glm/core/type_gentype.hpp
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 #ifndef glm_core_type_gentype
@@ -12,33 +12,89 @@
 
 #include "type_size.hpp"
 
-namespace glm{
+namespace glm
-
-enum profile
 {
+	enum profile
+	{
 		nice,
 		fast,
 		simd
-};
+	};
 
-namespace detail{
+namespace detail
-
-template <typename valTypeT, uint colT, uint rowT, profile proT = nice>
-class genType
 {
-public:
+	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 genType<value_type, colT, rowT>		class_type;
+		typedef base<value_type, colT, rowT>		class_type;
 
-	typedef genType<bool, colT, rowT>			bool_type;
+		typedef base<bool, colT, rowT>				bool_type;
-	typedef genType<value_type, rowT, 1>		col_type;
+		typedef base<value_type, rowT, 1>			col_type;
-	typedef genType<value_type, colT, 1>		row_type;
+		typedef base<value_type, colT, 1>			row_type;
-	typedef genType<value_type, rowT, colT>		transpose_type;
+		typedef base<value_type, rowT, colT>		transpose_type;
 
 		static size_type							col_size();
 		static size_type							row_size();
@@ -47,24 +103,24 @@ public:
 		static bool									is_vector();
 		static bool									is_matrix();
 
-private:
+	private:
 		// Data 
 		col_type value[colT];		
 
-public:
+	public:
 		//////////////////////////////////////
 		// Constructors
-	genType();
+		base();
-	genType(class_type const & m);
+		base(class_type const & m);
 
-	explicit genType(value_type const & x);
+		explicit base(value_type const & x);
-	explicit genType(value_type const * const x);
+		explicit base(value_type const * const x);
-	explicit genType(col_type const * const x);
+		explicit base(col_type const * const x);
 
 		//////////////////////////////////////
 		// Conversions
 		template <typename vU, uint cU, uint rU, profile pU>
-	explicit genType(genType<vU, cU, rU, pU> const & m);
+		explicit base(base<vU, cU, rU, pU> const & m);
 
 		//////////////////////////////////////
 		// Accesses
@@ -84,11 +140,11 @@ public:
 		class_type& operator/= (class_type const & x);
 		class_type& operator++ ();
 		class_type& operator-- ();
-};
+	};
-
+*/
-}//namespace detail
+	}//namespace detail
 }//namespace glm
 
-#include "type_gentype.inl"
+//#include "type_gentype.inl"
 
 #endif//glm_core_type_gentype

glm/core/type_gentype.inl

@@ -1,5 +1,5 @@
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-// OpenGL Mathematics Copyright (c) 2005 - 2009 G-Truc Creation (www.g-truc.net)
+// OpenGL Mathematics Copyright (c) 2005 - 2010 G-Truc Creation (www.g-truc.net)
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 // Created : 2008-10-05
 // Updated : 2008-10-05
@@ -14,37 +14,37 @@ namespace detail{
 // Static functions
 
 template <typename vT, uint cT, uint rT, profile pT>
-typename genType<vT, cT, rT, pT>::size_type genType<vT, cT, rT, pT>::col_size()
+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 genType<vT, cT, rT, pT>::size_type genType<vT, cT, rT, pT>::row_size()
+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 genType<vT, cT, rT, pT>::size_type genType<vT, cT, rT, pT>::value_size()
+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 genType<vT, cT, rT, pT>::is_scalar()
+bool base<vT, cT, rT, pT>::is_scalar()
 {
 	return rT == 1 && cT == 1;
 }
 
 template <typename vT, uint cT, uint rT, profile pT>
-bool genType<vT, cT, rT, pT>::is_vector()
+bool base<vT, cT, rT, pT>::is_vector()
 {
 	return rT == 1;
 }
 
 template <typename vT, uint cT, uint rT, profile pT>
-bool genType<vT, cT, rT, pT>::is_matrix()
+bool base<vT, cT, rT, pT>::is_matrix()
 {
 	return rT != 1;
 }
@@ -53,21 +53,21 @@ bool genType<vT, cT, rT, pT>::is_matrix()
 // Constructor
 
 template <typename vT, uint cT, uint rT, profile pT>
-genType<vT, cT, rT, pT>::genType()
+base<vT, cT, rT, pT>::base()
 {
 	memset(&this->value, 0, cT * rT * sizeof(vT));
 }
 
 template <typename vT, uint cT, uint rT, profile pT>
-genType<vT, cT, rT, pT>::genType
+base<vT, cT, rT, pT>::base
 (
-	typename genType<vT, cT, rT, pT>::class_type const & m
+	typename base<vT, cT, rT, pT>::class_type const & m
 )
 {
 	for
 	(
-		typename genType<vT, cT, rT, pT>::size_type i = typename genType<vT, cT, rT, pT>::size_type(0);
+		typename genType<vT, cT, rT, pT>::size_type i = typename base<vT, cT, rT, pT>::size_type(0);
-		i < genType<vT, cT, rT, pT>::col_size();
+		i < base<vT, cT, rT, pT>::col_size();
 		++i
 	)
 	{
@@ -76,17 +76,17 @@ genType<vT, cT, rT, pT>::genType
 }
 
 template <typename vT, uint cT, uint rT, profile pT>
-genType<vT, cT, rT, pT>::genType
+base<vT, cT, rT, pT>::base
 (
-	typename genType<vT, cT, rT, pT>::value_type const & x
+	typename base<vT, cT, rT, pT>::value_type const & x
 )
 {
 	if(rT == 1) // vector
 	{
 		for
 		(
-			typename genType<vT, cT, rT, pT>::size_type i = typename genType<vT, cT, rT, pT>::size_type(0);
+			typename base<vT, cT, rT, pT>::size_type i = typename base<vT, cT, rT, pT>::size_type(0);
-			i < genType<vT, cT, rT, pT>::col_size();
+			i < base<vT, cT, rT, pT>::col_size();
 			++i
 		)
 		{
@@ -97,11 +97,11 @@ genType<vT, cT, rT, pT>::genType
 	{
 		memset(&this->value, 0, cT * rT * sizeof(vT));
 
-		typename genType<vT, cT, rT, pT>::size_type stop = cT < rT ? cT : rT;
+		typename base<vT, cT, rT, pT>::size_type stop = cT < rT ? cT : rT;
 
 		for
 		(
-			typename genType<vT, cT, rT, pT>::size_type i = typename genType<vT, cT, rT, pT>::size_type(0);
+			typename base<vT, cT, rT, pT>::size_type i = typename base<vT, cT, rT, pT>::size_type(0);
 			i < stop;
 			++i
 		)
@@ -112,24 +112,24 @@ genType<vT, cT, rT, pT>::genType
 }
 
 template <typename vT, uint cT, uint rT, profile pT>
-genType<vT, cT, rT, pT>::genType
+base<vT, cT, rT, pT>::base
 (
-	typename genType<vT, cT, rT, pT>::value_type const * const x
+	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>
-genType<vT, cT, rT, pT>::genType
+base<vT, cT, rT, pT>::base
 (
-	typename genType<vT, cT, rT, pT>::col_type const * const x
+	typename base<vT, cT, rT, pT>::col_type const * const x
 )
 {
 	for
 	(
-		typename genType<vT, cT, rT, pT>::size_type i = typename genType<vT, cT, rT, pT>::size_type(0);
+		typename base<vT, cT, rT, pT>::size_type i = typename base<vT, cT, rT, pT>::size_type(0);
-		i < genType<vT, cT, rT, pT>::col_size();
+		i < base<vT, cT, rT, pT>::col_size();
 		++i
 	)
 	{
@@ -139,19 +139,19 @@ genType<vT, cT, rT, pT>::genType
 
 template <typename vT, uint cT, uint rT, profile pT>
 template <typename vU, uint cU, uint rU, profile pU>
-genType<vT, cT, rT, pT>::genType
+base<vT, cT, rT, pT>::base
 (
-	genType<vU, cU, rU, pU> const & m
+	base<vU, cU, rU, pU> const & m
 )
 {
 	for
 	(
-		typename genType<vT, cT, rT, pT>::size_type i = typename genType<vT, cT, rT, pT>::size_type(0);
+		typename base<vT, cT, rT, pT>::size_type i = typename base<vT, cT, rT, pT>::size_type(0);
-		i < genType<vT, cT, rT, pT>::col_size();
+		i < base<vT, cT, rT, pT>::col_size();
 		++i
 	)
 	{
-		this->value[i] = genType<vT, cT, rT, pT>(m[i]);
+		this->value[i] = base<vT, cT, rT, pT>(m[i]);
 	}
 }
 
@@ -159,18 +159,18 @@ genType<vT, cT, rT, pT>::genType
 // Accesses
 
 template <typename vT, uint cT, uint rT, profile pT>
-typename genType<vT, cT, rT, pT>::col_type& genType<vT, cT, rT, pT>::operator[]
+typename base<vT, cT, rT, pT>::col_type& base<vT, cT, rT, pT>::operator[]
 (
-	typename genType<vT, cT, rT, pT>::size_type i
+	typename base<vT, cT, rT, pT>::size_type i
 )
 {
 	return this->value[i];
 }
 
 template <typename vT, uint cT, uint rT, profile pT>
-typename genType<vT, cT, rT, pT>::col_type const & genType<vT, cT, rT, pT>::operator[]
+typename base<vT, cT, rT, pT>::col_type const & base<vT, cT, rT, pT>::operator[]
 (
-	typename genType<vT, cT, rT, pT>::size_type i
+	typename base<vT, cT, rT, pT>::size_type i
 ) const
 {
 	return this->value[i];
@@ -180,9 +180,9 @@ typename genType<vT, cT, rT, pT>::col_type const & genType<vT, cT, rT, pT>::oper
 // Unary updatable operators
 
 template <typename vT, uint cT, uint rT, profile pT>
-typename genType<vT, cT, rT, pT>::class_type& genType<vT, cT, rT, pT>::operator= 
+typename base<vT, cT, rT, pT>::class_type& base<vT, cT, rT, pT>::operator= 
 (
-	typename genType<vT, cT, rT, pT>::class_type const & x
+	typename base<vT, cT, rT, pT>::class_type const & x
 )
 {
 	memcpy(&this->value, &x.value, cT * rT * sizeof(vT));
@@ -190,154 +190,154 @@ typename genType<vT, cT, rT, pT>::class_type& genType<vT, cT, rT, pT>::operator=
 }
 
 template <typename vT, uint cT, uint rT, profile pT>
-typename genType<vT, cT, rT, pT>::class_type& genType<vT, cT, rT, pT>::operator+= 
+typename base<vT, cT, rT, pT>::class_type& base<vT, cT, rT, pT>::operator+= 
 (
-	typename genType<vT, cT, rT, pT>::value_type const & x
+	typename base<vT, cT, rT, pT>::value_type const & x
 )
 {
-	typename genType<vT, cT, rT, pT>::size_type stop_col = x.col_size();
+	typename base<vT, cT, rT, pT>::size_type stop_col = x.col_size();
-	typename genType<vT, cT, rT, pT>::size_type stop_row = x.row_size();
+	typename base<vT, cT, rT, pT>::size_type stop_row = x.row_size();
 
-	for(typename genType<vT, cT, rT, pT>::size_type j = 0; j < stop_col; ++j)
+	for(typename base<vT, cT, rT, pT>::size_type j = 0; j < stop_col; ++j)
-	for(typename genType<vT, cT, rT, pT>::size_type i = 0; i < stop_row; ++i)
+	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 genType<vT, cT, rT, pT>::class_type& genType<vT, cT, rT, pT>::operator+= 
+typename base<vT, cT, rT, pT>::class_type& base<vT, cT, rT, pT>::operator+= 
 (
-	typename genType<vT, cT, rT, pT>::class_type const & x
+	typename base<vT, cT, rT, pT>::class_type const & x
 )
 {
-	typename genType<vT, cT, rT, pT>::size_type stop_col = x.col_size();
+	typename base<vT, cT, rT, pT>::size_type stop_col = x.col_size();
-	typename genType<vT, cT, rT, pT>::size_type stop_row = x.row_size();
+	typename base<vT, cT, rT, pT>::size_type stop_row = x.row_size();
 
-	for(typename genType<vT, cT, rT, pT>::size_type j = 0; j < stop_col; ++j)
+	for(typename base<vT, cT, rT, pT>::size_type j = 0; j < stop_col; ++j)
-	for(typename genType<vT, cT, rT, pT>::size_type i = 0; i < stop_row; ++i)
+	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 genType<vT, cT, rT, pT>::class_type& genType<vT, cT, rT, pT>::operator-= 
+typename base<vT, cT, rT, pT>::class_type& base<vT, cT, rT, pT>::operator-= 
 (
-	typename genType<vT, cT, rT, pT>::value_type const & x
+	typename base<vT, cT, rT, pT>::value_type const & x
 )
 {
-	typename genType<vT, cT, rT, pT>::size_type stop_col = x.col_size();
+	typename base<vT, cT, rT, pT>::size_type stop_col = x.col_size();
-	typename genType<vT, cT, rT, pT>::size_type stop_row = x.row_size();
+	typename base<vT, cT, rT, pT>::size_type stop_row = x.row_size();
 
-	for(typename genType<vT, cT, rT, pT>::size_type j = 0; j < stop_col; ++j)
+	for(typename base<vT, cT, rT, pT>::size_type j = 0; j < stop_col; ++j)
-	for(typename genType<vT, cT, rT, pT>::size_type i = 0; i < stop_row; ++i)
+	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 genType<vT, cT, rT, pT>::class_type& genType<vT, cT, rT, pT>::operator-= 
+typename base<vT, cT, rT, pT>::class_type& base<vT, cT, rT, pT>::operator-= 
 (
-	typename genType<vT, cT, rT, pT>::class_type const & x
+	typename base<vT, cT, rT, pT>::class_type const & x
 )
 {
-	typename genType<vT, cT, rT, pT>::size_type stop_col = x.col_size();
+	typename base<vT, cT, rT, pT>::size_type stop_col = x.col_size();
-	typename genType<vT, cT, rT, pT>::size_type stop_row = x.row_size();
+	typename base<vT, cT, rT, pT>::size_type stop_row = x.row_size();
 
-	for(typename genType<vT, cT, rT, pT>::size_type j = 0; j < stop_col; ++j)
+	for(typename base<vT, cT, rT, pT>::size_type j = 0; j < stop_col; ++j)
-	for(typename genType<vT, cT, rT, pT>::size_type i = 0; i < stop_row; ++i)
+	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 genType<vT, cT, rT, pT>::class_type& genType<vT, cT, rT, pT>::operator*= 
+typename base<vT, cT, rT, pT>::class_type& base<vT, cT, rT, pT>::operator*= 
 (
-	typename genType<vT, cT, rT, pT>::value_type const & x
+	typename base<vT, cT, rT, pT>::value_type const & x
 )
 {
-	typename genType<vT, cT, rT, pT>::size_type stop_col = x.col_size();
+	typename base<vT, cT, rT, pT>::size_type stop_col = x.col_size();
-	typename genType<vT, cT, rT, pT>::size_type stop_row = x.row_size();
+	typename base<vT, cT, rT, pT>::size_type stop_row = x.row_size();
 
-	for(typename genType<vT, cT, rT, pT>::size_type j = 0; j < stop_col; ++j)
+	for(typename base<vT, cT, rT, pT>::size_type j = 0; j < stop_col; ++j)
-	for(typename genType<vT, cT, rT, pT>::size_type i = 0; i < stop_row; ++i)
+	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 genType<vT, cT, rT, pT>::class_type& genType<vT, cT, rT, pT>::operator*= 
+typename base<vT, cT, rT, pT>::class_type& base<vT, cT, rT, pT>::operator*= 
 (
-	typename genType<vT, cT, rT, pT>::class_type const & x
+	typename base<vT, cT, rT, pT>::class_type const & x
 )
 {
-	typename genType<vT, cT, rT, pT>::size_type stop_col = x.col_size();
+	typename base<vT, cT, rT, pT>::size_type stop_col = x.col_size();
-	typename genType<vT, cT, rT, pT>::size_type stop_row = x.row_size();
+	typename base<vT, cT, rT, pT>::size_type stop_row = x.row_size();
 
-	for(typename genType<vT, cT, rT, pT>::size_type j = 0; j < stop_col; ++j)
+	for(typename base<vT, cT, rT, pT>::size_type j = 0; j < stop_col; ++j)
-	for(typename genType<vT, cT, rT, pT>::size_type i = 0; i < stop_row; ++i)
+	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 genType<vT, cT, rT, pT>::class_type& genType<vT, cT, rT, pT>::operator/= 
+typename base<vT, cT, rT, pT>::class_type& base<vT, cT, rT, pT>::operator/= 
 (
-	typename genType<vT, cT, rT, pT>::value_type const & x
+	typename base<vT, cT, rT, pT>::value_type const & x
 )
 {
-	typename genType<vT, cT, rT, pT>::size_type stop_col = x.col_size();
+	typename base<vT, cT, rT, pT>::size_type stop_col = x.col_size();
-	typename genType<vT, cT, rT, pT>::size_type stop_row = x.row_size();
+	typename base<vT, cT, rT, pT>::size_type stop_row = x.row_size();
 
-	for(typename genType<vT, cT, rT, pT>::size_type j = 0; j < stop_col; ++j)
+	for(typename base<vT, cT, rT, pT>::size_type j = 0; j < stop_col; ++j)
-	for(typename genType<vT, cT, rT, pT>::size_type i = 0; i < stop_row; ++i)
+	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 genType<vT, cT, rT, pT>::class_type& genType<vT, cT, rT, pT>::operator/= 
+typename base<vT, cT, rT, pT>::class_type& base<vT, cT, rT, pT>::operator/= 
 (
-	typename genType<vT, cT, rT, pT>::class_type const & x
+	typename base<vT, cT, rT, pT>::class_type const & x
 )
 {
-	typename genType<vT, cT, rT, pT>::size_type stop_col = x.col_size();
+	typename base<vT, cT, rT, pT>::size_type stop_col = x.col_size();
-	typename genType<vT, cT, rT, pT>::size_type stop_row = x.row_size();
+	typename base<vT, cT, rT, pT>::size_type stop_row = x.row_size();
 
-	for(typename genType<vT, cT, rT, pT>::size_type j = 0; j < stop_col; ++j)
+	for(typename base<vT, cT, rT, pT>::size_type j = 0; j < stop_col; ++j)
-	for(typename genType<vT, cT, rT, pT>::size_type i = 0; i < stop_row; ++i)
+	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 genType<vT, cT, rT, pT>::class_type& genType<vT, cT, rT, pT>::operator++ ()
+typename base<vT, cT, rT, pT>::class_type& base<vT, cT, rT, pT>::operator++ ()
 {
-	typename genType<vT, cT, rT, pT>::size_type stop_col = col_size();
+	typename base<vT, cT, rT, pT>::size_type stop_col = col_size();
-	typename genType<vT, cT, rT, pT>::size_type stop_row = row_size();
+	typename base<vT, cT, rT, pT>::size_type stop_row = row_size();
 
-	for(typename genType<vT, cT, rT, pT>::size_type j = 0; j < stop_col; ++j)
+	for(typename base<vT, cT, rT, pT>::size_type j = 0; j < stop_col; ++j)
-	for(typename genType<vT, cT, rT, pT>::size_type i = 0; i < stop_row; ++i)
+	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 genType<vT, cT, rT, pT>::class_type& genType<vT, cT, rT, pT>::operator-- ()
+typename base<vT, cT, rT, pT>::class_type& base<vT, cT, rT, pT>::operator-- ()
 {
-	typename genType<vT, cT, rT, pT>::size_type stop_col = col_size();
+	typename base<vT, cT, rT, pT>::size_type stop_col = col_size();
-	typename genType<vT, cT, rT, pT>::size_type stop_row = row_size();
+	typename base<vT, cT, rT, pT>::size_type stop_row = row_size();
 
-	for(typename genType<vT, cT, rT, pT>::size_type j = 0; j < stop_col; ++j)
+	for(typename base<vT, cT, rT, pT>::size_type j = 0; j < stop_col; ++j)
-	for(typename genType<vT, cT, rT, pT>::size_type i = 0; i < stop_row; ++i)
+	for(typename base<vT, cT, rT, pT>::size_type i = 0; i < stop_row; ++i)
 		--this->value[j][i];
 
 	return *this;

glm/core/type_half.hpp

@@ -1,8 +1,8 @@
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-// OpenGL Mathematics Copyright (c) 2005 - 2009 G-Truc Creation (www.g-truc.net)
+// OpenGL Mathematics Copyright (c) 2005 - 2010 G-Truc Creation (www.g-truc.net)
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 // Created : 2008-08-17
-// Updated : 2009-11-12
+// Updated : 2010-02-17
 // Licence : This source is under MIT License
 // File    : glm/core/type_half.hpp
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -35,7 +35,7 @@ namespace glm
 			thalf(thalf const & s);
 			
 			template <typename U>
-			thalf(U const & s);
+			explicit thalf(U const & s);
 
 			// Cast
 			//operator float();

glm/core/type_half.inl

@@ -1,5 +1,5 @@
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-// OpenGL Mathematics Copyright (c) 2005 - 2009 G-Truc Creation (www.g-truc.net)
+// OpenGL Mathematics Copyright (c) 2005 - 2010 G-Truc Creation (www.g-truc.net)
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 // Created : 2008-08-17
 // Updated : 2009-11-12

glm/core/type_int.hpp

@@ -1,10 +1,10 @@
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-// OpenGL Mathematics Copyright (c) 2005 - 2009 G-Truc Creation (www.g-truc.net)
+// 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.h
+// File    : glm/core/type_int.hpp
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 #ifndef glm_core_type_int
@@ -30,9 +30,12 @@ namespace glm
 //		__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							highp_int_t;
+		typedef signed long	long					highp_int_t;
-		typedef unsigned long						highp_uint_t;
+		typedef unsigned long long					highp_uint_t;
 #endif//GLM_COMPILER
 
 		GLM_DETAIL_IS_INT(signed char);
@@ -46,15 +49,7 @@ namespace glm
 		GLM_DETAIL_IS_UINT(unsigned int);
 		GLM_DETAIL_IS_UINT(unsigned long);
 		GLM_DETAIL_IS_UINT(highp_uint_t);
-	}
-	//namespace detail
 
-	namespace core{
-	namespace type{
-	namespace scalar{
-
-	namespace precision
-	{
 		typedef signed short			lowp_int_t;
 		typedef signed int				mediump_int_t;
 		typedef detail::highp_int_t		highp_int_t;
@@ -62,58 +57,65 @@ namespace glm
 		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 lowp_int_t				lowp_int;
+		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 mediump_int_t			mediump_int;
+		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 highp_int_t				highp_int;
+		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 lowp_uint_t				lowp_uint;
+		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 mediump_uint_t			mediump_uint;
+		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 highp_uint_t			highp_uint;
+		typedef detail::highp_uint_t			highp_uint;
 	}
 	//namespace precision
 
 #ifndef GLM_PRECISION 
-	typedef precision::mediump_int_t			int_t;
+	typedef precision::mediump_int				int_t;
 #elif(GLM_PRECISION & GLM_PRECISION_HIGHP_INT)
-	typedef precision::highp_int_t				int_t;
+	typedef precision::highp_int				int_t;
 #elif(GLM_PRECISION & GLM_PRECISION_MEDIUMP_INT)
-	typedef precision::mediump_int_t			int_t;
+	typedef precision::mediump_int				int_t;
 #elif(GLM_PRECISION & GLM_PRECISION_LOWP_INT)
-	typedef precision::lowp_int_t				int_t;
+	typedef precision::lowp_int					int_t;
 #else
-	typedef mediump_int_t			int_t;
+	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_t			uint_t;
+	typedef precision::mediump_uint				uint_t;
 #elif(GLM_PRECISION & GLM_PRECISION_HIGHP_UINT)
-	typedef precision::highp_uint_t				uint_t;
+	typedef precision::highp_uint				uint_t;
 #elif(GLM_PRECISION & GLM_PRECISION_MEDIUMP_UINT)
-	typedef precision::mediump_uint_t			uint_t;
+	typedef precision::mediump_uint				uint_t;
 #elif(GLM_PRECISION & GLM_PRECISION_LOWP_UINT)
-	typedef precision::lowp_uint_t				uint_t;
+	typedef precision::lowp_uint				uint_t;
 #else
-	typedef precision::mediump_uint_t			uint_t;
+	typedef precision::mediump_uint				uint_t;
 #	pragma message("GLM message: Precisson undefined for unsigned integer number.");
 #endif//GLM_PRECISION
 
@@ -121,9 +123,8 @@ namespace glm
 	//! From GLSL 1.30.8 specification section 4.1.3 Integers.
 	typedef uint_t								uint;
 
-	}//namespace scalar
 	}//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

@@ -1,16 +1,16 @@
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-// OpenGL Mathematics Copyright (c) 2005 - 2009 G-Truc Creation (www.g-truc.net)
+// OpenGL Mathematics Copyright (c) 2005 - 2010 G-Truc Creation (www.g-truc.net)
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 // Created : 2005-01-27
-// Updated : 2008-08-30
+// Updated : 2010-02-11
 // Licence : This source is under MIT License
-// File    : glm/core/type_mat2x2.h
+// File    : glm/core/type_mat2x2.hpp
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 #ifndef glm_core_type_mat2x2
 #define glm_core_type_mat2x2
 
-#include "type_size.hpp"
+#include "type_mat.hpp"
 
 namespace glm
 {
@@ -39,142 +39,185 @@ namespace glm
 		template <typename T> 
 		struct tmat2x2
 		{
-		public:
+			enum ctor{null};
-			typedef tmat2x2<T>* pointer;
-			typedef const tmat2x2<T>* const_pointer;
-			typedef const tmat2x2<T>*const const_pointer_const;
-			typedef tmat2x2<T>*const pointer_const;
-			typedef tmat2x2<T>& reference;
-			typedef const tmat2x2<T>& const_reference;
-			typedef const tmat2x2<T>& param_type;
-			typedef tmat2x2<T> transpose_type;
-
 			typedef T value_type;
-			typedef detail::tvec2<T> col_type;
+			typedef std::size_t size_type;
-			typedef detail::tvec2<T> row_type;
+			typedef tvec2<T> col_type;
-			typedef glm::sizeType size_type;
+			typedef tvec2<T> row_type;
-			static size_type value_size();
 			static size_type col_size();
 			static size_type row_size();
-			static bool is_matrix();
+
+			typedef tmat2x2<T> type;
+			typedef tmat2x2<T> transpose_type;
 
 		public:
+			// Implementation detail
 			tmat2x2<T> _inverse() const;
 
 		private:
 			// Data 
-			detail::tvec2<T> value[2];
+			col_type value[2];
 
 		public:
 			// Constructors
 			tmat2x2();
-			tmat2x2(tmat2x2<T> const & m);
+			tmat2x2(
+				tmat2x2 const & m);
 
-			explicit tmat2x2(const T x);
 			explicit tmat2x2(
-				const T x1, const T y1, 
+				ctor Null);
-				const T x2, const T y2);
 			explicit tmat2x2(
-				const detail::tvec2<T> & v1, 
+				value_type const & x);
-				const detail::tvec2<T> & v2);
+			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(const tmat2x2<U>& m);
+			explicit tmat2x2(tmat2x2<U> const & m);
 
-			explicit tmat2x2(const tmat3x3<T>& x);
+			explicit tmat2x2(tmat3x3<T> const & x);
-			explicit tmat2x2(const tmat4x4<T>& x);
+			explicit tmat2x2(tmat4x4<T> const & x);
-			explicit tmat2x2(const tmat2x3<T>& x);
+			explicit tmat2x2(tmat2x3<T> const & x);
-			explicit tmat2x2(const tmat3x2<T>& x);
+			explicit tmat2x2(tmat3x2<T> const & x);
-			explicit tmat2x2(const tmat2x4<T>& x);
+			explicit tmat2x2(tmat2x4<T> const & x);
-			explicit tmat2x2(const tmat4x2<T>& x);
+			explicit tmat2x2(tmat4x2<T> const & x);
-			explicit tmat2x2(const tmat3x4<T>& x);
+			explicit tmat2x2(tmat3x4<T> const & x);
-			explicit tmat2x2(const tmat4x3<T>& x);
+			explicit tmat2x2(tmat4x3<T> const & x);
 
 			//////////////////////////////////////
 			// Accesses
 
-			detail::tvec2<T>& operator[](size_type i);
+			col_type & operator[](size_type i);
-			detail::tvec2<T> const & operator[](size_type i) const;
+			col_type const & operator[](size_type i) const;
 
 			// Unary updatable operators
-			tmat2x2<T>& operator=(tmat2x2<T> const & m);
+			tmat2x2<T> & operator=(tmat2x2<T> const & m);
-			tmat2x2<T>& operator+=(const T & s);
+			template <typename U> 
-			tmat2x2<T>& operator+=(tmat2x2<T> const & m);
+			tmat2x2<T> & operator=(tmat2x2<U> const & m);
-			tmat2x2<T>& operator-=(const T & s);
+			template <typename U> 
-			tmat2x2<T>& operator-=(tmat2x2<T> const & m);
+			tmat2x2<T> & operator+=(U const & s);
-			tmat2x2<T>& operator*=(const T & s);
+			template <typename U> 
-			tmat2x2<T>& operator*= (tmat2x2<T> const & m);
+			tmat2x2<T> & operator+=(tmat2x2<U> const & m);
-			tmat2x2<T>& operator/= (const T & s);
+			template <typename U> 
-			tmat2x2<T>& operator/= (tmat2x2<T> const & m);
+			tmat2x2<T> & operator-=(U const & s);
-			tmat2x2<T>& operator++ ();
+			template <typename U> 
-			tmat2x2<T>& operator-- ();
+			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, const T & s);
+		tmat2x2<T> operator+ (
+			tmat2x2<T> const & m, 
+			typename tmat2x2<T>::value_type const & s);
 
 		template <typename T> 
-		tmat2x2<T> operator+ (const T & s, tmat2x2<T> const & m);
+		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);
+		tmat2x2<T> operator+ (
+			tmat2x2<T> const & m1, 
+			tmat2x2<T> const & m2);
 	    
 		template <typename T> 
-		tmat2x2<T> operator- (tmat2x2<T> const & m, const T & s);
+		tmat2x2<T> operator- (
+			tmat2x2<T> const & m, 
+			typename tmat2x2<T>::value_type const & s);
 
 		template <typename T> 
-		tmat2x2<T> operator- (const T & s, tmat2x2<T> const & m);
+		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);
+		tmat2x2<T> operator- (
+			tmat2x2<T> const & m1, 
+			tmat2x2<T> const & m2);
 
 		template <typename T> 
-		tmat2x2<T> operator* (tmat2x2<T> const & m, const T & s);
+		tmat2x2<T> operator* (
+			tmat2x2<T> const & m, 
+			typename tmat2x2<T>::value_type const & s);
 
 		template <typename T> 
-		tmat2x2<T> operator* (const T & s, tmat2x2<T> const & m);
+		tmat2x2<T> operator* (
+			typename tmat2x2<T>::value_type const & s, 
+			tmat2x2<T> const & m);
 
 		template <typename T> 
-		tvec2<T> operator* (tmat2x2<T> const & m, const tvec2<T>& v);
+		typename tmat2x2<T>::row_type operator* (
+			tmat2x2<T> const & m, 
+			typename tmat2x2<T>::col_type const & s);
 
 		template <typename T> 
-		tvec2<T> operator* (const tvec2<T>& v, tmat2x2<T> const & m);
+		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);
+		tmat2x2<T> operator* (
+			tmat2x2<T> const & m1, 
+			tmat2x2<T> const & m2);
 
 		template <typename T> 
-		tmat2x2<T> operator/ (tmat2x2<T> const & m, const T & s);
+		tmat2x2<T> operator/ (
+			tmat2x2<T> const & m, 
+			typename tmat2x2<T>::value_type const & s);
 
 		template <typename T> 
-		tmat2x2<T> operator/ (const T & s, tmat2x2<T> const & m);
+		tmat2x2<T> operator/ (
+			typename tmat2x2<T>::value_type const & s,
+			tmat2x2<T> const & m);
 
 		template <typename T> 
-		tvec2<T> operator/ (tmat2x2<T> const & m, const tvec2<T>& v);
+		typename tmat2x2<T>::row_type operator/ (
+			tmat2x2<T> const & m, 
+			typename tmat2x2<T>::col_type const & v);
 
 		template <typename T> 
-		tvec2<T> operator/ (const tvec2<T>& v, tmat2x2<T> const & m);
+		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);
+		tmat2x2<T> operator/ (
+			tmat2x2<T> const & m1, 
+			tmat2x2<T> const & m2);
 
 		// Unary constant operators
-		template <typename valType> 
+		template <typename T> 
-		tmat2x2<valType> const operator-  (tmat2x2<valType> const & m);
+		tmat2x2<T> const operator-  (
+			tmat2x2<T> const & m);
 
-		template <typename valType> 
+		template <typename T> 
-		tmat2x2<valType> const operator-- (tmat2x2<valType> const & m, int);
+		tmat2x2<T> const operator-- (
+			tmat2x2<T> const & m, 
+			int);
 
-		template <typename valType> 
+		template <typename T> 
-		tmat2x2<valType> const operator++ (tmat2x2<valType> const & m, int);
+		tmat2x2<T> const operator++ (
+			tmat2x2<T> const & m, 
+			int);
 
 	} //namespace detail
 
 	namespace core{
 	namespace type{
-	namespace matrix{
 
 	namespace precision
 	{
@@ -193,25 +236,6 @@ namespace glm
 	}
 	//namespace precision
 
-#ifndef GLM_PRECISION
-	//! 2 columns of 2 components matrix of floating-point numbers. 
-	//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices)
-	typedef detail::tmat2x2<mediump_float>	mat2x2;
-#elif(GLM_PRECISION & GLM_PRECISION_HIGH)
-	typedef detail::tmat2x2<highp_float>	mat2x2;
-#elif(GLM_PRECISION & GLM_PRECISION_MEDIUM)
-	typedef detail::tmat2x2<mediump_float>	mat2x2;
-#elif(GLM_PRECISION & GLM_PRECISION_LOW)
-	typedef detail::tmat2x2<lowp_float>		mat2x2;
-#else
-	typedef detail::tmat2x2<mediump_float>	mat2x2;
-#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;
-
-	}//namespace matrix
 	}//namespace type
 	}//namespace core
 } //namespace glm

glm/core/type_mat2x2.inl

@@ -1,95 +1,107 @@
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-// OpenGL Mathematics Copyright (c) 2005 - 2009 G-Truc Creation (www.g-truc.net)
+// OpenGL Mathematics Copyright (c) 2005 - 2010 G-Truc Creation (www.g-truc.net)
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 // Created : 2005-01-16
-// Updated : 2007-03-01
+// Updated : 2010-02-11
 // Licence : This source is under MIT License
 // File    : glm/core/type_mat2x2.inl
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 namespace glm{
-namespace detail{
+namespace detail
-
+{
-	template <typename valType> 
+	template <typename T>
-	typename tmat2x2<valType>::size_type tmat2x2<valType>::value_size()
+	inline typename tmat2x2<T>::size_type tmat2x2<T>::col_size()
 	{
-		return typename tmat2x2<valType>::size_type(2);
+		return 2;
 	}
 
-	template <typename valType> 
+	template <typename T>
-	typename tmat2x2<valType>::size_type tmat2x2<valType>::col_size()
+	inline typename tmat2x2<T>::size_type tmat2x2<T>::row_size()
 	{
-		return typename tmat2x2<valType>::size_type(2);
+		return 2;
-	}
-
-	template <typename valType> 
-	typename tmat2x2<valType>::size_type tmat2x2<valType>::row_size()
-	{
-		return typename tmat2x2<valType>::size_type(2);
-	}
-
-	template <typename valType> 
-	bool tmat2x2<valType>::is_matrix()
-	{
-		return true;
 	}
 
 	//////////////////////////////////////
 	// Accesses
 
-	template <typename valType>
+	template <typename T>
-	detail::tvec2<valType>& tmat2x2<valType>::operator[](typename tmat2x2<valType>::size_type i)
+	inline typename tmat2x2<T>::col_type &
+	tmat2x2<T>::operator[]
+	(
+		size_type i
+	)
 	{
-		assert(
+		assert(i >= size_type(0) && i < col_size());
-			i >= typename tmat2x2<valType>::size_type(0) && 
+		return this->value[i];
-			i < tmat2x2<valType>::col_size());
-
-		return value[i];
 	}
 
-	template <typename valType>
+	template <typename T>
-	const detail::tvec2<valType>& tmat2x2<valType>::operator[](typename tmat2x2<valType>::size_type i) const
+	inline typename tmat2x2<T>::col_type const &
+	tmat2x2<T>::operator[]
+	(
+		size_type i
+	) const
 	{
-		assert(
+		assert(i >= size_type(0) && i < col_size());
-			i >= typename tmat2x2<valType>::size_type(0) && 
+		return this->value[i];
-			i < tmat2x2<valType>::col_size());
-
-		return value[i];
 	}
 
     //////////////////////////////////////////////////////////////
-    // mat2 constructors
+    // Constructors
 
     template <typename T> 
     inline tmat2x2<T>::tmat2x2()
     {
-        this->value[0] = detail::tvec2<T>(1, 0);
+		this->value[0] = col_type(1, 0);
-        this->value[1] = detail::tvec2<T>(0, 1);
+        this->value[1] = col_type(0, 1);
     }
 
     template <typename T> 
-    inline tmat2x2<T>::tmat2x2(const tmat2x2<T> & m)
+    inline tmat2x2<T>::tmat2x2
+	(
+		tmat2x2<T> const & m
+	)
     {
         this->value[0] = m.value[0];
         this->value[1] = m.value[1];
     }
 
     template <typename T> 
-    inline tmat2x2<T>::tmat2x2(const T f)
+    inline tmat2x2<T>::tmat2x2
+	(
+		ctor
+	)
+    {}
+
+    template <typename T> 
+	inline tmat2x2<T>::tmat2x2
+	(
+		value_type const & s
+	)
     {
-        this->value[0] = detail::tvec2<T>(f, 0);
+		value_type const Zero(0);
-        this->value[1] = detail::tvec2<T>(0, f);
+        this->value[0] = col_type(s, Zero);
+        this->value[1] = col_type(Zero, s);
     }
 
     template <typename T> 
-    inline tmat2x2<T>::tmat2x2(const T x0, const T y0, const T x1, const T y1)
+    inline tmat2x2<T>::tmat2x2
+	(
+		value_type const & x0, value_type const & y0, 
+		value_type const & x1, value_type const & y1
+	)
     {
-        this->value[0] = detail::tvec2<T>(x0, y0);
+        this->value[0] = col_type(x0, y0);
-        this->value[1] = detail::tvec2<T>(x1, y1);
+        this->value[1] = col_type(x1, y1);
     }
 
     template <typename T> 
-    inline tmat2x2<T>::tmat2x2(const detail::tvec2<T>& v0, const detail::tvec2<T>& v1)
+    inline tmat2x2<T>::tmat2x2
+	(
+		col_type const & v0, 
+		col_type const & v1
+	)
     {
         this->value[0] = v0;
         this->value[1] = v1;
@@ -100,87 +112,105 @@ namespace detail{
 
     template <typename T> 
     template <typename U> 
-    inline tmat2x2<T>::tmat2x2(const tmat2x2<U>& m)
+    inline tmat2x2<T>::tmat2x2
+	(
+		tmat2x2<U> const & m
+	)
     {
-        this->value[0] = detail::tvec2<T>(m[0]);
+        this->value[0] = col_type(m[0]);
-        this->value[1] = detail::tvec2<T>(m[1]);
+        this->value[1] = col_type(m[1]);
 	}
 
     template <typename T> 
-    inline tmat2x2<T>::tmat2x2(const tmat3x3<T>& m)
+    inline tmat2x2<T>::tmat2x2
+	(
+		tmat3x3<T> const & m
+	)
     {
-        this->value[0] = detail::tvec2<T>(m[0]);
+        this->value[0] = col_type(m[0]);
-        this->value[1] = detail::tvec2<T>(m[1]);
+        this->value[1] = col_type(m[1]);
     }
 
     template <typename T> 
-    inline tmat2x2<T>::tmat2x2(const tmat4x4<T>& m)
+    inline tmat2x2<T>::tmat2x2
+	(
+		tmat4x4<T> const & m
+	)
     {
-        this->value[0] = detail::tvec2<T>(m[0]);
+        this->value[0] = col_type(m[0]);
-        this->value[1] = detail::tvec2<T>(m[1]);
+        this->value[1] = col_type(m[1]);
     }
 
 	template <typename T> 
-    inline tmat2x2<T>::tmat2x2(const tmat2x3<T>& m)
+    inline tmat2x2<T>::tmat2x2
+	(
+		tmat2x3<T> const & m
+	)
     {
-        this->value[0] = detail::tvec2<T>(m[0]);
+        this->value[0] = col_type(m[0]);
-        this->value[1] = detail::tvec2<T>(m[1]);
+        this->value[1] = col_type(m[1]);
     }
 
     template <typename T> 
-    inline tmat2x2<T>::tmat2x2(const tmat3x2<T>& m)
+    inline tmat2x2<T>::tmat2x2
+	(
+		tmat3x2<T> const & m
+	)
     {
         this->value[0] = m[0];
         this->value[1] = m[1];
     }
 
     template <typename T> 
-    inline tmat2x2<T>::tmat2x2(const tmat2x4<T>& m)
+    inline tmat2x2<T>::tmat2x2
+	(
+		tmat2x4<T> const & m
+	)
     {
-        this->value[0] = detail::tvec2<T>(m[0]);
+        this->value[0] = col_type(m[0]);
-        this->value[1] = detail::tvec2<T>(m[1]);
+        this->value[1] = col_type(m[1]);
     }
 
     template <typename T> 
-    inline tmat2x2<T>::tmat2x2(const tmat4x2<T>& m)
+    inline tmat2x2<T>::tmat2x2
+	(
+		tmat4x2<T> const & m
+	)
     {
         this->value[0] = m[0];
         this->value[1] = m[1];
     }
 
     template <typename T> 
-    inline tmat2x2<T>::tmat2x2(const tmat3x4<T>& m)
+    inline tmat2x2<T>::tmat2x2
+	(
+		tmat3x4<T> const & m
+	)
     {
-        this->value[0] = detail::tvec2<T>(m[0]);
+        this->value[0] = col_type(m[0]);
-        this->value[1] = detail::tvec2<T>(m[1]);
+        this->value[1] = col_type(m[1]);
     }
 
     template <typename T> 
-    inline tmat2x2<T>::tmat2x2(const tmat4x3<T>& m)
+    inline tmat2x2<T>::tmat2x2
+	(
+		tmat4x3<T> const & m
+	)
     {
-        this->value[0] = detail::tvec2<T>(m[0]);
+        this->value[0] = col_type(m[0]);
-        this->value[1] = detail::tvec2<T>(m[1]);
+        this->value[1] = col_type(m[1]);
     }
 
-/*
-    template <typename T> 
-    inline tmat2x2<T>::tmat2x2(const T* a)
-    {
-        this->value[0] = detail::tvec2<T>(a[0], a[1]);
-        this->value[1] = detail::tvec2<T>(a[2], a[3]);
-    }
-*/
-
     template <typename T> 
     inline tmat2x2<T> tmat2x2<T>::_inverse() const
     {
-        T Determinant = value[0][0] * value[1][1] - value[1][0] * value[0][1];
+        typename tmat2x2<T>::value_type Determinant = this->value[0][0] * this->value[1][1] - this->value[1][0] * this->value[0][1];
 
         tmat2x2<T> Inverse(
-            + value[1][1] / Determinant,
+            + this->value[1][1] / Determinant,
-            - value[1][0] / Determinant,
+            - this->value[1][0] / Determinant,
-            - value[0][1] / Determinant, 
+            - this->value[0][1] / Determinant, 
-            + value[0][0] / Determinant);
+            + this->value[0][0] / Determinant);
         return Inverse;
     }
 
@@ -189,7 +219,10 @@ namespace detail{
 
     // This function shouldn't required but it seems that VC7.1 have an optimisation bug if this operator wasn't declared
     template <typename T> 
-    inline tmat2x2<T>& tmat2x2<T>::operator=(tmat2x2<T> const & m)
+    inline tmat2x2<T>& tmat2x2<T>::operator=
+	(
+		tmat2x2<T> const & m
+	)
     {
 	    this->value[0] = m[0];
 	    this->value[1] = m[1];
@@ -197,7 +230,23 @@ namespace detail{
     }
 
 	template <typename T> 
-    inline tmat2x2<T>& tmat2x2<T>::operator+= (const T & s)
+	template <typename U> 
+    inline tmat2x2<T>& tmat2x2<T>::operator=
+	(
+		tmat2x2<U> const & m
+	)
+    {
+	    this->value[0] = m[0];
+	    this->value[1] = m[1];
+	    return *this;
+    }
+
+    template <typename T> 
+	template <typename U> 
+    inline tmat2x2<T>& tmat2x2<T>::operator+=
+	(
+		U const & s
+	)
     {
 	    this->value[0] += s;
 	    this->value[1] += s;
@@ -205,7 +254,11 @@ namespace detail{
     }
 
     template <typename T> 
-    inline tmat2x2<T>& tmat2x2<T>::operator+= (tmat2x2<T> const & m)
+	template <typename U> 
+    inline tmat2x2<T>& tmat2x2<T>::operator+=
+	(
+		tmat2x2<U> const & m
+	)
     {
 	    this->value[0] += m[0];
 	    this->value[1] += m[1];
@@ -213,7 +266,11 @@ namespace detail{
     }
 
     template <typename T> 
-    inline tmat2x2<T>& tmat2x2<T>::operator-= (const T & s)
+	template <typename U> 
+    inline tmat2x2<T>& tmat2x2<T>::operator-=
+	(
+		U const & s
+	)
     {
 	    this->value[0] -= s;
 	    this->value[1] -= s;
@@ -221,7 +278,11 @@ namespace detail{
     }
 
     template <typename T> 
-    inline tmat2x2<T>& tmat2x2<T>::operator-= (tmat2x2<T> const & m)
+	template <typename U> 
+    inline tmat2x2<T>& tmat2x2<T>::operator-=
+	(
+		tmat2x2<U> const & m
+	)
     {
 	    this->value[0] -= m[0];
 	    this->value[1] -= m[1];
@@ -229,7 +290,11 @@ namespace detail{
     }
 
     template <typename T> 
-    inline tmat2x2<T>& tmat2x2<T>::operator*= (const T & s)
+	template <typename U> 
+    inline tmat2x2<T>& tmat2x2<T>::operator*= 
+	(
+		U const & s
+	)
     {
 	    this->value[0] *= s;
 	    this->value[1] *= s;
@@ -237,13 +302,21 @@ namespace detail{
     }
 
     template <typename T> 
-    inline tmat2x2<T>& tmat2x2<T>::operator*= (tmat2x2<T> const & m)
+	template <typename U> 
+    inline tmat2x2<T>& tmat2x2<T>::operator*= 
+	(
+		tmat2x2<U> const & m
+	)
     {
         return (*this = *this * m);
     }
 
     template <typename T> 
-    inline tmat2x2<T>& tmat2x2<T>::operator/= (const T & s)
+	template <typename U> 
+    inline tmat2x2<T>& tmat2x2<T>::operator/= 
+	(
+		U const & s
+	)
     {
 	    this->value[0] /= s;
 	    this->value[1] /= s;
@@ -251,7 +324,11 @@ namespace detail{
     }
 
     template <typename T> 
-    inline tmat2x2<T>& tmat2x2<T>::operator/= (tmat2x2<T> const & m)
+	template <typename U> 
+    inline tmat2x2<T>& tmat2x2<T>::operator/= 
+	(
+		tmat2x2<U> const & m
+	)
     {
         return (*this = *this / m);
     }
@@ -276,7 +353,11 @@ namespace detail{
 	// Binary operators
 
     template <typename T> 
-    inline tmat2x2<T> operator+ (tmat2x2<T> const & m, const T & s)
+    inline tmat2x2<T> operator+ 
+	(
+		tmat2x2<T> const & m, 
+		typename tmat2x2<T>::value_type const & s
+	)
     {
         return tmat2x2<T>(
             m[0] + s,
@@ -284,27 +365,23 @@ namespace detail{
     }
 
     template <typename T> 
-    inline tmat2x2<T> operator+ (const T & s, tmat2x2<T> const & m)
+    inline tmat2x2<T> operator+ 
+	(
+		typename tmat2x2<T>::value_type const & s, 
+		tmat2x2<T> const & m
+	)
     {
         return tmat2x2<T>(
             m[0] + s,
             m[1] + s);
     }
 
-    //template <typename T> 
-    //inline detail::tvec2<T> operator+ (tmat2x2<T> const & m, const detail::tvec2<T>& v)
-    //{
-
-    //}
-
-    //template <typename T> 
-    //inline detail::tvec2<T> operator+ (const detail::tvec2<T>& v, tmat2x2<T> const & m)
-    //{
-
-    //}
-
     template <typename T> 
-    inline tmat2x2<T> operator+ (tmat2x2<T> const & m1, tmat2x2<T> const & m2)
+    inline tmat2x2<T> operator+ 
+	(
+		tmat2x2<T> const & m1, 
+		tmat2x2<T> const & m2
+	)
     {
         return tmat2x2<T>(
             m1[0] + m2[0],
@@ -312,7 +389,11 @@ namespace detail{
     }
 
     template <typename T> 
-    inline tmat2x2<T> operator- (tmat2x2<T> const & m, const T & s)
+    inline tmat2x2<T> operator- 
+	(
+		tmat2x2<T> const & m, 
+		typename tmat2x2<T>::value_type const & s
+	)
     {
         return tmat2x2<T>(
             m[0] - s,
@@ -320,27 +401,23 @@ namespace detail{
     }
 
     template <typename T> 
-    inline tmat2x2<T> operator- (const T & s, tmat2x2<T> const & m)
+    inline tmat2x2<T> operator- 
+	(
+		typename tmat2x2<T>::value_type const & s, 
+		tmat2x2<T> const & m
+	)
     {
         return tmat2x2<T>(
             s - m[0],
             s - m[1]);
     }
 
-    //template <typename T> 
-    //inline tmat2x2<T> operator- (tmat2x2<T> const & m, const detail::tvec2<T>& v)
-    //{
-
-    //}
-
-    //template <typename T> 
-    //inline tmat2x2<T> operator- (const detail::tvec2<T>& v, tmat2x2<T> const & m)
-    //{
-
-    //}
-
     template <typename T> 
-    inline tmat2x2<T> operator- (tmat2x2<T> const & m1, tmat2x2<T> const & m2)
+    inline tmat2x2<T> operator- 
+	(
+		tmat2x2<T> const & m1, 
+		tmat2x2<T> const & m2
+	)
     {
         return tmat2x2<T>(
             m1[0] - m2[0],
@@ -348,7 +425,11 @@ namespace detail{
     }
 
     template <typename T> 
-    inline tmat2x2<T> operator* (tmat2x2<T> const & m, const T & s)
+    inline tmat2x2<T> operator* 
+	(
+		tmat2x2<T> const & m, 
+		typename tmat2x2<T>::value_type const & s
+	)
     {
         return tmat2x2<T>(
             m[0] * s,
@@ -356,7 +437,11 @@ namespace detail{
     }
 
     template <typename T> 
-    inline tmat2x2<T> operator* (const T & s, tmat2x2<T> const & m)
+    inline tmat2x2<T> operator* 
+	(	
+		typename tmat2x2<T>::value_type const & s, 
+		tmat2x2<T> const & m
+	)
     {
         return tmat2x2<T>(
             m[0] * s,
@@ -364,7 +449,11 @@ namespace detail{
     }
 
     template <typename T> 
-    inline detail::tvec2<T> operator* (tmat2x2<T> const & m, const detail::tvec2<T>& v)
+    inline typename tmat2x2<T>::row_type operator* 
+	(
+		tmat2x2<T> const & m, 
+		typename tmat2x2<T>::col_type const & v
+	)
     {
         return detail::tvec2<T>(
             m[0][0] * v.x + m[1][0] * v.y,
@@ -372,7 +461,11 @@ namespace detail{
     }
 
     template <typename T> 
-    inline detail::tvec2<T> operator* (const detail::tvec2<T>& v, tmat2x2<T> const & m)
+    inline typename tmat2x2<T>::col_type operator* 
+	(
+		typename tmat2x2<T>::row_type const & v, 
+		tmat2x2<T> const & m
+	)
     {
         return detail::tvec2<T>(
             m[0][0] * v.x + m[0][1] * v.y,
@@ -380,7 +473,11 @@ namespace detail{
     }
 
 	template <typename T>
-	inline tmat2x2<T> operator* (tmat2x2<T> const & m1, tmat2x2<T> const & m2)
+	inline tmat2x2<T> operator* 
+	(
+		tmat2x2<T> const & m1, 
+		tmat2x2<T> const & m2
+	)
 	{
 		return tmat2x2<T>(
 			m1[0][0] * m2[0][0] + m1[1][0] * m2[0][1],
@@ -390,7 +487,11 @@ namespace detail{
 	}
 
     template <typename T> 
-    inline tmat2x2<T> operator/ (tmat2x2<T> const & m, const T & s)
+    inline tmat2x2<T> operator/ 
+	(
+		tmat2x2<T> const & m, 
+		typename tmat2x2<T>::value_type const & s
+	)
     {
         return tmat2x2<T>(
             m[0] / s,
@@ -398,7 +499,11 @@ namespace detail{
     }
 
     template <typename T> 
-    inline tmat2x2<T> operator/ (const T & s, tmat2x2<T> const & m)
+    inline tmat2x2<T> operator/ 
+	(
+		typename tmat2x2<T>::value_type const & s, 
+		tmat2x2<T> const & m
+	)
     {
         return tmat2x2<T>(
             s / m[0],
@@ -406,57 +511,69 @@ namespace detail{
     }
 
     template <typename T> 
-    inline detail::tvec2<T> operator/ (tmat2x2<T> const & m, const detail::tvec2<T>& v)
+    inline typename tmat2x2<T>::row_type operator/ 
+	(
+		tmat2x2<T> const & m, 
+		typename tmat2x2<T>::col_type & v
+	)
     {
         return m._inverse() * v;
     }
 
     template <typename T> 
-    inline detail::tvec2<T> operator/ (const detail::tvec2<T>& v, tmat2x2<T> const & m)
+    inline typename tmat2x2<T>::col_type operator/ 
+	(
+		typename tmat2x2<T>::row_type const & v,
+		tmat2x2<T> const & m
+	)
     {
         return v * m._inverse();
     }
 
     template <typename T> 
-    inline tmat2x2<T> operator/ (tmat2x2<T> const & m1, tmat2x2<T> const & m2)
+    inline tmat2x2<T> operator/ 
+	(
+		tmat2x2<T> const & m1, 
+		tmat2x2<T> const & m2
+	)
     {
         return m1 * m2._inverse();
     }
 
 	// Unary constant operators
-    template <typename valType> 
+    template <typename T> 
-    inline tmat2x2<valType> const operator- 
+    inline tmat2x2<T> const operator- 
 	(
-		tmat2x2<valType> const & m
+		tmat2x2<T> const & m
 	)
     {
-        return tmat2x2<valType>(
+        return tmat2x2<T>(
             -m[0], 
             -m[1]);
     }
 
-    template <typename valType> 
+    template <typename T> 
-    inline tmat2x2<valType> const operator++ 
+    inline tmat2x2<T> const operator++ 
 	(
-		tmat2x2<valType> const & m, 
+		tmat2x2<T> const & m, 
 		int
 	) 
     {
-        return tmat2x2<valType>(
+        return tmat2x2<T>(
-            m[0] + valType(1),
+            m[0] + T(1),
-            m[1] + valType(1));
+            m[1] + T(1));
     }
 
-    template <typename valType> 
+    template <typename T> 
-    inline tmat2x2<valType> const operator-- 
+    inline tmat2x2<T> const operator-- 
 	(
-		tmat2x2<valType> const & m, 
+		tmat2x2<T> const & m, 
 		int
 	) 
     {
-        return tmat2x2<valType>(
+        return tmat2x2<T>(
-            m[0] - valType(1),
+            m[0] - T(1),
-            m[1] - valType(1));
+            m[1] - T(1));
     }
 
 } //namespace detail

glm/core/type_mat2x3.hpp

@@ -1,16 +1,16 @@
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-// OpenGL Mathematics Copyright (c) 2005 - 2009 G-Truc Creation (www.g-truc.net)
+// OpenGL Mathematics Copyright (c) 2005 - 2010 G-Truc Creation (www.g-truc.net)
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 // Created : 2006-10-01
-// Updated : 2008-08-30
+// Updated : 2010-02-03
 // Licence : This source is under MIT License
-// File    : glm/core/type_mat2x3.h
+// File    : glm/core/type_mat2x3.hpp
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 #ifndef glm_core_type_mat2x3
 #define glm_core_type_mat2x3
 
-#include "type_size.hpp"
+#include "type_mat.hpp"
 
 namespace glm
 {
@@ -39,137 +39,152 @@ namespace glm
 		template <typename T> 
 		struct tmat2x3
 		{
-		public:
+			enum ctor{null};
-			typedef tmat2x3<T>* pointer;
-			typedef const tmat2x3<T>* const_pointer;
-			typedef const tmat2x3<T>*const const_pointer_const;
-			typedef tmat2x3<T>*const pointer_const;
-			typedef tmat2x3<T>& reference;
-			typedef const tmat2x3<T>& const_reference;
-			typedef const tmat2x3<T>& param_type;
-			typedef tmat3x2<T> transpose_type;
-
 			typedef T value_type;
-			typedef detail::tvec3<T> col_type;
+			typedef std::size_t size_type;
-			typedef detail::tvec2<T> row_type;
+			typedef tvec3<T> col_type;
-			typedef glm::sizeType size_type;
+			typedef tvec2<T> row_type;
 			static size_type col_size();
 			static size_type row_size();
-			static bool is_matrix();
 
-		public:
+			typedef tmat2x3<T> type;
-			tmat3x2<T> _inverse() const;
+			typedef tmat3x2<T> transpose_type;
 
 		private:
 			// Data 
-			detail::tvec3<T> value[2];
+			col_type value[2];
 
 		public:
 			// Constructors
 			tmat2x3();
-			explicit tmat2x3(const T x);
+			tmat2x3(tmat2x3 const & m);
+
 			explicit tmat2x3(
-				const T x0, const T y0, const T z0,
+				ctor);
-				const T x1, const T y1, const T z1);
 			explicit tmat2x3(
-				const detail::tvec3<T>& v0, 
+				value_type const & s);
-				const detail::tvec3<T>& v1);
+			explicit tmat2x3(
+				value_type const & x0, value_type const & y0, value_type const & z0,
+				value_type const & x1, value_type const & y1, value_type const & z1);
+			explicit tmat2x3(
+				col_type const & v0, 
+				col_type const & v1);
 
 			// Conversion
 			template <typename U> 
-			explicit tmat2x3(const tmat2x3<U>& m);
+			explicit tmat2x3(tmat2x3<U> const & m);
 
-			explicit tmat2x3(const tmat2x2<T>& x);
+			explicit tmat2x3(tmat2x2<T> const & x);
-			explicit tmat2x3(const tmat3x3<T>& x);
+			explicit tmat2x3(tmat3x3<T> const & x);
-			explicit tmat2x3(const tmat4x4<T>& x);
+			explicit tmat2x3(tmat4x4<T> const & x);
-			explicit tmat2x3(const tmat2x4<T>& x);
+			explicit tmat2x3(tmat2x4<T> const & x);
-			explicit tmat2x3(const tmat3x2<T>& x);
+			explicit tmat2x3(tmat3x2<T> const & x);
-			explicit tmat2x3(const tmat3x4<T>& x);
+			explicit tmat2x3(tmat3x4<T> const & x);
-			explicit tmat2x3(const tmat4x2<T>& x);
+			explicit tmat2x3(tmat4x2<T> const & x);
-			explicit tmat2x3(const tmat4x3<T>& x);
+			explicit tmat2x3(tmat4x3<T> const & x);
 
 			// Accesses
-			detail::tvec3<T>& operator[](size_type i);
+			col_type & operator[](size_type i);
-			detail::tvec3<T> const & operator[](size_type i) const;
+			col_type const & operator[](size_type i) const;
 
 			// Unary updatable operators
-			tmat2x3<T>& operator=  (const tmat2x3<T>& m);
+			tmat2x3<T> & operator=  (tmat2x3<T> const & m);
-			tmat2x3<T>& operator+= (const T & s);
+			template <typename U> 
-			tmat2x3<T>& operator+= (const tmat2x3<T>& m);
+			tmat2x3<T> & operator=  (tmat2x3<U> const & m);
-			tmat2x3<T>& operator-= (const T & s);
+			template <typename U> 
-			tmat2x3<T>& operator-= (const tmat2x3<T>& m);
+			tmat2x3<T> & operator+= (U const & s);
-			tmat2x3<T>& operator*= (const T & s);
+			template <typename U> 
-			tmat2x3<T>& operator*= (const tmat3x2<T>& m);
+			tmat2x3<T> & operator+= (tmat2x3<U> const & m);
-			tmat2x3<T>& operator/= (const T & s);
+			template <typename U> 
-			// tmat2x3<T>& operator/= (const tmat3x2<T>& m);
+			tmat2x3<T> & operator-= (U const & s);
+			template <typename U> 
+			tmat2x3<T> & operator-= (tmat2x3<U> const & m);
+			template <typename U> 
+			tmat2x3<T> & operator*= (U const & s);
+			template <typename U> 
+			tmat2x3<T> & operator*= (tmat2x3<U> const & m);
+			template <typename U> 
+			tmat2x3<T> & operator/= (U const & s);
 
-			tmat2x3<T>& operator++ ();
+			tmat2x3<T> & operator++ ();
-			tmat2x3<T>& operator-- ();
+			tmat2x3<T> & operator-- ();
-
-			// Unary constant operators
-			const tmat2x3<T> operator- () const;
-			const tmat2x3<T> operator++ (int n) const;
-			const tmat2x3<T> operator-- (int n) const;
 		};
 
 		// Binary operators
 		template <typename T> 
-		tmat2x3<T> operator+ (const tmat2x3<T>& m, const T & s);
+		tmat2x3<T> operator+ (
+			tmat2x3<T> const & m, 
+			typename tmat2x3<T>::value_type const & s);
 	    
 		template <typename T> 
-		tmat2x3<T> operator+ (const tmat2x3<T>& m1, const tmat2x3<T>& m2);
+		tmat2x3<T> operator+ (
+			tmat2x3<T> const & m1, 
+			tmat2x3<T> const & m2);
 	    
 		template <typename T> 
-		tmat2x3<T> operator- (const tmat2x3<T>& m, const T & s);
+		tmat2x3<T> operator- (
+			tmat2x3<T> const & m, 
+			typename tmat2x3<T>::value_type const & s);
 
 		template <typename T> 
-		tmat2x3<T> operator- (const tmat2x3<T>& m1, const tmat2x3<T>& m2);
+		tmat2x3<T> operator- (
+			tmat2x3<T> const & m1, 
+			tmat2x3<T> const & m2);
 
 		template <typename T> 
-		tmat2x3<T> operator* (const tmat2x3<T>& m, const T & s);
+		tmat2x3<T> operator* (
+			tmat2x3<T> const & m, 
+			typename tmat2x3<T>::value_type const & s);
 
 		template <typename T> 
-		tmat2x3<T> operator* (const T & s, const tmat2x3<T>& m);
+		tmat2x3<T> operator* (
+			typename tmat2x3<T>::value_type const & s, 
+			tmat2x3<T> const & m);
 
 		template <typename T>
-		detail::tvec3<T> operator* (const tmat2x3<T>& m, const detail::tvec2<T>& v);
+		typename tmat2x3<T>::row_type operator* (
+			tmat2x3<T> const & m, 
+			typename tmat2x3<T>::col_type const & v);
 
 		template <typename T> 
-		detail::tvec3<T> operator* (const detail::tvec3<T>& v, const tmat2x3<T>& m);
+		typename tmat2x3<T>::col_type operator* (
+			typename tmat2x3<T>::row_type const & v, 
+			tmat2x3<T> const & m);
 
 		template <typename T>
-		tmat3x3<T> operator* (const tmat2x3<T>& m1, const tmat3x2<T>& m2);
+		tmat3x3<T> operator* (
+			tmat2x3<T> const & m1, 
+			tmat3x2<T> const & m2);
 
 		template <typename T> 
-		tmat3x2<T> operator/ (const tmat2x3<T>& m, const T & s);
+		tmat3x2<T> operator/ (
+			tmat2x3<T> const & m, 
+			typename tmat2x3<T>::value_type const & s);
 
 		template <typename T> 
-		tmat3x2<T> operator/ (const T & s, const tmat2x3<T>& m);
+		tmat3x2<T> operator/ (
-
+			typename tmat2x3<T>::value_type const & s,
-		//template <typename T> 
+			tmat2x3<T> const & m);
-		//detail::tvec3<T> operator/ (const tmat2x3<T>& m, const detail::tvec2<T>& v);
-
-		//template <typename T> 
-		//detail::tvec2<T> operator/ (const detail::tvec3<T>& v, const tmat2x3<T>& m);
-
-		//template <typename T> 
-		//tmat3x3<T> operator/ (const tmat3x2<T>& m1, const tmat2x3<T>& m2);
 
 		// Unary constant operators
-		template <typename valType> 
+		template <typename T> 
-		tmat2x3<valType> const operator-  (tmat2x3<valType> const & m);
+		tmat2x3<T> const operator-  (
+			tmat2x3<T> const & m);
 
-		template <typename valType> 
+		template <typename T> 
-		tmat2x3<valType> const operator-- (tmat2x3<valType> const & m, int);
+		tmat2x3<T> const operator-- (
+			tmat2x3<T> const & m, 
+			int);
 
-		template <typename valType> 
+		template <typename T> 
-		tmat2x3<valType> const operator++ (tmat2x3<valType> const & m, int);
+		tmat2x3<T> const operator++ (
+			tmat2x3<T> const & m, 
+			int);
 
 	} //namespace detail
 
 	namespace core{
 	namespace type{
-	namespace matrix{
 
 	namespace precision
 	{
@@ -188,21 +203,6 @@ namespace glm
 	}
 	//namespace precision
 
-#ifndef GLM_PRECISION 
-	//! 2 columns of 3 components matrix of floating-point numbers. 
-	//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices)
-	typedef detail::tmat2x3<mediump_float>	mat2x3;
-#elif(GLM_PRECISION & GLM_PRECISION_HIGHP_FLOAT)
-	typedef detail::tmat2x3<highp_float>	mat2x3;
-#elif(GLM_PRECISION & GLM_PRECISION_MEDIUMP_FLOAT)
-	typedef detail::tmat2x3<mediump_float>	mat2x3;
-#elif(GLM_PRECISION & GLM_PRECISION_LOWP_FLOAT)
-	typedef detail::tmat2x3<lowp_float>		mat2x3;
-#else
-	typedef detail::tmat2x3<mediump_float>	mat2x3;
-#endif//GLM_PRECISION
-
-	}//namespace matrix
 	}//namespace type
 	}//namespace core
 } //namespace glm

glm/core/type_mat2x3.inl

@@ -1,54 +1,50 @@
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-// OpenGL Mathematics Copyright (c) 2005 - 2009 G-Truc Creation (www.g-truc.net)
+// OpenGL Mathematics Copyright (c) 2005 - 2010 G-Truc Creation (www.g-truc.net)
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 // Created : 2006-08-05
-// Updated : 2006-10-01
+// Updated : 2010-02-03
 // Licence : This source is under MIT License
 // File    : glm/core/type_mat2x3.inl
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 namespace glm{
-namespace detail{
+namespace detail
-
+{
-	template <typename valType> 
+	template <typename T>
-	typename tmat2x3<valType>::size_type tmat2x3<valType>::col_size()
+	inline typename tmat2x3<T>::size_type tmat2x3<T>::col_size()
 	{
-		return typename tmat2x3<valType>::size_type(2);
+		return 3;
 	}
 
-	template <typename valType> 
+	template <typename T>
-	typename tmat2x3<valType>::size_type tmat2x3<valType>::row_size()
+	inline typename tmat2x3<T>::size_type tmat2x3<T>::row_size()
 	{
-		return typename tmat2x3<valType>::size_type(3);
+		return 2;
-	}
-
-	template <typename valType> 
-	bool tmat2x3<valType>::is_matrix()
-	{
-		return true;
 	}
 
 	//////////////////////////////////////
 	// Accesses
 
-	template <typename valType>
+	template <typename T>
-	detail::tvec3<valType>& tmat2x3<valType>::operator[](typename tmat2x3<valType>::size_type i)
+	inline typename tmat2x3<T>::col_type &
+	tmat2x3<T>::operator[]
+	(
+		size_type i
+	)
 	{
-		assert(
+		assert(i >= size_type(0) && i < col_size());
-			i >= typename tmat2x3<valType>::size_type(0) && 
+		return this->value[i];
-			i < tmat2x3<valType>::col_size());
-
-		return value[i];
 	}
 
-	template <typename valType>
+	template <typename T>
-	const detail::tvec3<valType>& tmat2x3<valType>::operator[](typename tmat2x3<valType>::size_type i) const
+	inline typename tmat2x3<T>::col_type const &
+	tmat2x3<T>::operator[]
+	(
+		size_type i
+	) const
 	{
-		assert(
+		assert(i >= size_type(0) && i < col_size());
-			i >= typename tmat2x3<valType>::size_type(0) && 
+		return this->value[i];
-			i < tmat2x3<valType>::col_size());
-
-		return value[i];
 	}
 
     //////////////////////////////////////////////////////////////
@@ -57,33 +53,53 @@ namespace detail{
     template <typename T> 
     inline tmat2x3<T>::tmat2x3()
     {
-        this->value[0] = detail::tvec3<T>(T(1), T(0), T(0));
+        this->value[0] = col_type(T(1), T(0), T(0));
-        this->value[1] = detail::tvec3<T>(T(0), T(1), T(0));
+        this->value[1] = col_type(T(0), T(1), T(0));
-    }
-
-    template <typename T> 
-    inline tmat2x3<T>::tmat2x3(const T f)
-    {
-        this->value[0] = detail::tvec3<T>(f, T(0), T(0));
-        this->value[1] = detail::tvec3<T>(T(0), f, T(0));
     }
 
     template <typename T> 
     inline tmat2x3<T>::tmat2x3
 	(
-        const T x0, const T y0, const T z0,
+		tmat2x3<T> const & m
-        const T x1, const T y1, const T z1
 	)
     {
-        this->value[0] = detail::tvec3<T>(x0, y0, z0);
+        this->value[0] = m.value[0];
-        this->value[1] = detail::tvec3<T>(x1, y1, z1);
+        this->value[1] = m.value[1];
     }
 
     template <typename T> 
     inline tmat2x3<T>::tmat2x3
 	(
-        const detail::tvec3<T> & v0, 
+		ctor
-        const detail::tvec3<T> & v1
+	)
+    {}
+
+    template <typename T> 
+    inline tmat2x3<T>::tmat2x3
+	(
+		value_type const & s
+	)
+    {
+        this->value[0] = col_type(s, T(0), T(0));
+        this->value[1] = col_type(T(0), s, T(0));
+    }
+
+    template <typename T> 
+    inline tmat2x3<T>::tmat2x3
+    (
+        value_type const & x0, value_type const & y0, value_type const & z0,
+        value_type const & x1, value_type const & y1, value_type const & z1
+    )
+    {
+        this->value[0] = col_type(x0, y0, z0);
+        this->value[1] = col_type(x1, y1, z1);
+    }
+
+    template <typename T> 
+    inline tmat2x3<T>::tmat2x3
+    (
+        col_type const & v0, 
+        col_type const & v1
     )
     {
         this->value[0] = v0;
@@ -93,63 +109,90 @@ namespace detail{
     // Conversion
     template <typename T> 
     template <typename U> 
-    inline tmat2x3<T>::tmat2x3(const tmat2x3<U>& m)
+    inline tmat2x3<T>::tmat2x3
+	(
+		tmat2x3<U> const & m
+	)
     {
-        this->value[0] = detail::tvec3<T>(m[0]);
+        this->value[0] = col_type(m[0]);
-        this->value[1] = detail::tvec3<T>(m[1]);
+        this->value[1] = col_type(m[1]);
 	}
 
     template <typename T> 
-    inline tmat2x3<T>::tmat2x3(tmat2x2<T> const & m)
+    inline tmat2x3<T>::tmat2x3
+	(
+		tmat2x2<T> const & m
+	)
     {
-        this->value[0] = detail::tvec3<T>(m[0], T(0));
+        this->value[0] = col_type(m[0], T(0));
-        this->value[1] = detail::tvec3<T>(m[1], T(0));
+        this->value[1] = col_type(m[1], T(0));
     }
 
     template <typename T> 
-    inline tmat2x3<T>::tmat2x3(const tmat3x3<T>& m)
+    inline tmat2x3<T>::tmat2x3
+	(
+		tmat3x3<T> const & m
+	)
     {
-        this->value[0] = detail::tvec3<T>(m[0]);
+        this->value[0] = col_type(m[0]);
-        this->value[1] = detail::tvec3<T>(m[1]);
+        this->value[1] = col_type(m[1]);
     }
 
     template <typename T> 
-    inline tmat2x3<T>::tmat2x3(const tmat4x4<T>& m)
+    inline tmat2x3<T>::tmat2x3
+	(
+		tmat4x4<T> const & m
+	)
     {
-        this->value[0] = detail::tvec3<T>(m[0]);
+        this->value[0] = col_type(m[0]);
-        this->value[1] = detail::tvec3<T>(m[1]);
+        this->value[1] = col_type(m[1]);
     }
 
     template <typename T> 
-    inline tmat2x3<T>::tmat2x3(const tmat2x4<T>& m)
+    inline tmat2x3<T>::tmat2x3
+	(
+		tmat2x4<T> const & m
+	)
     {
-        this->value[0] = detail::tvec3<T>(m[0]);
+        this->value[0] = col_type(m[0]);
-        this->value[1] = detail::tvec3<T>(m[1]);
+        this->value[1] = col_type(m[1]);
     }
 
     template <typename T> 
-    inline tmat2x3<T>::tmat2x3(const tmat3x2<T>& m)
+    inline tmat2x3<T>::tmat2x3
+	(
+		tmat3x2<T> const & m
+	)
     {
-        this->value[0] = detail::tvec3<T>(m[0], T(0));
+        this->value[0] = col_type(m[0], T(0));
-        this->value[1] = detail::tvec3<T>(m[1], T(0));
+        this->value[1] = col_type(m[1], T(0));
     }
 
     template <typename T> 
-    inline tmat2x3<T>::tmat2x3(const tmat3x4<T>& m)
+    inline tmat2x3<T>::tmat2x3
+	(
+		tmat3x4<T> const & m
+	)
     {
-        this->value[0] = detail::tvec3<T>(m[0]);
+        this->value[0] = col_type(m[0]);
-        this->value[1] = detail::tvec3<T>(m[1]);
+        this->value[1] = col_type(m[1]);
     }
 
     template <typename T> 
-    inline tmat2x3<T>::tmat2x3(const tmat4x2<T>& m)
+    inline tmat2x3<T>::tmat2x3
+	(
+		tmat4x2<T> const & m
+	)
     {
-        this->value[0] = detail::tvec3<T>(m[0], T(0));
+        this->value[0] = col_type(m[0], T(0));
-        this->value[1] = detail::tvec3<T>(m[1], T(0));
+        this->value[1] = col_type(m[1], T(0));
     }
 
     template <typename T> 
-    inline tmat2x3<T>::tmat2x3(const tmat4x3<T>& m)
+    inline tmat2x3<T>::tmat2x3
+	(
+		tmat4x3<T> const & m
+	)
     {
         this->value[0] = m[0];
         this->value[1] = m[1];
@@ -159,7 +202,10 @@ namespace detail{
     // Unary updatable operators
 
     template <typename T> 
-    inline tmat2x3<T>& tmat2x3<T>::operator= (const tmat2x3<T>& m)
+    inline tmat2x3<T>& tmat2x3<T>::operator= 
+	(
+		tmat2x3<T> const & m
+	)
     {
         this->value[0] = m[0];
         this->value[1] = m[1];
@@ -167,7 +213,23 @@ namespace detail{
     }
 
     template <typename T> 
-    inline tmat2x3<T>& tmat2x3<T>::operator+= (const T & s)
+	template <typename U> 
+    inline tmat2x3<T>& tmat2x3<T>::operator= 
+	(
+		tmat2x3<U> const & m
+	)
+    {
+        this->value[0] = m[0];
+        this->value[1] = m[1];
+        return *this;
+    }
+
+    template <typename T> 
+	template <typename U> 
+    inline tmat2x3<T> & tmat2x3<T>::operator+= 
+	(
+		U const & s
+	)
     {
         this->value[0] += s;
         this->value[1] += s;
@@ -175,7 +237,11 @@ namespace detail{
     }
 
     template <typename T> 
-    inline tmat2x3<T>& tmat2x3<T>::operator+= (const tmat2x3<T>& m)
+	template <typename U> 
+    inline tmat2x3<T>& tmat2x3<T>::operator+=
+	(
+		tmat2x3<U> const & m
+	)
     {
         this->value[0] += m[0];
         this->value[1] += m[1];
@@ -183,7 +249,11 @@ namespace detail{
     }
 
     template <typename T> 
-    inline tmat2x3<T>& tmat2x3<T>::operator-= (const T & s)
+	template <typename U> 
+    inline tmat2x3<T>& tmat2x3<T>::operator-= 
+	(
+		U const & s
+	)
     {
         this->value[0] -= s;
         this->value[1] -= s;
@@ -191,7 +261,11 @@ namespace detail{
     }
 
     template <typename T> 
-    inline tmat2x3<T>& tmat2x3<T>::operator-= (const tmat2x3<T>& m)
+	template <typename U> 
+    inline tmat2x3<T>& tmat2x3<T>::operator-= 
+	(
+		tmat2x3<U> const & m
+	)
     {
         this->value[0] -= m[0];
         this->value[1] -= m[1];
@@ -199,7 +273,11 @@ namespace detail{
     }
 
     template <typename T> 
-    inline tmat2x3<T>& tmat2x3<T>::operator*= (const T & s)
+	template <typename U> 
+    inline tmat2x3<T>& tmat2x3<T>::operator*= 
+	(
+		U const & s
+	)
     {
         this->value[0] *= s;
         this->value[1] *= s;
@@ -207,27 +285,29 @@ namespace detail{
     }
 
     template <typename T> 
-    inline tmat2x3<T>& tmat2x3<T>::operator*= (const tmat3x2<T>& m)
+	template <typename U> 
+    inline tmat2x3<T> & tmat2x3<T>::operator*= 
+	(
+		tmat2x3<U> const & m
+	)
     {
-        return (*this = tmat2x3<T>(*this * m));
+        return (*this = tmat2x3<U>(*this * m));
     }
 
     template <typename T>
-    inline tmat2x3<T> & tmat2x3<T>::operator/= (const T & s)
+	template <typename U> 
+    inline tmat2x3<T> & tmat2x3<T>::operator/= 
+	(
+		U const & s
+	)
     {
         this->value[0] /= s;
         this->value[1] /= s;
         return *this;
     }
-/* ToDo
+
     template <typename T> 
-    inline tmat2x3<T>& tmat2x3<T>::operator/= (const tmat3x2<T>& m)
+    inline tmat2x3<T> & tmat2x3<T>::operator++ ()
-    {
-        return (*this = tmat2x3<T>(*this / m));
-    }
-*/
-    template <typename T> 
-    inline tmat2x3<T>& tmat2x3<T>::operator++ ()
     {
         ++this->value[0];
         ++this->value[1];
@@ -235,46 +315,22 @@ namespace detail{
     }
 
     template <typename T> 
-    inline tmat2x3<T>& tmat2x3<T>::operator-- ()
+    inline tmat2x3<T> & tmat2x3<T>::operator-- ()
     {
         --this->value[0];
         --this->value[1];
         return *this;
     }
     
-    //////////////////////////////////////////////////////////////
-    // Unary constant operators
-    template <typename T> 
-    inline const tmat2x3<T> tmat2x3<T>::operator- () const
-    {
-        return tmat2x3<T>(
-            -this->value[0], 
-            -this->value[1]);
-    }
-
-    template <typename T> 
-    inline const tmat2x3<T> tmat2x3<T>::operator-- (int n) const 
-    {
-        tmat2x3<T> m = *this;
-        --m[0];
-        --m[1];
-        return m;
-    }
-
-    template <typename T> 
-    inline const tmat2x3<T> tmat2x3<T>::operator++ (int n) const
-    {
-        tmat2x3<T> m = *this;
-        ++m[0];
-        ++m[1];
-        return m;
-    }
-
     //////////////////////////////////////////////////////////////
     // Binary operators
 
     template <typename T> 
-    inline tmat2x3<T> operator+ (const tmat2x3<T>& m, const T & s)
+    inline tmat2x3<T> operator+ 
+	(
+		tmat2x3<T> const & m, 
+		typename tmat2x3<T>::value_type const & s
+	)
     {
         return tmat2x3<T>(
             m[0] + s,
@@ -282,7 +338,11 @@ namespace detail{
     }
 
     template <typename T> 
-    inline tmat2x3<T> operator+ (const tmat2x3<T>& m1, const tmat2x3<T>& m2)
+    inline tmat2x3<T> operator+ 
+	(
+		tmat2x3<T> const & m1, 
+		tmat2x3<T> const & m2
+	)
     {
         return tmat2x3<T>(
             m1[0] + m2[0],
@@ -290,7 +350,11 @@ namespace detail{
     }
 
     template <typename T> 
-    inline tmat2x3<T> operator- (const tmat2x3<T>& m, const T & s)
+    inline tmat2x3<T> operator- 
+	(
+		tmat2x3<T> const & m, 
+		typename tmat2x3<T>::value_type const & s
+	)
     {
         return tmat2x3<T>(
             m[0] - s,
@@ -298,7 +362,11 @@ namespace detail{
     }
 
     template <typename T> 
-    inline tmat2x3<T> operator- (const tmat2x3<T>& m1, const tmat2x3<T>& m2)
+    inline tmat2x3<T> operator- 
+	(
+		tmat2x3<T> const & m1, 
+		tmat2x3<T> const & m2
+	)
     {
         return tmat2x3<T>(
             m1[0] - m2[0],
@@ -306,7 +374,11 @@ namespace detail{
     }
 
     template <typename T> 
-    inline tmat2x3<T> operator* (const tmat2x3<T>& m, const T & s)
+    inline tmat2x3<T> operator* 
+	(
+		tmat2x3<T> const & m, 
+		typename tmat2x3<T>::value_type const & s
+	)
     {
         return tmat2x3<T>(
             m[0] * s,
@@ -314,7 +386,11 @@ namespace detail{
     }
 
     template <typename T> 
-    inline tmat2x3<T> operator* (const T & s, const tmat2x3<T> & m)
+    inline tmat2x3<T> operator* 
+	(
+		typename tmat2x3<T>::value_type const & s, 
+		tmat2x3<T> const & m
+	)
     {
         return tmat2x3<T>(
             m[0] * s,
@@ -322,7 +398,11 @@ namespace detail{
     }
    
     template <typename T>
-    inline detail::tvec3<T> operator* (const tmat2x3<T>& m, const detail::tvec2<T>& v)
+    inline typename tmat2x3<T>::row_type operator* 
+	(
+		tmat2x3<T> const & m, 
+		typename tmat2x3<T>::col_type const & v
+	)
     {
         return detail::tvec3<T>(
             m[0][0] * v.x + m[1][0] * v.y,
@@ -332,7 +412,11 @@ namespace detail{
     }
 
     template <typename T> 
-    inline detail::tvec2<T> operator* (const detail::tvec3<T>& v, const tmat2x3<T>& m) 
+    inline typename tmat2x3<T>::col_type operator* 
+	(
+		typename tmat2x3<T>::row_type const & v, 
+		tmat2x3<T> const & m
+	) 
     {
         return detail::tvec2<T>(
             m[0][0] * v.x + m[1][0] * v.y + m[2][0] * v.z + m[3][0] * v.w,
@@ -340,23 +424,27 @@ namespace detail{
     }
 
     template <typename T> 
-    inline tmat3x3<T> operator* (const tmat2x3<T>& m1, const tmat3x2<T>& m2)
+    inline tmat3x3<T> operator* 
+	(
+		tmat2x3<T> const & m1, 
+		tmat3x2<T> const & m2
+	)
     {
-        const T SrcA00 = m1[0][0];
+		typename tmat2x3<T>::value_type SrcA00 = m1[0][0];
-        const T SrcA01 = m1[0][1];
+		typename tmat2x3<T>::value_type SrcA01 = m1[0][1];
-        const T SrcA02 = m1[0][2];
+		typename tmat2x3<T>::value_type SrcA02 = m1[0][2];
-        const T SrcA10 = m1[1][0];
+		typename tmat2x3<T>::value_type SrcA10 = m1[1][0];
-        const T SrcA11 = m1[1][1];
+		typename tmat2x3<T>::value_type SrcA11 = m1[1][1];
-        const T SrcA12 = m1[1][2];
+		typename tmat2x3<T>::value_type SrcA12 = m1[1][2];
 
-        const T SrcB00 = m2[0][0];
+		typename tmat2x3<T>::value_type SrcB00 = m2[0][0];
-        const T SrcB01 = m2[0][1];
+		typename tmat2x3<T>::value_type SrcB01 = m2[0][1];
-        const T SrcB10 = m2[1][0];
+		typename tmat2x3<T>::value_type SrcB10 = m2[1][0];
-        const T SrcB11 = m2[1][1];
+		typename tmat2x3<T>::value_type SrcB11 = m2[1][1];
-        const T SrcB20 = m2[2][0];
+		typename tmat2x3<T>::value_type SrcB20 = m2[2][0];
-        const T SrcB21 = m2[2][1];
+		typename tmat2x3<T>::value_type SrcB21 = m2[2][1];
 
-        tmat3x3<T> Result;
+		tmat3x3<T> Result(tmat3x3<T>::null);
 		Result[0][0] = SrcA00 * SrcB00 + SrcA10 * SrcB01;
 		Result[0][1] = SrcA01 * SrcB00 + SrcA11 * SrcB01;
 		Result[0][2] = SrcA02 * SrcB00 + SrcA12 * SrcB01;
@@ -370,7 +458,11 @@ namespace detail{
     }
 
     template <typename T> 
-    inline tmat2x3<T> operator/ (const tmat2x3<T>& m, const T & s)
+    inline tmat2x3<T> operator/ 
+	(
+		tmat2x3<T> const & m, 
+		typename tmat2x3<T>::value_type const & s
+	)
     {
         return tmat2x3<T>(
             m[0] / s,
@@ -379,7 +471,11 @@ namespace detail{
     }
 
     template <typename T> 
-    inline tmat2x3<T> operator/ (const T & s, const tmat2x3<T>& m)
+    inline tmat2x3<T> operator/ 
+	(
+		typename tmat2x3<T>::value_type const & s, 
+		tmat2x3<T> const & m
+	)
     {
         return tmat2x3<T>(
             s / m[0],
@@ -387,70 +483,40 @@ namespace detail{
             s / m[2]);        
     }
 
-	//template <typename valType> 
-	//tvec3<valType> operator/ 
-	//(
-	//	tmat3x2<valType> const & m, 
-	//	tvec2<valType> const & v
-	//)
-	//{
-	//	return m._inverse() * v;
-	//}
-
-	//template <typename valType> 
-	//tvec3<valType> operator/ 
-	//(
-	//	tvec2<valType> const & v, 
-	//	tmat3x2<valType> const & m
-	//)
-	//{
-	//	return v * m._inverse();
-	//}
-
-	//template <typename valType> 
-	//inline tmat2x2<valType> operator/ 
-	//(
-	//	tmat3x2<valType> const & m1, 
-	//	tmat2x3<valType> const & m2
-	//)
-	//{
-	//	return m1 * m2._inverse();
-	//}
-
 	// Unary constant operators
-    template <typename valType> 
+    template <typename T> 
-    inline tmat2x3<valType> const operator- 
+    inline tmat2x3<T> const operator- 
 	(
-		tmat2x3<valType> const & m
+		tmat2x3<T> const & m
 	)
     {
-        return tmat2x3<valType>(
+        return tmat2x3<T>(
             -m[0], 
             -m[1]);
     }
 
-    template <typename valType> 
+    template <typename T> 
-    inline tmat2x3<valType> const operator++ 
+    inline tmat2x3<T> const operator++ 
 	(
-		tmat2x3<valType> const & m, 
+		tmat2x3<T> const & m, 
 		int
 	) 
     {
-        return tmat2x3<valType>(
+        return tmat2x3<T>(
-            m[0] + valType(1),
+            m[0] + typename tmat2x3<T>::value_type(1),
-            m[1] + valType(1));
+            m[1] + typename tmat2x3<T>::value_type(1));
     }
 
-    template <typename valType> 
+    template <typename T> 
-    inline tmat2x3<valType> const operator-- 
+    inline tmat2x3<T> const operator-- 
 	(
-		tmat2x3<valType> const & m, 
+		tmat2x3<T> const & m, 
 		int
 	) 
     {
-        return tmat2x3<valType>(
+        return tmat2x3<T>(
-            m[0] - valType(1),
+            m[0] - typename tmat2x3<T>::value_type(1),
-            m[1] - valType(1));
+            m[1] - typename tmat2x3<T>::value_type(1));
     }
 
 } //namespace detail

glm/core/type_mat2x4.hpp

@@ -1,16 +1,16 @@
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-// OpenGL Mathematics Copyright (c) 2005 - 2009 G-Truc Creation (www.g-truc.net)
+// OpenGL Mathematics Copyright (c) 2005 - 2010 G-Truc Creation (www.g-truc.net)
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 // Created : 2006-08-05
-// Updated : 2008-08-25
+// Updated : 2010-02-11
 // Licence : This source is under MIT License
-// File    : glm/core/type_mat2x4.h
+// File    : glm/core/type_mat2x4.hpp
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 #ifndef glm_core_type_mat2x4
 #define glm_core_type_mat2x4
 
-#include "type_size.hpp"
+#include "type_mat.hpp"
 
 namespace glm
 {
@@ -39,70 +39,72 @@ namespace glm
 		template <typename T> 
 		struct tmat2x4
 		{
-		public:
+			enum ctor{null};
-			typedef tmat2x4<T>* pointer;
-			typedef const tmat2x4<T>* const_pointer;
-			typedef const tmat2x4<T>*const const_pointer_const;
-			typedef tmat2x4<T>*const pointer_const;
-			typedef tmat2x4<T>& reference;
-			typedef const tmat2x4<T>& const_reference;
-			typedef const tmat2x4<T>& param_type;
-			typedef tmat4x2<T> transpose_type;
-
 			typedef T value_type;
-			typedef detail::tvec2<T> col_type;
+			typedef std::size_t size_type;
-			typedef detail::tvec4<T> row_type;
+			typedef tvec4<T> col_type;
-			typedef glm::sizeType size_type;
+			typedef tvec2<T> row_type;
 			static size_type col_size();
 			static size_type row_size();
-			static bool is_matrix();
 
-		public:
+			typedef tmat2x4<T> type;
-			tmat4x2<T> _inverse() const;
+			typedef tmat4x2<T> transpose_type;
 
 		private:
 			// Data 
-			detail::tvec4<T> value[2];
+			col_type value[2];
 
 		public:
 			// Constructors
 			tmat2x4();
-			explicit tmat2x4(const T x);
+			tmat2x4(tmat2x4 const & m);
+
 			explicit tmat2x4(
-				const T x0, const T y0, const T z0, const T w0,
+				ctor Null);
-				const T x1, const T y1, const T z1, const T w1);
 			explicit tmat2x4(
-				const detail::tvec4<T>& v0, 
+				value_type const & s);
-				const detail::tvec4<T>& v1);
+			explicit tmat2x4(
+				value_type const & x0, value_type const & y0, value_type const & z0, value_type const & w0,
+				value_type const & x1, value_type const & y1, value_type const & z1, value_type const & w1);
+			explicit tmat2x4(
+				col_type const & v0, 
+				col_type const & v1);
 
 			// Conversion
 			template <typename U> 
-			explicit tmat2x4(const tmat2x4<U>& m);
+			explicit tmat2x4(tmat2x4<U> const & m);
 
-			explicit tmat2x4(const tmat2x2<T>& x);
+			explicit tmat2x4(tmat2x2<T> const & x);
-			explicit tmat2x4(const tmat3x3<T>& x);
+			explicit tmat2x4(tmat3x3<T> const & x);
-			explicit tmat2x4(const tmat4x4<T>& x);
+			explicit tmat2x4(tmat4x4<T> const & x);
-			explicit tmat2x4(const tmat2x3<T>& x);
+			explicit tmat2x4(tmat2x3<T> const & x);
-			//explicit tmat2x4(const tmat2x4<T>& x);
+			explicit tmat2x4(tmat3x2<T> const & x);
-			explicit tmat2x4(const tmat3x2<T>& x);
+			explicit tmat2x4(tmat3x4<T> const & x);
-			explicit tmat2x4(const tmat3x4<T>& x);
+			explicit tmat2x4(tmat4x2<T> const & x);
-			explicit tmat2x4(const tmat4x2<T>& x);
+			explicit tmat2x4(tmat4x3<T> const & x);
-			explicit tmat2x4(const tmat4x3<T>& x);
 
 			// Accesses
-			detail::tvec4<T>& operator[](size_type i);
+			col_type & operator[](size_type i);
-			detail::tvec4<T> const & operator[](size_type i) const;
+			col_type const & operator[](size_type i) const;
 
 			// Unary updatable operators
-			tmat2x4<T>& operator=  (const tmat2x4<T>& m);
+			tmat2x4<T>& operator=  (tmat2x4<T> const & m);
-			tmat2x4<T>& operator+= (const T & s);
+			template <typename U> 
-			tmat2x4<T>& operator+= (const tmat2x4<T>& m);
+			tmat2x4<T>& operator=  (tmat2x4<U> const & m);
-			tmat2x4<T>& operator-= (const T & s);
+			template <typename U> 
-			tmat2x4<T>& operator-= (const tmat2x4<T>& m);
+			tmat2x4<T>& operator+= (U const & s);
-			tmat2x4<T>& operator*= (const T & s);
+			template <typename U> 
-			tmat2x4<T>& operator*= (const tmat4x2<T>& m);
+			tmat2x4<T>& operator+= (tmat2x4<U> const & m);
-			tmat2x4<T>& operator/= (const T & s);
+			template <typename U> 
-			//tmat2x4<T>& operator/= (const tmat4x2<T>& m);
+			tmat2x4<T>& operator-= (U const & s);
+			template <typename U> 
+			tmat2x4<T>& operator-= (tmat2x4<U> const & m);
+			template <typename U> 
+			tmat2x4<T>& operator*= (U const & s);
+			template <typename U> 
+			tmat2x4<T>& operator*= (tmat2x4<U> const & m);
+			template <typename U> 
+			tmat2x4<T>& operator/= (U const & s);
 
 			tmat2x4<T>& operator++ ();
 			tmat2x4<T>& operator-- ();
@@ -110,62 +112,79 @@ namespace glm
 
 		// Binary operators
 		template <typename T> 
-		tmat2x4<T> operator+ (const tmat2x4<T>& m, const T & s);
+		tmat2x4<T> operator+ (
+			tmat2x4<T> const & m, 
+			typename tmat2x4<T>::value_type const & s);
 	    
 		template <typename T> 
-		tmat2x4<T> operator+ (const tmat2x4<T>& m1, const tmat2x4<T>& m2);
+		tmat2x4<T> operator+ (
+			tmat2x4<T> const & m1, 
+			tmat2x4<T> const & m2);
 	    
 		template <typename T> 
-		tmat2x4<T> operator- (const tmat2x4<T>& m, const T & s);
+		tmat2x4<T> operator- (
+			tmat2x4<T> const & m, 
+			typename tmat2x4<T>::value_type const & s);
 
 		template <typename T> 
-		tmat2x4<T> operator- (const tmat2x4<T>& m1, const tmat2x4<T>& m2);
+		tmat2x4<T> operator- (
+			tmat2x4<T> const & m1, 
+			tmat2x4<T> const & m2);
 
 		template <typename T> 
-		tmat2x4<T> operator* (const tmat2x4<T>& m, const T & s);
+		tmat2x4<T> operator* (
+			tmat2x4<T> const & m, 
+			typename tmat2x4<T>::value_type const & s);
 
 		template <typename T> 
-		tmat2x4<T> operator* (const T & s, const tmat2x4<T>& m);
+		tmat2x4<T> operator* (
+			typename tmat2x4<T>::value_type const & s, 
+			tmat2x4<T> const & m);
 
 		template <typename T>
-		detail::tvec4<T> operator* (const tmat2x4<T>& m, const detail::tvec2<T>& v);
+		typename tmat2x4<T>::row_type operator* (
+			tmat2x4<T> const & m, 
+			typename tmat2x4<T>::col_type const & v);
 
 		template <typename T> 
-		detail::tvec2<T> operator* (const detail::tvec4<T>& v, const tmat2x4<T>& m);
+		typename tmat2x4<T>::col_type operator* (
+			typename tmat2x4<T>::row_type const & v, 
+			tmat2x4<T> const & m);
 
 		template <typename T>
-		tmat4x4<T> operator* (const tmat2x4<T>& m1, const tmat4x2<T>& m2);
+		tmat2x4<T> operator* (
+			tmat2x4<T> const & m1, 
+			tmat2x4<T> const & m2);
 
 		template <typename T> 
-		tmat4x2<T> operator/ (const tmat2x4<T>& m, const T & s);
+		tmat2x4<T> operator/ (
+			tmat2x4<T> const & m, 
+			typename tmat2x4<T>::value_type const & s);
 
 		template <typename T> 
-		tmat4x2<T> operator/ (const T & s, const tmat2x4<T>& m);
+		tmat2x4<T> operator/ (
-
+			typename tmat2x4<T>::value_type const & s, 
-		//template <typename T> 
+			tmat2x4<T> const & m);
-		//detail::tvec4<T> operator/ (const tmat2x4<T>& m, const detail::tvec2<T>& v);
-
-		//template <typename T> 
-		//detail::tvec2<T> operator/ (const detail::tvec4<T>& v, const tmat2x4<T>& m);
-
-		//template <typename T> 
-		//tmat4x4<T> operator/ (const tmat4x2<T>& m1, const tmat2x4<T>& m2);
 
 		// Unary constant operators
-		template <typename valType> 
+		template <typename T> 
-		tmat2x4<valType> const operator-  (tmat2x4<valType> const & m);
+		tmat2x4<T> const operator-  (
+			tmat2x4<T> const & m);
 
-		template <typename valType> 
+		template <typename T> 
-		tmat2x4<valType> const operator-- (tmat2x4<valType> const & m, int);
+		tmat2x4<T> const operator-- (
+			tmat2x4<T> const & m, 
+			int);
 
-		template <typename valType> 
+		template <typename T> 
-		tmat2x4<valType> const operator++ (tmat2x4<valType> const & m, int);
+		tmat2x4<T> const operator++ (
+			tmat2x4<T> const & m, 
+			int);
 
 	} //namespace detail
 
 	namespace core{
 	namespace type{
-	namespace matrix{
 
 	namespace precision
 	{
@@ -184,21 +203,6 @@ namespace glm
 	}
 	//namespace precision
 
-#ifndef GLM_PRECISION
-	//! 2 columns of 4 components matrix of floating-point numbers. 
-	//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices)
-	typedef detail::tmat2x4<mediump_float>	mat2x4;
-#elif(GLM_PRECISION & GLM_PRECISION_HIGH)
-	typedef detail::tmat2x4<highp_float>	mat2x4;
-#elif(GLM_PRECISION & GLM_PRECISION_MEDIUM)
-	typedef detail::tmat2x4<mediump_float>	mat2x4;
-#elif(GLM_PRECISION & GLM_PRECISION_LOW)
-	typedef detail::tmat2x4<lowp_float>		mat2x4;
-#else
-	typedef detail::tmat2x4<mediump_float>	mat2x4;
-#endif//GLM_PRECISION
-
-	}//namespace matrix
 	}//namespace type
 	}//namespace core
 } //namespace glm

glm/core/type_mat2x4.inl

@@ -1,54 +1,50 @@
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-// OpenGL Mathematics Copyright (c) 2005 - 2009 G-Truc Creation (www.g-truc.net)
+// OpenGL Mathematics Copyright (c) 2005 - 2010 G-Truc Creation (www.g-truc.net)
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 // Created : 2006-08-05
-// Updated : 2006-10-01
+// Updated : 2010-02-03
 // Licence : This source is under MIT License
 // File    : glm/core/type_mat2x4.inl
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 namespace glm{
-namespace detail{
+namespace detail
-
+{
-	template <typename valType> 
+	template <typename T>
-	typename tmat2x4<valType>::size_type tmat2x4<valType>::col_size()
+	inline typename tmat2x4<T>::size_type tmat2x4<T>::col_size()
 	{
-		return typename tmat2x4<valType>::size_type(2);
+		return 4;
 	}
 
-	template <typename valType> 
+	template <typename T>
-	typename tmat2x4<valType>::size_type tmat2x4<valType>::row_size()
+	inline typename tmat2x4<T>::size_type tmat2x4<T>::row_size()
 	{
-		return typename tmat2x4<valType>::size_type(4);
+		return 2;
-	}
-
-	template <typename valType> 
-	bool tmat2x4<valType>::is_matrix()
-	{
-		return true;
 	}
 
 	//////////////////////////////////////
 	// Accesses
 
-	template <typename valType>
+	template <typename T>
-	detail::tvec4<valType>& tmat2x4<valType>::operator[](typename tmat2x4<valType>::size_type i)
+	inline typename tmat2x4<T>::col_type &
+	tmat2x4<T>::operator[]
+	(
+		size_type i
+	)
 	{
-		assert(
+		assert(i >= size_type(0) && i < col_size());
-			i >= typename tmat2x4<valType>::size_type(0) && 
+		return this->value[i];
-			i < tmat2x4<valType>::col_size());
-
-		return value[i];
 	}
 
-	template <typename valType>
+	template <typename T>
-	const detail::tvec4<valType>& tmat2x4<valType>::operator[](typename tmat2x4<valType>::size_type i) const
+	inline typename tmat2x4<T>::col_type const &
+	tmat2x4<T>::operator[]
+	(
+		size_type i
+	) const
 	{
-		assert(
+		assert(i >= size_type(0) && i < col_size());
-			i >= typename tmat2x4<valType>::size_type(0) && 
+		return this->value[i];
-			i < tmat2x4<valType>::col_size());
-
-		return value[i];
 	}
 
     //////////////////////////////////////////////////////////////
@@ -57,33 +53,56 @@ namespace detail{
     template <typename T> 
     inline tmat2x4<T>::tmat2x4()
     {
-        this->value[0] = detail::tvec4<T>(1, 0, 0, 0);
+		value_type const Zero(0);
-        this->value[1] = detail::tvec4<T>(0, 1, 0, 0);
+		value_type const One(1);
-    }
+        this->value[0] = col_type(One, Zero, Zero, Zero);
-
+        this->value[1] = col_type(Zero, One, Zero, Zero);
-    template <typename T> 
-    inline tmat2x4<T>::tmat2x4(const T f)
-    {
-        this->value[0] = detail::tvec4<T>(f, 0, 0, 0);
-        this->value[1] = detail::tvec4<T>(0, f, 0, 0);
     }
 
     template <typename T> 
     inline tmat2x4<T>::tmat2x4
 	(
-        const T x0, const T y0, const T z0, const T w0,
+		tmat2x4<T> const & m
-        const T x1, const T y1, const T z1, const T w1
 	)
     {
-        this->value[0] = detail::tvec4<T>(x0, y0, z0, w0);
+        this->value[0] = m.value[0];
-        this->value[1] = detail::tvec4<T>(x1, y1, z1, w1);
+        this->value[1] = m.value[1];
     }
 
     template <typename T> 
     inline tmat2x4<T>::tmat2x4
 	(
-        const detail::tvec4<T> & v0, 
+		ctor
-        const detail::tvec4<T> & v1
+	)
+    {}
+
+    template <typename T> 
+    inline tmat2x4<T>::tmat2x4
+	(
+		value_type const & s
+	)
+    {
+		value_type const Zero(0);
+        this->value[0] = col_type(s, Zero, Zero, Zero);
+        this->value[1] = col_type(Zero, Zero, Zero, Zero);
+    }
+
+    template <typename T> 
+    inline tmat2x4<T>::tmat2x4
+    (
+        value_type const & x0, value_type const & y0, value_type const & z0, value_type const & w0,
+        value_type const & x1, value_type const & y1, value_type const & z1, value_type const & w1
+    )
+    {
+        this->value[0] = col_type(x0, y0, z0, w0);
+        this->value[1] = col_type(x1, y1, z1, w1);
+    }
+
+    template <typename T> 
+    inline tmat2x4<T>::tmat2x4
+    (
+        col_type const & v0, 
+        col_type const & v1
     )
     {
         this->value[0] = v0;
@@ -93,73 +112,103 @@ namespace detail{
     // Conversion
     template <typename T> 
     template <typename U> 
-    inline tmat2x4<T>::tmat2x4(const tmat2x4<U>& m)
+    inline tmat2x4<T>::tmat2x4
+	(
+		tmat2x4<U> const & m
+	)
     {
-        this->value[0] = detail::tvec4<T>(m[0]);
+        this->value[0] = col_type(m[0]);
-        this->value[1] = detail::tvec4<T>(m[1]);
+        this->value[1] = col_type(m[1]);
 	}
 
     template <typename T> 
-    inline tmat2x4<T>::tmat2x4(tmat2x2<T> const & m)
+    inline tmat2x4<T>::tmat2x4
+	(
+		tmat2x2<T> const & m
+	)
     {
-        this->value[0] = detail::tvec4<T>(m[0], detail::tvec2<T>(0));
+        this->value[0] = col_type(m[0], detail::tvec2<T>(0));
-        this->value[1] = detail::tvec4<T>(m[1], detail::tvec2<T>(0));
+        this->value[1] = col_type(m[1], detail::tvec2<T>(0));
     }
 
     template <typename T> 
-    inline tmat2x4<T>::tmat2x4(const tmat3x3<T>& m)
+    inline tmat2x4<T>::tmat2x4
+	(
+		tmat3x3<T> const & m
+	)
     {
-        this->value[0] = detail::tvec4<T>(m[0], T(0));
+        this->value[0] = col_type(m[0], T(0));
-        this->value[1] = detail::tvec4<T>(m[1], T(0));
+        this->value[1] = col_type(m[1], T(0));
     }
 
     template <typename T> 
-    inline tmat2x4<T>::tmat2x4(const tmat4x4<T>& m)
+    inline tmat2x4<T>::tmat2x4
+	(
+		tmat4x4<T> const & m
+	)
     {
-        this->value[0] = detail::tvec4<T>(m[0]);
+        this->value[0] = col_type(m[0]);
-        this->value[1] = detail::tvec4<T>(m[1]);
+        this->value[1] = col_type(m[1]);
     }
 
     template <typename T> 
-    inline tmat2x4<T>::tmat2x4(const tmat2x3<T>& m)
+    inline tmat2x4<T>::tmat2x4
+	(
+		tmat2x3<T> const & m
+	)
     {
-        this->value[0] = detail::tvec4<T>(m[0], T(0));
+        this->value[0] = col_type(m[0], T(0));
-        this->value[1] = detail::tvec4<T>(m[1], T(0));
+        this->value[1] = col_type(m[1], T(0));
     }
 
     template <typename T> 
-    inline tmat2x4<T>::tmat2x4(const tmat3x2<T>& m)
+    inline tmat2x4<T>::tmat2x4
+	(
+		tmat3x2<T> const & m
+	)
     {
-        this->value[0] = detail::tvec4<T>(m[0], detail::tvec2<T>(0));
+        this->value[0] = col_type(m[0], detail::tvec2<T>(0));
-        this->value[1] = detail::tvec4<T>(m[1], detail::tvec2<T>(0));
+        this->value[1] = col_type(m[1], detail::tvec2<T>(0));
     }
 
     template <typename T> 
-    inline tmat2x4<T>::tmat2x4(const tmat3x4<T>& m)
+    inline tmat2x4<T>::tmat2x4
+	(
+		tmat3x4<T> const & m
+	)
     {
         this->value[0] = m[0];
         this->value[1] = m[1];
     }
 
     template <typename T> 
-    inline tmat2x4<T>::tmat2x4(const tmat4x2<T>& m)
+    inline tmat2x4<T>::tmat2x4
+	(
+		tmat4x2<T> const & m
+	)
     {
-        this->value[0] = detail::tvec4<T>(m[0], detail::tvec2<T>(T(0)));
+        this->value[0] = col_type(m[0], detail::tvec2<T>(T(0)));
-        this->value[1] = detail::tvec4<T>(m[1], detail::tvec2<T>(T(0)));
+        this->value[1] = col_type(m[1], detail::tvec2<T>(T(0)));
     }
 
     template <typename T> 
-    inline tmat2x4<T>::tmat2x4(const tmat4x3<T>& m)
+    inline tmat2x4<T>::tmat2x4
+	(
+		tmat4x3<T> const & m
+	)
     {
-        this->value[0] = detail::tvec4<T>(m[0], T(0));
+        this->value[0] = col_type(m[0], T(0));
-        this->value[1] = detail::tvec4<T>(m[1], T(0));
+        this->value[1] = col_type(m[1], T(0));
     }
 
     //////////////////////////////////////////////////////////////
     // Unary updatable operators
 
     template <typename T> 
-    inline tmat2x4<T>& tmat2x4<T>::operator= (const tmat2x4<T>& m)
+    inline tmat2x4<T>& tmat2x4<T>::operator= 
+	(
+		tmat2x4<T> const & m
+	)
     {
         this->value[0] = m[0];
         this->value[1] = m[1];
@@ -167,7 +216,23 @@ namespace detail{
     }
 
     template <typename T> 
-    inline tmat2x4<T>& tmat2x4<T>::operator+= (const T & s)
+	template <typename U> 
+    inline tmat2x4<T>& tmat2x4<T>::operator= 
+	(
+		tmat2x4<U> const & m
+	)
+    {
+        this->value[0] = m[0];
+        this->value[1] = m[1];
+        return *this;
+    }
+
+    template <typename T> 
+	template <typename U> 
+    inline tmat2x4<T>& tmat2x4<T>::operator+= 
+	(
+		U const & s
+	)
     {
         this->value[0] += s;
         this->value[1] += s;
@@ -175,7 +240,11 @@ namespace detail{
     }
 
     template <typename T> 
-    inline tmat2x4<T>& tmat2x4<T>::operator+= (const tmat2x4<T>& m)
+	template <typename U> 
+    inline tmat2x4<T>& tmat2x4<T>::operator+= 
+	(
+		tmat2x4<U> const & m
+	)
     {
         this->value[0] += m[0];
         this->value[1] += m[1];
@@ -183,7 +252,11 @@ namespace detail{
     }
 
     template <typename T> 
-    inline tmat2x4<T>& tmat2x4<T>::operator-= (const T & s)
+	template <typename U> 
+    inline tmat2x4<T>& tmat2x4<T>::operator-= 
+	(
+		U const & s
+	)
     {
         this->value[0] -= s;
         this->value[1] -= s;
@@ -191,7 +264,11 @@ namespace detail{
     }
 
     template <typename T> 
-    inline tmat2x4<T>& tmat2x4<T>::operator-= (const tmat2x4<T>& m)
+	template <typename U> 
+    inline tmat2x4<T>& tmat2x4<T>::operator-= 
+	(
+		tmat2x4<U> const & m
+	)
     {
         this->value[0] -= m[0];
         this->value[1] -= m[1];
@@ -199,7 +276,11 @@ namespace detail{
     }
 
     template <typename T> 
-    inline tmat2x4<T>& tmat2x4<T>::operator*= (const T & s)
+	template <typename U> 
+    inline tmat2x4<T>& tmat2x4<T>::operator*= 
+	(
+		U const & s
+	)
     {
         this->value[0] *= s;
         this->value[1] *= s;
@@ -207,25 +288,27 @@ namespace detail{
     }
 
     template <typename T> 
-    inline tmat2x4<T>& tmat2x4<T>::operator*= (const tmat4x2<T>& m)
+	template <typename U> 
+    inline tmat2x4<T>& tmat2x4<T>::operator*=
+	(
+		tmat2x4<U> const & m
+	)
     {
         return (*this = tmat2x4<T>(*this * m));
     }
 
     template <typename T> 
-    inline tmat2x4<T> & tmat2x4<T>::operator/= (const T & s)
+	template <typename U> 
+    inline tmat2x4<T> & tmat2x4<T>::operator/= 
+	(
+		U const & s
+	)
     {
         this->value[0] /= s;
         this->value[1] /= s;
         return *this;
     }
-/* ToDo
+
-    template <typename T> 
-    inline tmat2x4<T>& tmat2x4<T>::operator/= (const tmat4x2<T>& m)
-    {
-        return (*this = tmat2x4<T>(*this / m));
-    }
-*/
     template <typename T> 
     inline tmat2x4<T>& tmat2x4<T>::operator++ ()
     {
@@ -242,19 +325,15 @@ namespace detail{
         return *this;
     }
 
-    //////////////////////////////////////////////////////////////
-    // inverse
-    template <typename valType> 
-    inline tmat4x2<valType> tmat2x4<valType>::_inverse() const
-    {
-		assert(0); //g.truc.creation[at]gmail.com
-    }
-
     //////////////////////////////////////////////////////////////
     // Binary operators
 
     template <typename T> 
-    inline tmat2x4<T> operator+ (const tmat2x4<T>& m, const T & s)
+    inline tmat2x4<T> operator+
+	(
+		tmat2x4<T> const & m, 
+		typename tmat2x4<T>::value_type const & s
+	)
     {
         return tmat2x4<T>(
             m[0] + s,
@@ -262,7 +341,11 @@ namespace detail{
     }
 
     template <typename T> 
-    inline tmat2x4<T> operator+ (const tmat2x4<T>& m1, const tmat2x4<T>& m2)
+    inline tmat2x4<T> operator+ 
+	(
+		tmat2x4<T> const & m1, 
+		tmat2x4<T> const & m2
+	)
     {
         return tmat2x4<T>(
             m1[0] + m2[0],
@@ -270,7 +353,11 @@ namespace detail{
     }
 
     template <typename T> 
-    inline tmat2x4<T> operator- (const tmat2x4<T>& m, const T & s)
+    inline tmat2x4<T> operator- 
+	(
+		tmat2x4<T> const & m, 
+		typename tmat2x4<T>::value_type const & s
+	)
     {
         return tmat2x4<T>(
             m[0] - s,
@@ -278,7 +365,11 @@ namespace detail{
     }
 
     template <typename T> 
-    inline tmat2x4<T> operator- (const tmat2x4<T>& m1, const tmat2x4<T>& m2)
+    inline tmat2x4<T> operator- 
+	(
+		tmat2x4<T> const & m1, 
+		tmat2x4<T> const & m2
+	)
     {
         return tmat2x4<T>(
             m1[0] - m2[0],
@@ -286,7 +377,11 @@ namespace detail{
     }
 
     template <typename T> 
-    inline tmat2x4<T> operator* (const tmat2x4<T>& m, const T & s)
+    inline tmat2x4<T> operator* 
+	(
+		tmat2x4<T> const & m, 
+		typename tmat2x4<T>::value_type const & s
+	)
     {
         return tmat2x4<T>(
             m[0] * s,
@@ -294,7 +389,11 @@ namespace detail{
     }
 
     template <typename T> 
-    inline tmat2x4<T> operator* (const T & s, const tmat2x4<T> & m)
+    inline tmat2x4<T> operator*
+	(
+		typename tmat2x4<T>::value_type const & s, 
+		tmat2x4<T> const & m
+	)
     {
         return tmat2x4<T>(
             m[0] * s,
@@ -302,9 +401,13 @@ namespace detail{
     }
    
     template <typename T>
-    inline detail::tvec4<T> operator* (const tmat2x4<T>& m, const detail::tvec2<T>& v)
+    inline typename tmat2x4<T>::row_type operator* 
+	(
+		tmat2x4<T> const & m, 
+		typename tmat2x4<T>::col_type const & v
+	)
     {
-        return detail::tvec4<T>(
+        return typename tmat2x4<T>::row_type(
             m[0][0] * v.x + m[1][0] * v.y,
             m[0][1] * v.x + m[1][1] * v.y,
             m[0][2] * v.x + m[1][2] * v.y,
@@ -312,35 +415,43 @@ namespace detail{
     }
 
     template <typename T> 
-    inline detail::tvec2<T> operator* (const detail::tvec4<T>& v, const tmat2x4<T>& m) 
+    inline typename tmat2x4<T>::col_type operator* 
+	(
+		typename tmat2x4<T>::row_type const & v, 
+		tmat2x4<T> const & m
+	) 
     {
-        return detail::tvec4<T>(
+        return typename tmat2x4<T>::col_type(
             m[0][0] * v.x + m[1][0] * v.y + m[2][0] * v.z + m[3][0] * v.w,
             m[0][1] * v.x + m[1][1] * v.y + m[2][1] * v.z + m[3][1] * v.w);
     }
 
     template <typename T> 
-    inline tmat4x4<T> operator* (const tmat2x4<T>& m1, const tmat4x2<T>& m2)
+    inline tmat4x4<T> operator* 
+	(
+		tmat2x4<T> const & m1, 
+		tmat4x2<T> const & m2
+	)
     {
-        const T SrcA00 = m1[0][0];
+		typename tmat2x4<T>::value_type SrcA00 = m1[0][0];
-        const T SrcA01 = m1[0][1];
+		typename tmat2x4<T>::value_type SrcA01 = m1[0][1];
-        const T SrcA02 = m1[0][2];
+		typename tmat2x4<T>::value_type SrcA02 = m1[0][2];
-        const T SrcA03 = m1[0][3];
+		typename tmat2x4<T>::value_type SrcA03 = m1[0][3];
-        const T SrcA10 = m1[1][0];
+		typename tmat2x4<T>::value_type SrcA10 = m1[1][0];
-        const T SrcA11 = m1[1][1];
+		typename tmat2x4<T>::value_type SrcA11 = m1[1][1];
-        const T SrcA12 = m1[1][2];
+		typename tmat2x4<T>::value_type SrcA12 = m1[1][2];
-        const T SrcA13 = m1[1][3];
+		typename tmat2x4<T>::value_type SrcA13 = m1[1][3];
 
-        const T SrcB00 = m2[0][0];
+		typename tmat2x4<T>::value_type SrcB00 = m2[0][0];
-        const T SrcB01 = m2[0][1];
+		typename tmat2x4<T>::value_type SrcB01 = m2[0][1];
-        const T SrcB10 = m2[1][0];
+		typename tmat2x4<T>::value_type SrcB10 = m2[1][0];
-        const T SrcB11 = m2[1][1];
+		typename tmat2x4<T>::value_type SrcB11 = m2[1][1];
-        const T SrcB20 = m2[2][0];
+		typename tmat2x4<T>::value_type SrcB20 = m2[2][0];
-        const T SrcB21 = m2[2][1];
+		typename tmat2x4<T>::value_type SrcB21 = m2[2][1];
-        const T SrcB30 = m2[3][0];
+		typename tmat2x4<T>::value_type SrcB30 = m2[3][0];
-        const T SrcB31 = m2[3][1];
+		typename tmat2x4<T>::value_type SrcB31 = m2[3][1];
 
-        tmat4x4<T> Result;
+		tmat4x4<T> Result(tmat4x4<T>::null);
 		Result[0][0] = SrcA00 * SrcB00 + SrcA10 * SrcB01;
 		Result[0][1] = SrcA01 * SrcB00 + SrcA11 * SrcB01;
 		Result[0][2] = SrcA02 * SrcB00 + SrcA12 * SrcB01;
@@ -361,7 +472,11 @@ namespace detail{
     }
 
     template <typename T> 
-    inline tmat2x4<T> operator/ (const tmat2x4<T>& m, const T & s)
+    inline tmat2x4<T> operator/ 
+	(
+		tmat2x4<T> const & m, 
+		typename tmat2x4<T>::value_type const & s
+	)
     {
         return tmat2x4<T>(
             m[0] / s,
@@ -371,7 +486,11 @@ namespace detail{
     }
 
     template <typename T> 
-    inline tmat2x4<T> operator/ (const T & s, const tmat2x4<T>& m)
+    inline tmat2x4<T> operator/ 
+	(
+		typename tmat2x4<T>::value_type const & s, 
+		tmat2x4<T> const & m
+	)
     {
         return tmat2x4<T>(
             s / m[0],
@@ -380,70 +499,40 @@ namespace detail{
             s / m[3]);        
     }
 
-	//template <typename valType> 
-	//tvec4<valType> operator/ 
-	//(
-	//	tmat4x2<valType> const & m, 
-	//	tvec2<valType> const & v
-	//)
-	//{
-	//	return m._inverse() * v;
-	//}
-
-	//template <typename valType> 
-	//tvec4<valType> operator/ 
-	//(
-	//	tvec2<valType> const & v, 
-	//	tmat4x2<valType> const & m
-	//)
-	//{
-	//	return v * m._inverse();
-	//}
-
-	//template <typename valType> 
-	//inline tmat2x2<valType> operator/ 
-	//(
-	//	tmat4x2<valType> const & m1, 
-	//	tmat2x4<valType> const & m2
-	//)
-	//{
-	//	return m1 * m2._inverse();
-	//}
-
 	// Unary constant operators
-    template <typename valType> 
+    template <typename T> 
-    inline tmat2x4<valType> const operator- 
+    inline tmat2x4<T> const operator- 
 	(
-		tmat2x4<valType> const & m
+		tmat2x4<T> const & m
 	)
     {
-        return tmat2x4<valType>(
+        return tmat2x4<T>(
             -m[0], 
             -m[1]);
     }
 
-    template <typename valType> 
+    template <typename T> 
-    inline tmat2x4<valType> const operator++ 
+    inline tmat2x4<T> const operator++ 
 	(
-		tmat2x4<valType> const & m, 
+		tmat2x4<T> const & m, 
 		int
 	) 
     {
-        return tmat2x4<valType>(
+        return tmat2x4<T>(
-            m[0] + valType(1),
+            m[0] + typename tmat2x4<T>::value_type(1),
-            m[1] + valType(1));
+            m[1] + typename tmat2x4<T>::value_type(1));
     }
 
-    template <typename valType> 
+    template <typename T> 
-    inline tmat2x4<valType> const operator-- 
+    inline tmat2x4<T> const operator-- 
 	(
-		tmat2x4<valType> const & m, 
+		tmat2x4<T> const & m, 
 		int
 	) 
     {
-        return tmat2x4<valType>(
+        return tmat2x4<T>(
-            m[0] - valType(1),
+            m[0] - typename tmat2x4<T>::value_type(1),
-            m[1] - valType(1));
+            m[1] - typename tmat2x4<T>::value_type(1));
     }
 
 } //namespace detail

glm/core/type_mat3x2.hpp

@@ -1,16 +1,16 @@
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-// OpenGL Mathematics Copyright (c) 2005 - 2009 G-Truc Creation (www.g-truc.net)
+// OpenGL Mathematics Copyright (c) 2005 - 2010 G-Truc Creation (www.g-truc.net)
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 // Created : 2006-08-05
-// Updated : 2008-08-30
+// Updated : 2010-02-05
 // Licence : This source is under MIT License
-// File    : glm/core/type_mat3x2.h
+// File    : glm/core/type_mat3x2.hpp
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 #ifndef glm_core_type_mat3x2
 #define glm_core_type_mat3x2
 
-#include "type_size.hpp"
+#include "type_mat.hpp"
 
 namespace glm
 {
@@ -39,134 +39,154 @@ namespace glm
 		template <typename T> 
 		struct tmat3x2
 		{
-		public:
+			enum ctor{null};
-			typedef tmat3x2<T>* pointer;
-			typedef const tmat3x2<T>* const_pointer;
-			typedef const tmat3x2<T>*const const_pointer_const;
-			typedef tmat3x2<T>*const pointer_const;
-			typedef tmat3x2<T>& reference;
-			typedef const tmat3x2<T>& const_reference;
-			typedef const tmat3x2<T>& param_type;
-			typedef tmat2x3<T> transpose_type;
-
 			typedef T value_type;
-			typedef detail::tvec3<T> col_type;
+			typedef std::size_t size_type;
-			typedef detail::tvec2<T> row_type;
+			typedef tvec2<T> col_type;
-			typedef glm::sizeType size_type;
+			typedef tvec3<T> row_type;
 			static size_type col_size();
 			static size_type row_size();
-			static bool is_matrix();
 
-		public:
+			typedef tmat3x2<T> type;
-			tmat2x3<T> _inverse() const;
+			typedef tmat2x3<T> transpose_type;
 
 		private:
 			// Data
-			detail::tvec2<T> value[3];
+			col_type value[3];
 
 		public:
 			// Constructors
 			tmat3x2();
-			explicit tmat3x2(const T x);
+			tmat3x2(tmat3x2 const & m);
+
 			explicit tmat3x2(
-				const T x0, const T y0,
+				ctor);
-				const T x1, const T y1,
-				const T x2, const T y2);
 			explicit tmat3x2(
-				const detail::tvec2<T>& v0, 
+				value_type const & s);
-				const detail::tvec2<T>& v1,
+			explicit tmat3x2(
-				const detail::tvec2<T>& v2);
+				value_type const & x0, value_type const & y0,
+				value_type const & x1, value_type const & y1,
+				value_type const & x2, value_type const & y2);
+			explicit tmat3x2(
+				col_type const & v0, 
+				col_type const & v1,
+				col_type const & v2);
 
 			// Conversion
 			template <typename U> 
-			explicit tmat3x2(const tmat3x2<U>& m);
+			explicit tmat3x2(tmat3x2<U> const & m);
 
-			explicit tmat3x2(const tmat2x2<T>& x);
+			explicit tmat3x2(tmat2x2<T> const & x);
-			explicit tmat3x2(const tmat3x3<T>& x);
+			explicit tmat3x2(tmat3x3<T> const & x);
-			explicit tmat3x2(const tmat4x4<T>& x);
+			explicit tmat3x2(tmat4x4<T> const & x);
-			explicit tmat3x2(const tmat2x3<T>& x);
+			explicit tmat3x2(tmat2x3<T> const & x);
-			explicit tmat3x2(const tmat2x4<T>& x);
+			explicit tmat3x2(tmat2x4<T> const & x);
-			explicit tmat3x2(const tmat3x4<T>& x);
+			explicit tmat3x2(tmat3x4<T> const & x);
-			explicit tmat3x2(const tmat4x2<T>& x);
+			explicit tmat3x2(tmat4x2<T> const & x);
-			explicit tmat3x2(const tmat4x3<T>& x);
+			explicit tmat3x2(tmat4x3<T> const & x);
 
 			// Accesses
-			detail::tvec2<T>& operator[](size_type i);
+			col_type & operator[](size_type i);
-			const detail::tvec2<T>& operator[](size_type i) const;
+			col_type const & operator[](size_type i) const;
 
 			// Unary updatable operators
-			tmat3x2<T>& operator=  (const tmat3x2<T>& m);
+			tmat3x2<T> & operator=  (tmat3x2<T> const & m);
-			tmat3x2<T>& operator+= (const T & s);
+			template <typename U> 
-			tmat3x2<T>& operator+= (const tmat3x2<T>& m);
+			tmat3x2<T> & operator=  (tmat3x2<U> const & m);
-			tmat3x2<T>& operator-= (const T & s);
+			template <typename U> 
-			tmat3x2<T>& operator-= (const tmat3x2<T>& m);
+			tmat3x2<T> & operator+= (U const & s);
-			tmat3x2<T>& operator*= (const T & s);
+			template <typename U> 
-			tmat3x2<T>& operator*= (const tmat2x3<T>& m);
+			tmat3x2<T> & operator+= (tmat3x2<U> const & m);
-			tmat3x2<T>& operator/= (const T & s);
+			template <typename U> 
-			//tmat3x2<T>& operator/= (const tmat2x3<T>& m);
+			tmat3x2<T> & operator-= (U const & s);
+			template <typename U> 
+			tmat3x2<T> & operator-= (tmat3x2<U> const & m);
+			template <typename U> 
+			tmat3x2<T> & operator*= (U const & s);
+			template <typename U> 
+			tmat3x2<T> & operator*= (tmat3x2<U> const & m);
+			template <typename U> 
+			tmat3x2<T> & operator/= (U const & s);
 
-			tmat3x2<T>& operator++ ();
+			tmat3x2<T> & operator++ ();
-			tmat3x2<T>& operator-- ();
+			tmat3x2<T> & operator-- ();
 		};
 
 		// Binary operators
 		template <typename T> 
-		tmat3x2<T> operator+ (const tmat3x2<T>& m, const T & s);
+		tmat3x2<T> operator+ (
+			tmat3x2<T> const & m, 
+			typename tmat3x2<T>::value_type const & s);
 	    
 		template <typename T> 
-		tmat3x2<T> operator+ (const tmat3x2<T>& m1, const tmat3x2<T>& m2);
+		tmat3x2<T> operator+ (
+			tmat3x2<T> const & m1, 
+			tmat3x2<T> const & m2);
 	    
 		template <typename T> 
-		tmat3x2<T> operator- (const tmat3x2<T>& m, const T & s);
+		tmat3x2<T> operator- (
+			tmat3x2<T> const & m, 
+			typename tmat3x2<T>::value_type const & s);
 
 		template <typename T> 
-		tmat3x2<T> operator- (const tmat3x2<T>& m1, const tmat3x2<T>& m2);
+		tmat3x2<T> operator- (
+			tmat3x2<T> const & m1, 
+			tmat3x2<T> const & m2);
 
 		template <typename T> 
-		tmat3x2<T> operator* (const tmat3x2<T>& m, const T & s);
+		tmat3x2<T> operator* (
+			tmat3x2<T> const & m, 
+			typename tmat3x2<T>::value_type const & s);
 
 		template <typename T> 
-		tmat3x2<T> operator* (const T & s, const tmat3x4<T>& m);
+		tmat3x2<T> operator* (
+			typename tmat3x2<T>::value_type const & s, 
+			tmat3x2<T> const & m);
 
 		template <typename T>
-		detail::tvec2<T> operator* (const tmat3x2<T>& m, const detail::tvec3<T>& v);
+		typename tmat3x2<T>::row_type operator* (
+			tmat3x2<T> const & m, 
+			typename tmat3x2<T>::col_type const & v);
 
 		template <typename T> 
-		detail::tvec3<T> operator* (const detail::tvec2<T>& v, const tmat3x2<T>& m);
+		typename tmat3x2<T>::col_type operator* (
+			typename tmat3x2<T>::row_type const & v,
+			tmat3x2<T> const & m);
 
 		template <typename T>
-		tmat2x2<T> operator* (const tmat3x2<T>& m1, const tmat2x3<T>& m2);
+		tmat2x2<T> operator* (
+			tmat3x2<T> const & m1, 
+			tmat2x3<T> const & m2);
 
 		template <typename T> 
-		tmat2x3<T> operator/ (const tmat2x3<T>& m, const T & s);
+		tmat3x2<T> operator/ (
+			tmat3x2<T> const & m, 
+			typename tmat3x2<T>::value_type const & s);
 
 		template <typename T> 
-		tmat2x3<T> operator/ (const T s, const tmat2x3<T>& m);
+		tmat3x2<T> operator/ (
-
+			typename tmat3x2<T>::value_type const & s, 
-		//template <typename T> 
+			tmat3x2<T> const & m);
-		//detail::tvec2<T> operator/ (const tmat3x2<T>& m, const detail::tvec3<T>& v);
-
-		//template <typename T> 
-		//detail::tvec3<T> operator/ (const detail::tvec2<T>& v, const tmat3x2<T>& m);
-
-		//template <typename T> 
-		//tmat2x2<T> operator/ (const tmat2x3<T>& m1, const tmat3x2<T>& m2);
 
 		// Unary constant operators
-		template <typename valType> 
+		template <typename T> 
-		tmat3x2<valType> const operator-  (tmat3x2<valType> const & m);
+		tmat3x2<T> const operator-  (
+			tmat3x2<T> const & m);
 
-		template <typename valType> 
+		template <typename T> 
-		tmat3x2<valType> const operator-- (tmat3x2<valType> const & m, int);
+		tmat3x2<T> const operator-- (
+			tmat3x2<T> const & m, 
+			int);
 
-		template <typename valType> 
+		template <typename T> 
-		tmat3x2<valType> const operator++ (tmat3x2<valType> const & m, int);
+		tmat3x2<T> const operator++ (
+			tmat3x2<T> const & m, 
+			int);
 
 	} //namespace detail
 
 	namespace core{
 	namespace type{
-	namespace matrix{
 
 	namespace precision
 	{
@@ -185,21 +205,6 @@ namespace glm
 	}
 	//namespace precision
 
-#ifndef GLM_PRECISION 
-	//! 3 columns of 2 components matrix of floating-point numbers. 
-	//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices)
-	typedef detail::tmat3x2<mediump_float>	mat3x2;
-#elif(GLM_PRECISION & GLM_PRECISION_HIGH)
-	typedef detail::tmat3x2<highp_float>	mat3x2;
-#elif(GLM_PRECISION & GLM_PRECISION_MEDIUM)
-	typedef detail::tmat3x2<mediump_float>	mat3x2;
-#elif(GLM_PRECISION & GLM_PRECISION_LOW)
-	typedef detail::tmat3x2<lowp_float>		mat3x2;
-#else
-	typedef detail::tmat3x2<mediump_float>	mat3x2;
-#endif//GLM_PRECISION
-
-	}//namespace matrix
 	}//namespace type
 	}//namespace core
 } //namespace glm

glm/core/type_mat3x2.inl

@@ -1,54 +1,50 @@
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-// OpenGL Mathematics Copyright (c) 2005 - 2009 G-Truc Creation (www.g-truc.net)
+// OpenGL Mathematics Copyright (c) 2005 - 2010 G-Truc Creation (www.g-truc.net)
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 // Created : 2006-08-05
-// Updated : 2006-10-01
+// Updated : 2010-01-05
 // Licence : This source is under MIT License
 // File    : glm/core/type_mat3x2.inl
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 namespace glm{
-namespace detail{
+namespace detail
-
+{
-	template <typename valType> 
+	template <typename T>
-	typename tmat3x2<valType>::size_type tmat3x2<valType>::col_size()
+	inline typename tmat3x2<T>::size_type tmat3x2<T>::col_size()
 	{
-		return typename tmat3x2<valType>::size_type(3);
+		return 2;
 	}
 
-	template <typename valType> 
+	template <typename T>
-	typename tmat3x2<valType>::size_type tmat3x2<valType>::row_size()
+	inline typename tmat3x2<T>::size_type tmat3x2<T>::row_size()
 	{
-		return typename tmat3x2<valType>::size_type(2);
+		return 3;
-	}
-
-	template <typename valType> 
-	bool tmat3x2<valType>::is_matrix()
-	{
-		return true;
 	}
 
 	//////////////////////////////////////
 	// Accesses
 
-	template <typename valType>
+	template <typename T>
-	detail::tvec2<valType>& tmat3x2<valType>::operator[](typename tmat3x2<valType>::size_type i)
+	inline typename tmat3x2<T>::col_type &
+	tmat3x2<T>::operator[]
+	(
+		size_type i
+	)
 	{
-		assert(
+		assert(i >= size_type(0) && i < col_size());
-			i >= typename tmat3x2<valType>::size_type(0) && 
+		return this->value[i];
-			i < tmat3x2<valType>::col_size());
-
-		return value[i];
 	}
 
-	template <typename valType>
+	template <typename T>
-	const detail::tvec2<valType>& tmat3x2<valType>::operator[](typename tmat3x2<valType>::size_type i) const
+	inline typename tmat3x2<T>::col_type const & 
+	tmat3x2<T>::operator[]
+	(
+		size_type i
+	) const
 	{
-		assert(
+		assert(i >= size_type(0) && i < col_size());
-			i >= typename tmat3x2<valType>::size_type(0) && 
+		return this->value[i];
-			i < tmat3x2<valType>::col_size());
-
-		return value[i];
 	}
 
     //////////////////////////////////////////////////////////////
@@ -57,38 +53,41 @@ namespace detail{
     template <typename T> 
     inline tmat3x2<T>::tmat3x2()
     {
-        this->value[0] = detail::tvec2<T>(1, 0);
+        this->value[0] = col_type(1, 0);
-        this->value[1] = detail::tvec2<T>(0, 1);
+        this->value[1] = col_type(0, 1);
-        this->value[2] = detail::tvec2<T>(0, 0);
+        this->value[2] = col_type(0, 0);
-    }
-
-    template <typename T> 
-    inline tmat3x2<T>::tmat3x2(const T f)
-    {
-        this->value[0] = detail::tvec2<T>(f, 0);
-        this->value[1] = detail::tvec2<T>(0, f);
-        this->value[2] = detail::tvec2<T>(0, 0);
     }
 
     template <typename T> 
     inline tmat3x2<T>::tmat3x2
 	(
-        const T x0, const T y0,
+		value_type const & s
-        const T x1, const T y1,
-        const T x2, const T y2
 	)
     {
-        this->value[0] = detail::tvec2<T>(x0, y0);
+        this->value[0] = col_type(s, 0);
-        this->value[1] = detail::tvec2<T>(x1, y1);
+        this->value[1] = col_type(0, s);
-        this->value[2] = detail::tvec2<T>(x2, y2);
+        this->value[2] = col_type(0, 0);
     }
 
     template <typename T> 
     inline tmat3x2<T>::tmat3x2
     (
-        const detail::tvec2<T> & v0, 
+        value_type const & x0, value_type const & y0,
-        const detail::tvec2<T> & v1, 
+        value_type const & x1, value_type const & y1,
-        const detail::tvec2<T> & v2
+        value_type const & x2, value_type const & y2
+    )
+    {
+        this->value[0] = col_type(x0, y0);
+        this->value[1] = col_type(x1, y1);
+        this->value[2] = col_type(x2, y2);
+    }
+
+    template <typename T> 
+    inline tmat3x2<T>::tmat3x2
+    (
+        col_type const & v0, 
+        col_type const & v1, 
+        col_type const & v2
     )
     {
         this->value[0] = v0;
@@ -99,63 +98,87 @@ namespace detail{
     // Conversion
     template <typename T> 
     template <typename U> 
-    inline tmat3x2<T>::tmat3x2(const tmat3x2<U>& m)
+    inline tmat3x2<T>::tmat3x2
+	(
+		tmat3x2<U> const & m
+	)
     {
-        this->value[0] = detail::tvec2<T>(m[0]);
+        this->value[0] = col_type(m[0]);
-        this->value[1] = detail::tvec2<T>(m[1]);
+        this->value[1] = col_type(m[1]);
-        this->value[2] = detail::tvec2<T>(m[2]);
+        this->value[2] = col_type(m[2]);
 	}
 
     template <typename T> 
-    inline tmat3x2<T>::tmat3x2(tmat2x2<T> const & m)
+    inline tmat3x2<T>::tmat3x2
+	(
+		tmat2x2<T> const & m
+	)
     {
         this->value[0] = m[0];
         this->value[1] = m[1];
-        this->value[2] = detail::tvec2<T>(T(0));
+        this->value[2] = col_type(T(0));
     }
 
     template <typename T> 
-    inline tmat3x2<T>::tmat3x2(const tmat3x3<T>& m)
+    inline tmat3x2<T>::tmat3x2
+	(
+		tmat3x3<T> const & m
+	)
     {
-        this->value[0] = detail::tvec2<T>(m[0]);
+        this->value[0] = col_type(m[0]);
-        this->value[1] = detail::tvec2<T>(m[1]);
+        this->value[1] = col_type(m[1]);
-        this->value[2] = detail::tvec2<T>(m[2]);
+        this->value[2] = col_type(m[2]);
     }
 
     template <typename T> 
-    inline tmat3x2<T>::tmat3x2(const tmat4x4<T>& m)
+    inline tmat3x2<T>::tmat3x2
+	(
+		tmat4x4<T> const & m
+	)
     {
-        this->value[0] = detail::tvec2<T>(m[0]);
+        this->value[0] = col_type(m[0]);
-        this->value[1] = detail::tvec2<T>(m[1]);
+        this->value[1] = col_type(m[1]);
-        this->value[2] = detail::tvec2<T>(m[2]);
+        this->value[2] = col_type(m[2]);
     }
 
     template <typename T> 
-    inline tmat3x2<T>::tmat3x2(const tmat2x3<T>& m)
+    inline tmat3x2<T>::tmat3x2
+	(
+		tmat2x3<T> const & m
+	)
     {
-        this->value[0] = detail::tvec2<T>(m[0]);
+        this->value[0] = col_type(m[0]);
-        this->value[1] = detail::tvec2<T>(m[1]);
+        this->value[1] = col_type(m[1]);
-        this->value[2] = detail::tvec2<T>(T(0));
+        this->value[2] = col_type(T(0));
     }
 
     template <typename T> 
-    inline tmat3x2<T>::tmat3x2(const tmat2x4<T>& m)
+    inline tmat3x2<T>::tmat3x2
+	(
+		tmat2x4<T> const & m
+	)
     {
-        this->value[0] = detail::tvec2<T>(m[0]);
+        this->value[0] = col_type(m[0]);
-        this->value[1] = detail::tvec2<T>(m[1]);
+        this->value[1] = col_type(m[1]);
-        this->value[2] = detail::tvec2<T>(T(0));
+        this->value[2] = col_type(T(0));
     }
 
     template <typename T> 
-    inline tmat3x2<T>::tmat3x2(const tmat3x4<T>& m)
+    inline tmat3x2<T>::tmat3x2
+	(
+		tmat3x4<T> const & m
+	)
     {
-        this->value[0] = detail::tvec2<T>(m[0]);
+        this->value[0] = col_type(m[0]);
-        this->value[1] = detail::tvec2<T>(m[1]);
+        this->value[1] = col_type(m[1]);
-        this->value[2] = detail::tvec2<T>(m[2]);
+        this->value[2] = col_type(m[2]);
     }
 
     template <typename T> 
-    inline tmat3x2<T>::tmat3x2(const tmat4x2<T>& m)
+    inline tmat3x2<T>::tmat3x2
+	(
+		tmat4x2<T> const & m
+	)
     {
         this->value[0] = m[0];
         this->value[1] = m[1];
@@ -163,18 +186,24 @@ namespace detail{
     }
 
     template <typename T> 
-    inline tmat3x2<T>::tmat3x2(const tmat4x3<T>& m)
+    inline tmat3x2<T>::tmat3x2
+	(
+		tmat4x3<T> const & m
+	)
     {
-        this->value[0] = detail::tvec2<T>(m[0]);
+        this->value[0] = col_type(m[0]);
-        this->value[1] = detail::tvec2<T>(m[1]);
+        this->value[1] = col_type(m[1]);
-        this->value[2] = detail::tvec2<T>(m[2]);
+        this->value[2] = col_type(m[2]);
     }
 
     //////////////////////////////////////////////////////////////
     // Unary updatable operators
 
     template <typename T> 
-    inline tmat3x2<T>& tmat3x2<T>::operator= (const tmat3x2<T>& m)
+    inline tmat3x2<T>& tmat3x2<T>::operator= 
+	(
+		tmat3x2<T> const & m
+	)
     {
         this->value[0] = m[0];
         this->value[1] = m[1];
@@ -183,7 +212,24 @@ namespace detail{
     }
 
     template <typename T> 
-    inline tmat3x2<T>& tmat3x2<T>::operator+= (const T & s)
+	template <typename U> 
+    inline tmat3x2<T>& tmat3x2<T>::operator= 
+	(
+		tmat3x2<U> const & m
+	)
+    {
+        this->value[0] = m[0];
+        this->value[1] = m[1];
+        this->value[2] = m[2];
+        return *this;
+    }
+
+    template <typename T> 
+	template <typename U> 
+    inline tmat3x2<T>& tmat3x2<T>::operator+= 
+	(
+		U const & s
+	)
     {
         this->value[0] += s;
         this->value[1] += s;
@@ -192,7 +238,11 @@ namespace detail{
     }
 
     template <typename T> 
-    inline tmat3x2<T>& tmat3x2<T>::operator+= (const tmat3x2<T>& m)
+	template <typename U> 
+    inline tmat3x2<T>& tmat3x2<T>::operator+= 
+	(
+		tmat3x2<U> const & m
+	)
     {
         this->value[0] += m[0];
         this->value[1] += m[1];
@@ -201,7 +251,11 @@ namespace detail{
     }
 
     template <typename T> 
-    inline tmat3x2<T>& tmat3x2<T>::operator-= (const T & s)
+	template <typename U> 
+    inline tmat3x2<T>& tmat3x2<T>::operator-= 
+	(
+		U const & s
+	)
     {
         this->value[0] -= s;
         this->value[1] -= s;
@@ -210,7 +264,11 @@ namespace detail{
     }
 
     template <typename T> 
-    inline tmat3x2<T>& tmat3x2<T>::operator-= (const tmat3x2<T>& m)
+	template <typename U> 
+    inline tmat3x2<T>& tmat3x2<T>::operator-= 
+	(
+		tmat3x2<U> const & m
+	)
     {
         this->value[0] -= m[0];
         this->value[1] -= m[1];
@@ -219,7 +277,11 @@ namespace detail{
     }
 
     template <typename T> 
-    inline tmat3x2<T>& tmat3x2<T>::operator*= (const T & s)
+	template <typename U> 
+    inline tmat3x2<T>& tmat3x2<T>::operator*= 
+	(
+		U const & s
+	)
     {
         this->value[0] *= s;
         this->value[1] *= s;
@@ -228,13 +290,21 @@ namespace detail{
     }
 
     template <typename T> 
-    inline tmat3x2<T>& tmat3x2<T>::operator*= (const tmat2x3<T>& m)
+	template <typename U> 
+    inline tmat3x2<T>& tmat3x2<T>::operator*= 
+	(
+		tmat3x2<U> const & m
+	)
     {
         return (*this = tmat3x2<T>(*this * m));
     }
 
     template <typename T> 
-    inline tmat3x2<T> & tmat3x2<T>::operator/= (const T & s)
+	template <typename U> 
+    inline tmat3x2<T> & tmat3x2<T>::operator/= 
+	(
+		U const & s
+	)
     {
         this->value[0] /= s;
         this->value[1] /= s;
@@ -242,12 +312,6 @@ namespace detail{
         return *this;
     }
 
-    //template <typename T> 
-    //inline tmat3x2<T>& tmat3x2<T>::operator/= (const tmat3x2<T>& m)
-    //{
-    //    return (*this = tmat3x2<T>(*this / m));
-    //}
-
     template <typename T> 
     inline tmat3x2<T>& tmat3x2<T>::operator++ ()
     {
@@ -266,19 +330,15 @@ namespace detail{
         return *this;
     }
 
-    //////////////////////////////////////////////////////////////
-    // inverse
-    template <typename valType> 
-    inline tmat2x3<valType> tmat3x2<valType>::_inverse() const
-    {
-		assert(0); //g.truc.creation[at]gmail.com
-    }
-
     //////////////////////////////////////////////////////////////
     // Binary operators
 
     template <typename T> 
-    inline tmat3x2<T> operator+ (const tmat3x2<T>& m, const T & s)
+    inline tmat3x2<T> operator+ 
+	(
+		tmat3x2<T> const & m, 
+		typename tmat3x2<T>::value_type const & s
+	)
     {
         return tmat3x2<T>(
             m[0] + s,
@@ -287,7 +347,11 @@ namespace detail{
     }
 
     template <typename T> 
-    inline tmat3x2<T> operator+ (const tmat3x2<T>& m1, const tmat3x2<T>& m2)
+    inline tmat3x2<T> operator+ 
+	(
+		tmat3x2<T> const & m1, 
+		tmat3x2<T> const & m2
+	)
     {
         return tmat3x2<T>(
             m1[0] + m2[0],
@@ -296,7 +360,11 @@ namespace detail{
     }
 
     template <typename T> 
-    inline tmat3x2<T> operator- (const tmat3x2<T>& m, const T & s)
+    inline tmat3x2<T> operator- 
+	(
+		tmat3x2<T> const & m, 
+		typename tmat3x2<T>::value_type const & s
+	)
     {
         return tmat3x4<T>(
             m[0] - s,
@@ -305,7 +373,11 @@ namespace detail{
     }
 
     template <typename T> 
-    inline tmat3x2<T> operator- (const tmat3x2<T>& m1, const tmat3x2<T>& m2)
+    inline tmat3x2<T> operator- 
+	(	
+		tmat3x2<T> const & m1, 
+		tmat3x2<T> const & m2
+	)
     {
         return tmat3x2<T>(
             m1[0] - m2[0],
@@ -314,7 +386,11 @@ namespace detail{
     }
 
     template <typename T> 
-    inline tmat3x2<T> operator* (const tmat3x2<T>& m, const T & s)
+    inline tmat3x2<T> operator* 
+	(
+		tmat3x2<T> const & m, 
+		typename tmat3x2<T>::value_type const & s
+	)
     {
         return tmat3x2<T>(
             m[0] * s,
@@ -323,7 +399,11 @@ namespace detail{
     }
 
     template <typename T> 
-    inline tmat3x2<T> operator* (const T & s, const tmat3x2<T> & m)
+    inline tmat3x2<T> operator* 
+	(
+		typename tmat3x2<T>::value_type const & s, 
+		const tmat3x2<T> & m
+	)
     {
         return tmat3x2<T>(
             m[0] * s,
@@ -332,7 +412,11 @@ namespace detail{
     }
    
     template <typename T>
-    inline detail::tvec2<T> operator* (const tmat3x2<T>& m, const detail::tvec3<T>& v)
+    inline detail::tvec2<T> operator* 
+	(
+		tmat3x2<T> const & m, 
+		detail::tvec3<T> const & v
+	)
     {
         return detail::tvec2<T>(
             m[0][0] * v.x + m[1][0] * v.y + m[2][0] * v.z,
@@ -340,7 +424,11 @@ namespace detail{
     }
 
     template <typename T> 
-    inline detail::tvec3<T> operator* (const detail::tvec2<T>& v, const tmat3x2<T>& m) 
+    inline detail::tvec3<T> operator* 
+	(
+		detail::tvec2<T> const & v, 
+		tmat3x2<T> const & m
+	)
     {
         return detail::tvec3<T>(
             m[0][0] * v.x + m[1][0] * v.y + m[2][0] * v.z + m[3][0] * v.w,
@@ -348,7 +436,11 @@ namespace detail{
     }
 
     template <typename T> 
-    inline tmat2x2<T> operator* (const tmat3x2<T>& m1, const tmat2x3<T>& m2)
+    inline tmat2x2<T> operator* 
+	(
+		tmat3x2<T> const & m1, 
+		tmat2x3<T> const & m2
+	)
     {
         const T SrcA00 = m1[0][0];
         const T SrcA01 = m1[0][1];
@@ -364,7 +456,7 @@ namespace detail{
         const T SrcB11 = m2[1][1];
         const T SrcB12 = m2[1][2];
 
-        tmat2x2<T> Result;
+        tmat2x2<T> Result(tmat2x2<T>::null);
         Result[0][0] = SrcA00 * SrcB00 + SrcA01 * SrcB01 + SrcA20 * SrcB02;
         Result[0][1] = SrcA01 * SrcB00 + SrcA11 * SrcB01 + SrcA21 * SrcB02;
         Result[1][0] = SrcA00 * SrcB10 + SrcA10 * SrcB11 + SrcA20 * SrcB12;
@@ -373,7 +465,11 @@ namespace detail{
     }
 
     template <typename T> 
-    inline tmat3x2<T> operator/ (const tmat3x2<T>& m, const T & s)
+    inline tmat3x2<T> operator/ 
+	(
+		tmat3x2<T> const & m, 
+		typename tmat3x2<T>::value_type const & s
+	)
     {
         return tmat3x2<T>(
             m[0] / s,
@@ -383,7 +479,11 @@ namespace detail{
     }
 
     template <typename T> 
-    inline tmat3x2<T> operator/ (const T & s, const tmat3x2<T>& m)
+    inline tmat3x2<T> operator/ 
+	(
+		typename tmat3x2<T>::value_type const & s, 
+		tmat3x2<T> const & m
+	)
     {
         return tmat3x2<T>(
             s / m[0],
@@ -392,73 +492,45 @@ namespace detail{
             s / m[3]);        
     }
 
-	//template <typename valType> 
-	//inline tvec2<valType> operator/ 
-	//(
-	//	tmat3x2<valType> const & m, 
-	//	tvec2<valType> const & v
-	//)
-	//{
-	//	return m._inverse() * v;
-	//}
-
-	//template <typename valType> 
-	//inline tvec3<valType> operator/ 
-	//(
-	//	tvec2<valType> const & v, 
-	//	tmat3x2<valType> const & m
-	//)
-	//{
-	//	return v * m._inverse();
-	//}
-
-	//template <typename valType> 
-	//inline tmat3x3<valType> operator/ 
-	//(
-	//	tmat3x2<valType> const & m1, 
-	//	tmat2x3<valType> const & m2
-	//)
-	//{
-	//	return m1 * m2._inverse();
-	//}
-
 	// Unary constant operators
-    template <typename valType> 
+    template <typename T> 
-    inline tmat3x2<valType> const operator- 
+    inline tmat3x2<T> const operator- 
 	(
-		tmat3x2<valType> const & m
+		tmat3x2<T> const & m
 	)
     {
-        return tmat3x2<valType>(
+        return tmat3x2<T>(
             -m[0], 
             -m[1],
             -m[2]);
     }
 
-    template <typename valType> 
+    template <typename T> 
-    inline tmat3x2<valType> const operator++ 
+    inline tmat3x2<T> const operator++ 
 	(
-		tmat3x2<valType> const & m, 
+		tmat3x2<T> const & m, 
 		int
 	) 
     {
-        return tmat3x2<valType>(
+		typename tmat3x2<T>::value_type One(1);
-            m[0] + valType(1),
+        return tmat3x2<T>(
-            m[1] + valType(1),
+            m[0] + One,
-            m[2] + valType(1));
+            m[1] + One,
+            m[2] + One);
     }
 
-    template <typename valType> 
+    template <typename T> 
-    inline tmat3x2<valType> const operator-- 
+    inline tmat3x2<T> const operator-- 
 	(
-		tmat3x2<valType> const & m, 
+		tmat3x2<T> const & m, 
 		int
 	) 
     {
-        return tmat3x2<valType>(
+		typename tmat3x2<T>::value_type One(1);
-            m[0] - valType(1),
+        return tmat3x2<T>(
-            m[1] - valType(1),
+            m[0] - One,
-            m[2] - valType(1));
+            m[1] - One,
+            m[2] - One);
     }
 
 } //namespace detail

glm/core/type_mat3x3.hpp

@@ -1,16 +1,16 @@
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-// OpenGL Mathematics Copyright (c) 2005 - 2009 G-Truc Creation (www.g-truc.net)
+// OpenGL Mathematics Copyright (c) 2005 - 2010 G-Truc Creation (www.g-truc.net)
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 // Created : 2005-01-27
-// Updated : 2008-08-30
+// Updated : 2010-02-03
 // Licence : This source is under MIT License
-// File    : glm/core/type_mat3x3.h
+// File    : glm/core/type_mat3x3.hpp
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 #ifndef glm_core_type_mat3x3
 #define glm_core_type_mat3x3
 
-#include "type_size.hpp"
+#include "type_mat.hpp"
 
 namespace glm
 {
@@ -39,140 +39,184 @@ namespace glm
 		template <typename T> 
 		struct tmat3x3
 		{
-		public:
+			enum ctor{null};
-			typedef tmat3x3<T>* pointer;
-			typedef const tmat3x3<T>* const_pointer;
-			typedef const tmat3x3<T>*const const_pointer_const;
-			typedef tmat3x3<T>*const pointer_const;
-			typedef tmat3x3<T>& reference;
-			typedef const tmat3x3<T>& const_reference;
-			typedef const tmat3x3<T>& param_type;
-			typedef tmat3x3<T> transpose_type;
-
 			typedef T value_type;
-			typedef detail::tvec3<T> col_type;
+			typedef std::size_t size_type;
-			typedef detail::tvec3<T> row_type;
+			typedef tvec3<T> col_type;
-			typedef glm::sizeType size_type;
+			typedef tvec3<T> row_type;
-			static size_type value_size();
 			static size_type col_size();
 			static size_type row_size();
-			static bool is_matrix();
+
+			typedef tmat3x3<T> type;
+			typedef tmat3x3<T> transpose_type;
 
 		public:
+			// Implementation detail
 			tmat3x3<T> _inverse() const;
 
 		private:
 			// Data
-			tvec3<T> value[3];
+			col_type value[3];
 
 		public:
 			// Constructors
 			tmat3x3();
-			explicit tmat3x3(const T x);
+			tmat3x3(tmat3x3 const & m);
+
 			explicit tmat3x3(
-				const T x0, const T y0, const T z0,
+				ctor Null);
-				const T x1, const T y1, const T z1,
-				const T x2, const T y2, const T z2);
 			explicit tmat3x3(
-				const detail::tvec3<T> & v0, 
+				value_type const & s);
-				const detail::tvec3<T> & v1,
+			explicit tmat3x3(
-				const detail::tvec3<T> & v2);
+				value_type const & x0, value_type const & y0, value_type const & z0,
+				value_type const & x1, value_type const & y1, value_type const & z1,
+				value_type const & x2, value_type const & y2, value_type const & z2);
+			explicit tmat3x3(
+				col_type const & v0, 
+				col_type const & v1,
+				col_type const & v2);
 
 			// Conversions
 			template <typename U> 
-			explicit tmat3x3(const tmat3x3<U>& m);
+			explicit tmat3x3(tmat3x3<U> const & m);
 
-			explicit tmat3x3(const tmat2x2<T>& x);
+			explicit tmat3x3(tmat2x2<T> const & x);
-			explicit tmat3x3(const tmat4x4<T>& x);
+			explicit tmat3x3(tmat4x4<T> const & x);
-			explicit tmat3x3(const tmat2x3<T>& x);
+			explicit tmat3x3(tmat2x3<T> const & x);
-			explicit tmat3x3(const tmat3x2<T>& x);
+			explicit tmat3x3(tmat3x2<T> const & x);
-			explicit tmat3x3(const tmat2x4<T>& x);
+			explicit tmat3x3(tmat2x4<T> const & x);
-			explicit tmat3x3(const tmat4x2<T>& x);
+			explicit tmat3x3(tmat4x2<T> const & x);
-			explicit tmat3x3(const tmat3x4<T>& x);
+			explicit tmat3x3(tmat3x4<T> const & x);
-			explicit tmat3x3(const tmat4x3<T>& x);
+			explicit tmat3x3(tmat4x3<T> const & x);
 
 			// Accesses
-			detail::tvec3<T>& operator[](size_type i);
+			col_type & operator[](size_type i);
-			detail::tvec3<T> const & operator[](size_type i) const;
+			col_type const & operator[](size_type i) const;
 
 			// Unary updatable operators
-			tmat3x3<T>& operator=(const tmat3x3<T>& m);
+			tmat3x3<T>& operator=  (tmat3x3<T> const & m);
-			tmat3x3<T>& operator+= (const T & s);
+			template <typename U> 
-			tmat3x3<T>& operator+= (const tmat3x3<T>& m);
+			tmat3x3<T>& operator=  (tmat3x3<U> const & m);
-			tmat3x3<T>& operator-= (const T & s);
+			template <typename U> 
-			tmat3x3<T>& operator-= (const tmat3x3<T>& m);
+			tmat3x3<T>& operator+= (U const & s);
-			tmat3x3<T>& operator*= (const T & s);
+			template <typename U> 
-			tmat3x3<T>& operator*= (const tmat3x3<T>& m);
+			tmat3x3<T>& operator+= (tmat3x3<U> const & m);
-			tmat3x3<T>& operator/= (const T & s);
+			template <typename U> 
-			tmat3x3<T>& operator/= (const tmat3x3<T>& m);
+			tmat3x3<T>& operator-= (U const & s);
+			template <typename U> 
+			tmat3x3<T>& operator-= (tmat3x3<U> const & m);
+			template <typename U> 
+			tmat3x3<T>& operator*= (U const & s);
+			template <typename U> 
+			tmat3x3<T>& operator*= (tmat3x3<U> const & m);
+			template <typename U> 
+			tmat3x3<T>& operator/= (U const & s);
+			template <typename U> 
+			tmat3x3<T>& operator/= (tmat3x3<U> const & m);
 			tmat3x3<T>& operator++ ();
 			tmat3x3<T>& operator-- ();
 		};
 
 		// Binary operators
 		template <typename T> 
-		tmat3x3<T> operator+ (const tmat3x3<T>& m, const T & s);
+		tmat3x3<T> operator+ (
+			tmat3x3<T> const & m, 
+			typename tmat3x3<T>::value_type const & s);
 
 		template <typename T> 
-		tmat3x3<T> operator+ (const T & s, const tmat3x3<T>& m);
+		tmat3x3<T> operator+ (
+			typename tmat3x3<T>::value_type const & s, 
+			tmat3x3<T> const & m);
 
 		template <typename T> 
-		tmat3x3<T> operator+ (const tmat3x3<T>& m1, const tmat3x3<T>& m2);
+		tmat3x3<T> operator+ (
+			tmat3x3<T> const & m1, 
+			tmat3x3<T> const & m2);
 	    
 		template <typename T> 
-		tmat3x3<T> operator- (const tmat3x3<T>& m, const T & s);
+		tmat3x3<T> operator- (
+			tmat3x3<T> const & m, 
+			typename tmat3x3<T>::value_type const & s);
 
 		template <typename T> 
-		tmat3x3<T> operator- (const T & s, const tmat3x3<T>& m);
+		tmat3x3<T> operator- (
+			typename tmat3x3<T>::value_type const & s, 
+			tmat3x3<T> const & m);
 
 		template <typename T> 
-		tmat3x3<T> operator- (const tmat3x3<T>& m1, const tmat3x3<T>& m2);
+		tmat3x3<T> operator- (
+			tmat3x3<T> const & m1, 
+			tmat3x3<T> const & m2);
 
 		template <typename T> 
-		tmat3x3<T> operator* (const tmat3x3<T>& m, const T & s);
+		tmat3x3<T> operator* (
+			tmat3x3<T> const & m, 
+			typename tmat3x3<T>::value_type const & s);
 
 		template <typename T> 
-		tmat3x3<T> operator* (const T & s, const tmat3x3<T>& m);
+		tmat3x3<T> operator* (
+			typename tmat3x3<T>::value_type const & s, 
+			tmat3x3<T> const & m);
 
 		template <typename T> 
-		detail::tvec3<T> operator* (const tmat3x3<T>& m, const detail::tvec3<T>& v);
+		typename tmat3x3<T>::row_type operator* (
+			tmat3x3<T> const & m, 
+			typename tmat3x3<T>::col_type const & v);
 
 		template <typename T> 
-		detail::tvec3<T> operator* (const detail::tvec3<T>& v, const tmat3x3<T>& m);
+		typename tmat3x3<T>::col_type operator* (
+			typename tmat3x3<T>::row_type const & v, 
+			tmat3x3<T> const & m);
 
 		template <typename T> 
-		tmat3x3<T> operator* (const tmat3x3<T>& m1, const tmat3x3<T>& m2);
+		tmat3x3<T> operator* (
+			tmat3x3<T> const & m1, 
+			tmat3x3<T> const & m2);
 
 		template <typename T> 
-		tmat3x3<T> operator/ (const tmat3x3<T>& m, const T & s);
+		tmat3x3<T> operator/ (
+			tmat3x3<T> const & m, 
+			typename tmat3x3<T>::value_type const & s);
 
 		template <typename T> 
-		tmat3x3<T> operator/ (const T & s, const tmat3x3<T>& m);
+		tmat3x3<T> operator/ (
+			typename tmat3x3<T>::value_type const & s, 
+			tmat3x3<T> const & m);
 
 		template <typename T> 
-		detail::tvec3<T> operator/ (const tmat3x3<T>& m, const detail::tvec3<T>& v);
+		typename tmat3x3<T>::row_type operator/ (
+			tmat3x3<T> const & m, 
+			typename tmat3x3<T>::col_type const & v);
 
 		template <typename T> 
-		detail::tvec3<T> operator/ (const detail::tvec3<T>& v, const tmat3x3<T>& m);
+		typename tmat3x3<T>::col_type operator/ (
+			typename tmat3x3<T>::row_type const & v, 
+			tmat3x3<T> const & m);
 
 		template <typename T> 
-		tmat3x3<T> operator/ (const tmat3x3<T>& m1, const tmat3x3<T>& m2);
+		tmat3x3<T> operator/ (
+			tmat3x3<T> const & m1, 
+			tmat3x3<T> const & m2);
 
 		// Unary constant operators
-		template <typename valType> 
+		template <typename T> 
-		tmat3x3<valType> const operator-  (tmat3x3<valType> const & m);
+		tmat3x3<T> const operator-  (
+			tmat3x3<T> const & m);
 
-		template <typename valType> 
+		template <typename T> 
-		tmat3x3<valType> const operator-- (tmat3x3<valType> const & m, int);
+		tmat3x3<T> const operator-- (
+			tmat3x3<T> const & m, 
+			int);
 
-		template <typename valType> 
+		template <typename T> 
-		tmat3x3<valType> const operator++ (tmat3x3<valType> const & m, int);
+		tmat3x3<T> const operator++ (
+			tmat3x3<T> const & m, 
+			int);
 
 	} //namespace detail
 
 	namespace core{
 	namespace type{
-	namespace matrix{
 
 	namespace precision
 	{
@@ -191,25 +235,6 @@ namespace glm
 	}
 	//namespace precision
 
-#ifndef GLM_PRECISION
-	//! 3 columns of 3 components matrix of floating-point numbers. 
-	//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices)
-	typedef detail::tmat3x3<mediump_float>	mat3x3;
-#elif(GLM_PRECISION & GLM_PRECISION_HIGH)
-	typedef detail::tmat3x3<highp_float>	mat3x3;
-#elif(GLM_PRECISION & GLM_PRECISION_MEDIUM)
-	typedef detail::tmat3x3<mediump_float>	mat3x3;
-#elif(GLM_PRECISION & GLM_PRECISION_LOW)
-	typedef detail::tmat3x3<lowp_float>		mat3x3;
-#else
-	typedef detail::tmat3x3<mediump_float>	mat3x3;
-#endif//GLM_PRECISION
-
-	//! 3 columns of 3 components matrix of floating-point numbers. 
-	//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices)
-	typedef mat3x3							mat3;
-
-	}//namespace matrix
 	}//namespace type
 	}//namespace core
 } //namespace glm

glm/core/type_mat3x3.inl

@@ -1,100 +1,114 @@
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-// OpenGL Mathematics Copyright (c) 2005 - 2009 G-Truc Creation (www.g-truc.net)
+// OpenGL Mathematics Copyright (c) 2005 - 2010 G-Truc Creation (www.g-truc.net)
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 // Created : 2005-01-27
-// Updated : 2008-08-25
+// Updated : 2010-02-03
 // Licence : This source is under MIT License
 // File    : glm/core/type_mat3x3.inl
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 namespace glm{
-namespace detail{
+namespace detail
-
+{
-	template <typename valType> 
+	template <typename T>
-	typename tmat3x3<valType>::size_type tmat3x3<valType>::value_size()
+	inline typename tmat3x3<T>::size_type tmat3x3<T>::col_size()
 	{
-		return typename tmat3x3<valType>::size_type(3);
+		return 3;
 	}
 
-	template <typename valType> 
+	template <typename T>
-	typename tmat3x3<valType>::size_type tmat3x3<valType>::col_size()
+	inline typename tmat3x3<T>::size_type tmat3x3<T>::row_size()
 	{
-		return typename tmat3x3<valType>::size_type(3);
+		return 3;
-	}
-
-	template <typename valType> 
-	typename tmat3x3<valType>::size_type tmat3x3<valType>::row_size()
-	{
-		return typename tmat3x3<valType>::size_type(3);
-	}
-
-	template <typename valType> 
-	bool tmat3x3<valType>::is_matrix()
-	{
-		return true;
 	}
 
 	//////////////////////////////////////
 	// Accesses
 
-	template <typename valType>
+	template <typename T>
-	detail::tvec3<valType>& tmat3x3<valType>::operator[](typename tmat3x3<valType>::size_type i)
+	inline typename tmat3x3<T>::col_type &
+	tmat3x3<T>::operator[]
+	(
+		size_type i
+	)
 	{
-		assert(
+		assert(i >= size_type(0) && i < col_size());
-			i >= typename tmat3x3<valType>::size_type(0) && 
+		return this->value[i];
-			i < tmat3x3<valType>::col_size());
-
-		return value[i];
 	}
 
-	template <typename valType>
+	template <typename T>
-	const detail::tvec3<valType>& tmat3x3<valType>::operator[](typename tmat3x3<valType>::size_type i) const
+	inline typename tmat3x3<T>::col_type const &
+	tmat3x3<T>::operator[]
+	(
+		size_type i
+	) const
 	{
-		assert(
+		assert(i >= size_type(0) && i < col_size());
-			i >= typename tmat3x3<valType>::size_type(0) &&
+		return this->value[i];
-			i < tmat3x3<valType>::col_size());
-
-		return value[i];
 	}
 
     //////////////////////////////////////////////////////////////
-    // mat3 constructors
+    // Constructors
 
     template <typename T> 
     inline tmat3x3<T>::tmat3x3()
     {
-        this->value[0] = detail::tvec3<T>(1, 0, 0);
+		value_type const Zero(0);
-        this->value[1] = detail::tvec3<T>(0, 1, 0);
+		value_type const One(1);
-        this->value[2] = detail::tvec3<T>(0, 0, 1);
+        this->value[0] = col_type(One, Zero, Zero);
-    }
+        this->value[1] = col_type(Zero, One, Zero);
-
+        this->value[2] = col_type(Zero, Zero, One);
-    template <typename T> 
-    inline tmat3x3<T>::tmat3x3(const T f)
-    {
-        this->value[0] = detail::tvec3<T>(f, 0, 0);
-        this->value[1] = detail::tvec3<T>(0, f, 0);
-        this->value[2] = detail::tvec3<T>(0, 0, f);
     }
 
     template <typename T> 
     inline tmat3x3<T>::tmat3x3
 	(
-        const T x0, const T y0, const T z0, 
+		tmat3x3<T> const & m
-        const T x1, const T y1, const T z1,
-        const T x2, const T y2, const T z2
 	)
     {
-        this->value[0] = detail::tvec3<T>(x0, y0, z0);
+        this->value[0] = m.value[0];
-        this->value[1] = detail::tvec3<T>(x1, y1, z1);
+        this->value[1] = m.value[1];
-        this->value[2] = detail::tvec3<T>(x2, y2, z2);
+        this->value[2] = m.value[2];
     }
 
     template <typename T> 
     inline tmat3x3<T>::tmat3x3
 	(
-        const detail::tvec3<T>& v0, 
+		ctor
-        const detail::tvec3<T>& v1, 
+	)
-        const detail::tvec3<T>& v2
+    {}
+
+    template <typename T> 
+    inline tmat3x3<T>::tmat3x3
+	(
+		value_type const & s
+	)
+    {
+		value_type const Zero(0);
+        this->value[0] = col_type(s, Zero, Zero);
+        this->value[1] = col_type(Zero, s, Zero);
+        this->value[2] = col_type(Zero, Zero, s);
+    }
+
+    template <typename T> 
+    inline tmat3x3<T>::tmat3x3
+    (
+        value_type const & x0, value_type const & y0, value_type const & z0, 
+        value_type const & x1, value_type const & y1, value_type const & z1,
+        value_type const & x2, value_type const & y2, value_type const & z2
+    )
+    {
+        this->value[0] = col_type(x0, y0, z0);
+        this->value[1] = col_type(x1, y1, z1);
+        this->value[2] = col_type(x2, y2, z2);
+    }
+
+    template <typename T> 
+    inline tmat3x3<T>::tmat3x3
+    (
+        col_type const & v0, 
+        col_type const & v1, 
+        col_type const & v2
     )
     {
         this->value[0] = v0;
@@ -103,137 +117,116 @@ namespace detail{
     }
 
     //////////////////////////////////////////////////////////////
-    // mat3 conversions
+    // Conversions
 
     template <typename T> 
     template <typename U> 
-    inline tmat3x3<T>::tmat3x3(const tmat3x3<U>& m)
+    inline tmat3x3<T>::tmat3x3
+	(
+		tmat3x3<U> const & m
+	)
     {
-        this->value[0] = detail::tvec3<T>(m[0]);
+        this->value[0] = col_type(m[0]);
-        this->value[1] = detail::tvec3<T>(m[1]);
+        this->value[1] = col_type(m[1]);
-        this->value[2] = detail::tvec3<T>(m[2]);
+        this->value[2] = col_type(m[2]);
 	}
 
     template <typename T> 
-    inline tmat3x3<T>::tmat3x3(tmat2x2<T> const & m)
+    inline tmat3x3<T>::tmat3x3
+	(
+		tmat2x2<T> const & m
+	)
     {
-        this->value[0] = detail::tvec3<T>(m[0], T(0));
+        this->value[0] = col_type(m[0], value_type(0));
-        this->value[1] = detail::tvec3<T>(m[1], T(0));
+        this->value[1] = col_type(m[1], value_type(0));
-        this->value[2] = detail::tvec3<T>(detail::tvec2<T>(0), T(1));
+        this->value[2] = col_type(detail::tvec2<T>(0), value_type(1));
     }
 
     template <typename T> 
-    inline tmat3x3<T>::tmat3x3(const tmat4x4<T>& m)
+    inline tmat3x3<T>::tmat3x3
+	(
+		tmat4x4<T> const & m
+	)
     {
-        this->value[0] = detail::tvec3<T>(m[0]);
+        this->value[0] = col_type(m[0]);
-        this->value[1] = detail::tvec3<T>(m[1]);
+        this->value[1] = col_type(m[1]);
-        this->value[2] = detail::tvec3<T>(m[2]);
+        this->value[2] = col_type(m[2]);
     }
 
 	template <typename T> 
-    inline tmat3x3<T>::tmat3x3(const tmat2x3<T>& m)
+    inline tmat3x3<T>::tmat3x3
+	(
+		tmat2x3<T> const & m
+	)
     {
         this->value[0] = m[0];
         this->value[1] = m[1];
-        this->value[2] = detail::tvec3<T>(detail::tvec2<T>(0), T(1));
+        this->value[2] = col_type(detail::tvec2<T>(0), value_type(1));
     }
 
     template <typename T> 
-    inline tmat3x3<T>::tmat3x3(const tmat3x2<T>& m)
+    inline tmat3x3<T>::tmat3x3
+	(
+		tmat3x2<T> const & m
+	)
     {
-        this->value[0] = detail::tvec3<T>(m[0], T(0));
+        this->value[0] = col_type(m[0], value_type(0));
-        this->value[1] = detail::tvec3<T>(m[1], T(0));
+        this->value[1] = col_type(m[1], value_type(0));
-        this->value[2] = detail::tvec3<T>(m[2], T(1));
+        this->value[2] = col_type(m[2], value_type(1));
     }
 
     template <typename T> 
-    inline tmat3x3<T>::tmat3x3(const tmat2x4<T>& m)
+    inline tmat3x3<T>::tmat3x3
+	(
+		tmat2x4<T> const & m
+	)
     {
-        this->value[0] = detail::tvec3<T>(m[0]);
+        this->value[0] = col_type(m[0]);
-        this->value[1] = detail::tvec3<T>(m[1]);
+        this->value[1] = col_type(m[1]);
-        this->value[2] = detail::tvec3<T>(detail::tvec2<T>(0), T(1));
+        this->value[2] = col_type(detail::tvec2<T>(0), value_type(1));
     }
 
     template <typename T> 
-    inline tmat3x3<T>::tmat3x3(const tmat4x2<T>& m)
+    inline tmat3x3<T>::tmat3x3
+	(
+		tmat4x2<T> const & m
+	)
     {
-        this->value[0] = detail::tvec3<T>(m[0], T(0));
+        this->value[0] = col_type(m[0], value_type(0));
-        this->value[1] = detail::tvec3<T>(m[1], T(0));
+        this->value[1] = col_type(m[1], value_type(0));
-        this->value[2] = detail::tvec3<T>(m[2], T(1));
+        this->value[2] = col_type(m[2], value_type(1));
     }
 
     template <typename T> 
-    inline tmat3x3<T>::tmat3x3(const tmat3x4<T>& m)
+    inline tmat3x3<T>::tmat3x3
+	(
+		tmat3x4<T> const & m
+	)
     {
-        this->value[0] = detail::tvec3<T>(m[0]);
+        this->value[0] = col_type(m[0]);
-        this->value[1] = detail::tvec3<T>(m[1]);
+        this->value[1] = col_type(m[1]);
-        this->value[2] = detail::tvec3<T>(m[2]);
+        this->value[2] = col_type(m[2]);
     }
 
     template <typename T> 
-    inline tmat3x3<T>::tmat3x3(const tmat4x3<T>& m)
+    inline tmat3x3<T>::tmat3x3
+	(
+		tmat4x3<T> const & m
+	)
     {
         this->value[0] = m[0];
         this->value[1] = m[1];
         this->value[2] = m[2];
     }
 
-/*
-    template <typename T> 
-    inline tmat3x3<T>::tmat3x3(const T* a)
-    {
-        this->value[0] = detail::tvec3<T>(a[0], a[1], a[2]);
-        this->value[1] = detail::tvec3<T>(a[3], a[4], a[5]);
-        this->value[2] = detail::tvec3<T>(a[6], a[7], a[8]);
-    }
-*/
-    /*
-    // GL_GTX_euler_angles
-    template <typename T> 
-    inline tmat3x3<T>::tmat3x3(const detail::tvec3<T> & angles)
-    {
-        T ch = cos(angles.x);
-        T sh = sin(angles.x);
-        T cp = cos(angles.y);
-        T sp = sin(angles.y);
-        T cb = cos(angles.z);
-        T sb = sin(angles.z);
-
-        value[0][0] = ch * cb + sh * sp * sb;
-        value[0][1] = sb * cp;
-        value[0][2] = -sh * cb + ch * sp * sb;
-        value[1][0] = -ch * sb + sh * sp * cb;
-        value[1][1] = cb * cp;
-        value[1][2] = sb * sh + ch * sp * cb;
-        value[2][0] = sh * cp;
-        value[2][1] = -sp;
-        value[2][2] = ch * cp;
-    }
-    */
     //////////////////////////////////////////////////////////////
-    // mat3 conversions
+    // Operators
-    /*
-    template <typename T> 
-    inline tmat3x3<T>::tmat3x3(const tquat<T> & q)
-    {
-        this->value[0][0] = 1 - 2 * q.y * q.y - 2 * q.z * q.z;
-        this->value[0][1] = 2 * q.x * q.y + 2 * q.w * q.z;
-        this->value[0][2] = 2 * q.x * q.z - 2 * q.w * q.y;
-
-        this->value[1][0] = 2 * q.x * q.y - 2 * q.w * q.z;
-        this->value[1][1] = 1 - 2 * q.x * q.x - 2 * q.z * q.z;
-        this->value[1][2] = 2 * q.y * q.z + 2 * q.w * q.x;
-
-        this->value[2][0] = 2 * q.x * q.z + 2 * q.w * q.y;
-        this->value[2][1] = 2 * q.y * q.z - 2 * q.w * q.x;
-        this->value[2][2] = 1 - 2 * q.x * q.x - 2 * q.y * q.y;
-    }
-    */
-    //////////////////////////////////////////////////////////////
-    // mat3 operators
 
     template <typename T> 
-    inline tmat3x3<T>& tmat3x3<T>::operator=(const tmat3x3<T>& m)
+    inline tmat3x3<T> & tmat3x3<T>::operator=
+	(
+		tmat3x3<T> const & m
+	)
     {
 	    this->value[0] = m[0];
 	    this->value[1] = m[1];
@@ -242,7 +235,24 @@ namespace detail{
     }
 
     template <typename T> 
-    inline tmat3x3<T>& tmat3x3<T>::operator+= (const T & s)
+    template <typename U> 
+	inline tmat3x3<T> & tmat3x3<T>::operator=
+	(
+		tmat3x3<U> const & m
+	)
+    {
+	    this->value[0] = m[0];
+	    this->value[1] = m[1];
+        this->value[2] = m[2];
+	    return *this;
+    }
+
+    template <typename T> 
+	template <typename U> 
+	inline tmat3x3<T> & tmat3x3<T>::operator+= 
+	(
+		U const & s
+	)
     {
 	    this->value[0] += s;
 	    this->value[1] += s;
@@ -251,7 +261,11 @@ namespace detail{
     }
 
     template <typename T> 
-    inline tmat3x3<T>& tmat3x3<T>::operator+= (const tmat3x3<T>& m)
+	template <typename U> 
+    inline tmat3x3<T> & tmat3x3<T>::operator+=
+	(
+		tmat3x3<U> const & m
+	)
     {
 	    this->value[0] += m[0];
 	    this->value[1] += m[1];
@@ -260,7 +274,11 @@ namespace detail{
     }
 
     template <typename T> 
-    inline tmat3x3<T>& tmat3x3<T>::operator-= (const T & s)
+	template <typename U> 
+    inline tmat3x3<T> & tmat3x3<T>::operator-= 
+	(
+		U const & s
+	)
     {
 	    this->value[0] -= s;
 	    this->value[1] -= s;
@@ -269,7 +287,11 @@ namespace detail{
     }
 
     template <typename T> 
-    inline tmat3x3<T>& tmat3x3<T>::operator-= (const tmat3x3<T>& m)
+	template <typename U> 
+    inline tmat3x3<T> & tmat3x3<T>::operator-= 
+	(
+		tmat3x3<U> const & m
+	)
     {
 	    this->value[0] -= m[0];
 	    this->value[1] -= m[1];
@@ -278,7 +300,11 @@ namespace detail{
     }
 
     template <typename T> 
-    inline tmat3x3<T>& tmat3x3<T>::operator*= (const T & s)
+	template <typename U> 
+    inline tmat3x3<T> & tmat3x3<T>::operator*= 
+	(
+		U const & s
+	)
     {
 	    this->value[0] *= s;
 	    this->value[1] *= s;
@@ -287,13 +313,21 @@ namespace detail{
     }
 
     template <typename T> 
-    inline tmat3x3<T>& tmat3x3<T>::operator*= (const tmat3x3<T>& m)
+	template <typename U> 
+    inline tmat3x3<T> & tmat3x3<T>::operator*= 
+	(
+		tmat3x3<U> const & m
+	)
     {
         return (*this = *this * m);
     }
 
     template <typename T> 
-    inline tmat3x3<T>& tmat3x3<T>::operator/= (const T & s)
+	template <typename U> 
+    inline tmat3x3<T> & tmat3x3<T>::operator/= 
+	(
+		U const & s
+	)
     {
 	    this->value[0] /= s;
 	    this->value[1] /= s;
@@ -302,13 +336,17 @@ namespace detail{
     }
 
     template <typename T> 
-    inline tmat3x3<T>& tmat3x3<T>::operator/= (const tmat3x3<T>& m)
+	template <typename U> 
+    inline tmat3x3<T> & tmat3x3<T>::operator/= 
+	(
+		tmat3x3<U> const & m
+	)
     {
         return (*this = *this / m);
     }
 
     template <typename T> 
-    inline tmat3x3<T>& tmat3x3<T>::operator++ ()
+    inline tmat3x3<T> & tmat3x3<T>::operator++ ()
     {
 	    this->value[0]++;
 	    this->value[1]++;
@@ -317,7 +355,7 @@ namespace detail{
     }
 
     template <typename T> 
-    inline tmat3x3<T>& tmat3x3<T>::operator-- ()
+    inline tmat3x3<T> & tmat3x3<T>::operator-- ()
     {
 	    this->value[0]--;
 	    this->value[1]--;
@@ -363,7 +401,11 @@ namespace detail{
 	// Binary operators
 
     template <typename T> 
-    inline tmat3x3<T> operator+ (const tmat3x3<T>& m, const T & s)
+    inline tmat3x3<T> operator+ 
+	(
+		tmat3x3<T> const & m, 
+		typename tmat3x3<T>::value_type const & s
+	)
     {
         return tmat3x3<T>(
             m[0] + s,
@@ -372,7 +414,11 @@ namespace detail{
     }
 
     template <typename T> 
-    inline tmat3x3<T> operator+ (const T & s, const tmat3x3<T>& m)
+    inline tmat3x3<T> operator+ 
+	(
+		typename tmat3x3<T>::value_type const & s, 
+		tmat3x3<T> const & m
+	)
     {
         return tmat3x3<T>(
             m[0] + s,
@@ -380,20 +426,12 @@ namespace detail{
             m[2] + s);
     }
 
-    //template <typename T> 
-    //inline tvec3<T> operator+ (const tmat3x3<T>& m, const tvec3<T>& v)
-    //{
-
-    //}
-
-    //template <typename T> 
-    //inline tvec3<T> operator+ (const tvec3<T>& v, const tmat3x3<T>& m)
-    //{
-
-    //}
-
     template <typename T> 
-    inline tmat3x3<T> operator+ (const tmat3x3<T>& m1, const tmat3x3<T>& m2)
+    inline tmat3x3<T> operator+ 
+	(
+		tmat3x3<T> const & m1, 
+		tmat3x3<T> const & m2
+	)
     {
         return tmat3x3<T>(
             m1[0] + m2[0],
@@ -402,7 +440,11 @@ namespace detail{
     }
 
     template <typename T> 
-    inline tmat3x3<T> operator- (const tmat3x3<T>& m, const T & s)
+    inline tmat3x3<T> operator- 
+	(
+		tmat3x3<T> const & m, 
+		typename tmat3x3<T>::value_type const & s
+	)
     {
         return tmat3x3<T>(
             m[0] - s,
@@ -411,7 +453,11 @@ namespace detail{
     }
 
     template <typename T> 
-    inline tmat3x3<T> operator- (const T & s, const tmat3x3<T>& m)
+    inline tmat3x3<T> operator- 
+	(
+		typename tmat3x3<T>::value_type const & s, 
+		tmat3x3<T> const & m
+	)
     {
         return tmat3x3<T>(
             s - m[0],
@@ -419,20 +465,12 @@ namespace detail{
             s - m[2]);
     }
 
-    //template <typename T> 
-    //inline detail::tvec3<T> operator- (const tmat3x3<T>& m, const detail::tvec3<T>& v)
-    //{
-
-    //}
-
-    //template <typename T> 
-    //inline detail::tvec3<T> operator- (const detail::tvec3<T>& v, const tmat3x3<T>& m)
-    //{
-
-    //}
-
     template <typename T> 
-    inline tmat3x3<T> operator- (const tmat3x3<T>& m1, const tmat3x3<T>& m2)
+    inline tmat3x3<T> operator- 
+	(
+		tmat3x3<T> const & m1, 
+		tmat3x3<T> const & m2
+	)
     {
         return tmat3x3<T>(
             m1[0] - m2[0],
@@ -441,7 +479,11 @@ namespace detail{
     }
 
     template <typename T> 
-    inline tmat3x3<T> operator* (const tmat3x3<T>& m, const T & s)
+    inline tmat3x3<T> operator* 
+	(
+		tmat3x3<T> const & m, 
+		typename tmat3x3<T>::value_type const & s
+	)
     {
         return tmat3x3<T>(
             m[0] * s,
@@ -450,7 +492,11 @@ namespace detail{
     }
 
     template <typename T> 
-    inline tmat3x3<T> operator* (const T & s, const tmat3x3<T>& m)
+    inline tmat3x3<T> operator* 
+	(
+		typename tmat3x3<T>::value_type const & s, 
+		tmat3x3<T> const & m
+	)
     {
         return tmat3x3<T>(
             m[0] * s,
@@ -459,47 +505,59 @@ namespace detail{
     }
 
     template <typename T> 
-    inline detail::tvec3<T> operator* (const tmat3x3<T>& m, const detail::tvec3<T>& v)
+    inline typename tmat3x3<T>::row_type operator* 
+	(
+		tmat3x3<T> const & m, 
+		typename tmat3x3<T>::col_type const & v
+	)
     {
-        return detail::tvec3<T>(
+        return typename tmat3x3<T>::row_type(
             m[0][0] * v.x + m[1][0] * v.y + m[2][0] * v.z,
             m[0][1] * v.x + m[1][1] * v.y + m[2][1] * v.z,
             m[0][2] * v.x + m[1][2] * v.y + m[2][2] * v.z);
     }
 
     template <typename T> 
-    inline detail::tvec3<T> operator* (const detail::tvec3<T>& v, const tmat3x3<T>& m)
+    inline typename tmat3x3<T>::col_type operator* 
+	(
+		typename tmat3x3<T>::row_type const & v, 
+		tmat3x3<T> const & m
+	)
     {
-        return detail::tvec3<T>(
+        return typename tmat3x3<T>::col_type(
             m[0][0] * v.x + m[0][1] * v.y + m[0][2] * v.z,
             m[1][0] * v.x + m[1][1] * v.y + m[1][2] * v.z,
             m[2][0] * v.x + m[2][1] * v.y + m[2][2] * v.z);
     }
 
     template <typename T> 
-    inline tmat3x3<T> operator* (const tmat3x3<T>& m1, const tmat3x3<T>& m2)
+    inline tmat3x3<T> operator* 
+	(
+		tmat3x3<T> const & m1, 
+		tmat3x3<T> const & m2
+	)
     {
-        const T SrcA00 = m1[0][0];
+		typename tmat3x3<T>::value_type const SrcA00 = m1[0][0];
-        const T SrcA01 = m1[0][1];
+		typename tmat3x3<T>::value_type const SrcA01 = m1[0][1];
-        const T SrcA02 = m1[0][2];
+		typename tmat3x3<T>::value_type const SrcA02 = m1[0][2];
-        const T SrcA10 = m1[1][0];
+		typename tmat3x3<T>::value_type const SrcA10 = m1[1][0];
-        const T SrcA11 = m1[1][1];
+		typename tmat3x3<T>::value_type const SrcA11 = m1[1][1];
-        const T SrcA12 = m1[1][2];
+		typename tmat3x3<T>::value_type const SrcA12 = m1[1][2];
-        const T SrcA20 = m1[2][0];
+		typename tmat3x3<T>::value_type const SrcA20 = m1[2][0];
-        const T SrcA21 = m1[2][1];
+		typename tmat3x3<T>::value_type const SrcA21 = m1[2][1];
-        const T SrcA22 = m1[2][2];
+		typename tmat3x3<T>::value_type const SrcA22 = m1[2][2];
 
-        const T SrcB00 = m2[0][0];
+		typename tmat3x3<T>::value_type const SrcB00 = m2[0][0];
-        const T SrcB01 = m2[0][1];
+		typename tmat3x3<T>::value_type const SrcB01 = m2[0][1];
-        const T SrcB02 = m2[0][2];
+		typename tmat3x3<T>::value_type const SrcB02 = m2[0][2];
-        const T SrcB10 = m2[1][0];
+		typename tmat3x3<T>::value_type const SrcB10 = m2[1][0];
-        const T SrcB11 = m2[1][1];
+		typename tmat3x3<T>::value_type const SrcB11 = m2[1][1];
-        const T SrcB12 = m2[1][2];
+		typename tmat3x3<T>::value_type const SrcB12 = m2[1][2];
-        const T SrcB20 = m2[2][0];
+		typename tmat3x3<T>::value_type const SrcB20 = m2[2][0];
-        const T SrcB21 = m2[2][1];
+		typename tmat3x3<T>::value_type const SrcB21 = m2[2][1];
-        const T SrcB22 = m2[2][2];
+		typename tmat3x3<T>::value_type const SrcB22 = m2[2][2];
 
-        tmat3x3<T> Result;
+		tmat3x3<T> Result(tmat3x3<T>::null);
 		Result[0][0] = SrcA00 * SrcB00 + SrcA10 * SrcB01 + SrcA20 * SrcB02;
 		Result[0][1] = SrcA01 * SrcB00 + SrcA11 * SrcB01 + SrcA21 * SrcB02;
 		Result[0][2] = SrcA02 * SrcB00 + SrcA12 * SrcB01 + SrcA22 * SrcB02;
@@ -514,7 +572,11 @@ namespace detail{
 
 
     template <typename T> 
-    inline tmat3x3<T> operator/ (const tmat3x3<T>& m, const T & s)
+    inline tmat3x3<T> operator/ 
+	(
+		tmat3x3<T> const & m, 
+		typename tmat3x3<T>::value_type const & s
+	)
     {
         return tmat3x3<T>(
             m[0] / s,
@@ -523,7 +585,11 @@ namespace detail{
     }
 
     template <typename T> 
-    inline tmat3x3<T> operator/ (const T & s, const tmat3x3<T>& m)
+    inline tmat3x3<T> operator/ 
+	(
+		typename tmat3x3<T>::value_type const & s, 
+		tmat3x3<T> const & m
+	)
     {
         return tmat3x3<T>(
             s / m[0],
@@ -532,19 +598,19 @@ namespace detail{
     }
 
 	template <typename T> 
-	inline detail::tvec3<T> operator/ 
+	inline typename tmat3x3<T>::row_type operator/ 
 	(
 		tmat3x3<T> const & m, 
-		tvec3<T> const & v
+		typename tmat3x3<T>::col_type const & v
 	)
 	{
 		return m._inverse() * v;
 	}
 
 	template <typename T> 
-	inline detail::tvec3<T> operator/ 
+	inline typename tmat3x3<T>::col_type operator/ 
 	(
-		tvec3<T> const & v, 
+		typename tmat3x3<T>::row_type const & v, 
 		tmat3x3<T> const & m
 	)
 	{
@@ -562,42 +628,42 @@ namespace detail{
 	}
 
 	// Unary constant operators
-    template <typename valType> 
+    template <typename T> 
-    inline tmat3x3<valType> const operator- 
+    inline tmat3x3<T> const operator- 
 	(
-		tmat3x3<valType> const & m
+		tmat3x3<T> const & m
 	)
     {
-        return tmat3x3<valType>(
+        return tmat3x3<T>(
             -m[0], 
             -m[1],
             -m[2]);
     }
 
-    template <typename valType> 
+    template <typename T> 
-    inline tmat3x3<valType> const operator++ 
+    inline tmat3x3<T> const operator++ 
 	(
-		tmat3x3<valType> const & m, 
+		tmat3x3<T> const & m, 
 		int
 	) 
     {
-        return tmat3x3<valType>(
+        return tmat3x3<T>(
-            m[0] + valType(1),
+            m[0] + T(1),
-            m[1] + valType(1),
+            m[1] + T(1),
-            m[2] + valType(1));
+            m[2] + T(1));
     }
 
-    template <typename valType> 
+    template <typename T> 
-    inline tmat3x3<valType> const operator-- 
+    inline tmat3x3<T> const operator-- 
 	(
-		tmat3x3<valType> const & m, 
+		tmat3x3<T> const & m, 
 		int
 	) 
     {
-        return tmat3x3<valType>(
+        return tmat3x3<T>(
-            m[0] - valType(1),
+            m[0] - T(1),
-            m[1] - valType(1),
+            m[1] - T(1),
-            m[2] - valType(1));
+            m[2] - T(1));
     }
 
 } //namespace detail

glm/core/type_mat3x4.hpp

@@ -1,16 +1,16 @@
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-// OpenGL Mathematics Copyright (c) 2005 - 2009 G-Truc Creation (www.g-truc.net)
+// OpenGL Mathematics Copyright (c) 2005 - 2010 G-Truc Creation (www.g-truc.net)
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 // Created : 2006-08-05
-// Updated : 2008-08-30
+// Updated : 2010-02-05
 // Licence : This source is under MIT License
-// File    : glm/core/type_mat3x4.h
+// File    : glm/core/type_mat3x4.hpp
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 #ifndef glm_core_type_mat3x4
 #define glm_core_type_mat3x4
 
-#include "type_size.hpp"
+#include "type_mat.hpp"
 
 namespace glm
 {
@@ -39,134 +39,154 @@ namespace glm
 		template <typename T> 
 		struct tmat3x4
 		{
-		public:
+			enum ctor{null};
-			typedef tmat3x4<T>* pointer;
-			typedef const tmat3x4<T>* const_pointer;
-			typedef const tmat3x4<T>*const const_pointer_const;
-			typedef tmat3x4<T>*const pointer_const;
-			typedef tmat3x4<T>& reference;
-			typedef const tmat3x4<T>& const_reference;
-			typedef const tmat3x4<T>& param_type;
-			typedef tmat4x3<T> transpose_type;
-
 			typedef T value_type;
-			typedef detail::tvec3<T> col_type;
+			typedef std::size_t size_type;
-			typedef detail::tvec4<T> row_type;
+			typedef tvec4<T> col_type;
-			typedef glm::sizeType size_type;
+			typedef tvec3<T> row_type;
 			static size_type col_size();
 			static size_type row_size();
-			static bool is_matrix();
 
-		public:
+			typedef tmat3x4<T> type;
-			tmat4x3<T> _inverse() const;
+			typedef tmat4x3<T> transpose_type;
 
 		private:
 			// Data 
-			detail::tvec4<T> value[3];
+			col_type value[3];
 
 		public:
 			// Constructors
 			tmat3x4();
-			explicit tmat3x4(const T x);
+			tmat3x4(tmat3x4 const & m);
+
 			explicit tmat3x4(
-				const T x0, const T y0, const T z0, const T w0,
+				ctor Null);
-				const T x1, const T y1, const T z1, const T w1,
-				const T x2, const T y2, const T z2, const T w2);
 			explicit tmat3x4(
-				const detail::tvec4<T>& v0, 
+				value_type const & s);
-				const detail::tvec4<T>& v1,
+			explicit tmat3x4(
-				const detail::tvec4<T>& v2);
+				value_type const & x0, value_type const & y0, value_type const & z0, value_type const & w0,
+				value_type const & x1, value_type const & y1, value_type const & z1, value_type const & w1,
+				value_type const & x2, value_type const & y2, value_type const & z2, value_type const & w2);
+			explicit tmat3x4(
+				col_type const & v0, 
+				col_type const & v1,
+				col_type const & v2);
 
 			// Conversion
 			template <typename U> 
-			explicit tmat3x4(const tmat3x4<U>& m);
+			explicit tmat3x4(tmat3x4<U> const & m);
 
-			explicit tmat3x4(const tmat2x2<T>& x);
+			explicit tmat3x4(tmat2x2<T> const & x);
-			explicit tmat3x4(const tmat3x3<T>& x);
+			explicit tmat3x4(tmat3x3<T> const & x);
-			explicit tmat3x4(const tmat4x4<T>& x);
+			explicit tmat3x4(tmat4x4<T> const & x);
-			explicit tmat3x4(const tmat2x3<T>& x);
+			explicit tmat3x4(tmat2x3<T> const & x);
-			explicit tmat3x4(const tmat3x2<T>& x);
+			explicit tmat3x4(tmat3x2<T> const & x);
-			explicit tmat3x4(const tmat2x4<T>& x);
+			explicit tmat3x4(tmat2x4<T> const & x);
-			explicit tmat3x4(const tmat4x2<T>& x);
+			explicit tmat3x4(tmat4x2<T> const & x);
-			explicit tmat3x4(const tmat4x3<T>& x);
+			explicit tmat3x4(tmat4x3<T> const & x);
 
 			// Accesses
-			detail::tvec4<T>& operator[](size_type i);
+			col_type & operator[](size_type i);
-			detail::tvec4<T> const & operator[](size_type i) const;
+			col_type const & operator[](size_type i) const;
 
 			// Unary updatable operators
-			tmat3x4<T>& operator=  (const tmat3x4<T>& m);
+			tmat3x4<T> & operator=  (tmat3x4<T> const & m);
-			tmat3x4<T>& operator+= (const T & s);
+			template <typename U> 
-			tmat3x4<T>& operator+= (const tmat3x4<T>& m);
+			tmat3x4<T> & operator=  (tmat3x4<U> const & m);
-			tmat3x4<T>& operator-= (const T & s);
+			template <typename U> 
-			tmat3x4<T>& operator-= (const tmat3x4<T>& m);
+			tmat3x4<T> & operator+= (U const & s);
-			tmat3x4<T>& operator*= (const T & s);
+			template <typename U> 
-			tmat3x4<T>& operator*= (const tmat4x3<T>& m);
+			tmat3x4<T> & operator+= (tmat3x4<U> const & m);
-			tmat3x4<T>& operator/= (const T & s);
+			template <typename U> 
-			//tmat3x4<T>& operator/= (const tmat4x3<T>& m);
+			tmat3x4<T> & operator-= (U const & s);
+			template <typename U> 
+			tmat3x4<T> & operator-= (tmat3x4<U> const & m);
+			template <typename U> 
+			tmat3x4<T> & operator*= (U const & s);
+			template <typename U> 
+			tmat3x4<T> & operator*= (tmat3x4<U> const & m);
+			template <typename U> 
+			tmat3x4<T> & operator/= (U const & s);
 
-			tmat3x4<T>& operator++ ();
+			tmat3x4<T> & operator++ ();
-			tmat3x4<T>& operator-- ();
+			tmat3x4<T> & operator-- ();
 		};
 
 		// Binary operators
 		template <typename T> 
-		tmat3x4<T> operator+ (const tmat3x4<T>& m, const T & s);
+		tmat3x4<T> operator+ (
+			tmat3x4<T> const & m, 
+			typename tmat3x4<T>::value_type const & s);
 	    
 		template <typename T> 
-		tmat3x4<T> operator+ (const tmat3x4<T>& m1, const tmat3x4<T>& m2);
+		tmat3x4<T> operator+ (
+			tmat3x4<T> const & m1, 
+			tmat3x4<T> const & m2);
 	    
 		template <typename T> 
-		tmat3x4<T> operator- (const tmat3x4<T>& m, const T & s);
+		tmat3x4<T> operator- (
+			tmat3x4<T> const & m, 
+			typename tmat3x4<T>::value_type const & s);
 
 		template <typename T> 
-		tmat3x4<T> operator- (const tmat3x4<T>& m1, const tmat3x4<T>& m2);
+		tmat3x4<T> operator- (
+			tmat3x4<T> const & m1, 
+			tmat3x4<T> const & m2);
 
 		template <typename T> 
-		tmat3x4<T> operator* (const tmat3x4<T>& m, const T & s);
+		tmat3x4<T> operator* (
+			tmat3x4<T> const & m, 
+			typename tmat3x4<T>::value_type const & s);
 
 		template <typename T> 
-		tmat3x4<T> operator* (const T & s, const tmat3x4<T>& m);
+		tmat3x4<T> operator* (
+			typename tmat3x4<T>::value_type const & s, 
+			tmat3x4<T> const & m);
 
 		template <typename T>
-		detail::tvec4<T> operator* (const tmat3x4<T>& m, const detail::tvec3<T>& v);
+		typename tmat3x4<T>::row_type operator* (
+			tmat3x4<T> const & m, 
+			typename tmat3x4<T>::col_type const & v);
 
 		template <typename T> 
-		detail::tvec3<T> operator* (const detail::tvec4<T>& v, const tmat3x4<T>& m);
+		typename tmat3x4<T>::col_type operator* (
+			typename tmat3x4<T>::row_type const & v, 
+			tmat3x4<T> const & m);
 
 		template <typename T>
-		tmat4x4<T> operator* (const tmat3x4<T>& m1, const tmat4x3<T>& m2);
+		tmat4x4<T> operator* (
+			tmat3x4<T> const & m1, 
+			tmat4x3<T> const & m2);
 
 		template <typename T> 
-		tmat4x3<T> operator/ (const tmat4x3<T>& m, const T & s);
+		tmat3x4<T> operator/ (
+			tmat3x4<T> const & m, 
+			typename tmat3x4<T>::value_type const & s);
 
 		template <typename T> 
-		tmat4x3<T> operator/ (const T & s, const tmat4x3<T>& m);
+		tmat3x4<T> operator/ (
-
+			typename tmat3x4<T>::value_type const & s, 
-		//template <typename T> 
+			tmat3x4<T> const & m);
-		//detail::tvec4<T> operator/ (const tmat3x4<T>& m, const detail::tvec3<T>& v);
-
-		//template <typename T> 
-		//detail::tvec3<T> operator/ (const detail::tvec4<T>& v, const tmat3x4<T>& m);
-
-		//template <typename T> 
-		//tmat4x4<T> operator/ (const tmat4x3<T>& m1, const tmat3x4<T>& m2);
 
 		// Unary constant operators
-		template <typename valType> 
+		template <typename T> 
-		tmat3x4<valType> const operator-  (tmat3x4<valType> const & m);
+		tmat3x4<T> const operator-  (
+			tmat3x4<T> const & m);
 
-		template <typename valType> 
+		template <typename T> 
-		tmat3x4<valType> const operator-- (tmat3x4<valType> const & m, int);
+		tmat3x4<T> const operator-- (
+			tmat3x4<T> const & m, 
+			int);
 
-		template <typename valType> 
+		template <typename T> 
-		tmat3x4<valType> const operator++ (tmat3x4<valType> const & m, int);
+		tmat3x4<T> const operator++ (
+			tmat3x4<T> const & m, 
+			int);
 
 	} //namespace detail
 
 	namespace core{
 	namespace type{
-	namespace matrix{
 
 	namespace precision
 	{
@@ -185,21 +205,6 @@ namespace glm
 	}
 	//namespace precision
 
-#ifndef GLM_PRECISION 
-	//! 3 columns of 4 components matrix of floating-point numbers. 
-	//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices)
-	typedef detail::tmat3x4<mediump_float>	mat3x4;
-#elif(GLM_PRECISION & GLM_PRECISION_HIGH)
-	typedef detail::tmat3x4<highp_float>	mat3x4;
-#elif(GLM_PRECISION & GLM_PRECISION_MEDIUM)
-	typedef detail::tmat3x4<mediump_float>	mat3x4;
-#elif(GLM_PRECISION & GLM_PRECISION_LOW)
-	typedef detail::tmat3x4<lowp_float>		mat3x4;
-#else
-	typedef detail::tmat3x4<mediump_float>	mat3x4;
-#endif//GLM_PRECISION
-
-	}//namespace matrix
 	}//namespace type
 	}//namespace core
 } //namespace glm

glm/core/type_mat3x4.inl

@@ -1,54 +1,50 @@
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-// OpenGL Mathematics Copyright (c) 2005 - 2009 G-Truc Creation (www.g-truc.net)
+// OpenGL Mathematics Copyright (c) 2005 - 2010 G-Truc Creation (www.g-truc.net)
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 // Created : 2006-08-05
-// Updated : 2006-10-01
+// Updated : 2010-02-05
 // Licence : This source is under MIT License
 // File    : glm/core/type_mat3x4.inl
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 namespace glm{
-namespace detail{
+namespace detail
-
+{
-	template <typename valType> 
+	template <typename T>
-	typename tmat3x4<valType>::size_type tmat3x4<valType>::col_size()
+	inline typename tmat3x4<T>::size_type tmat3x4<T>::col_size()
 	{
-		return typename tmat3x4<valType>::size_type(3);
+		return 4;
 	}
 
-	template <typename valType> 
+	template <typename T>
-	typename tmat3x4<valType>::size_type tmat3x4<valType>::row_size()
+	inline typename tmat3x4<T>::size_type tmat3x4<T>::row_size()
 	{
-		return typename tmat3x4<valType>::size_type(4);
+		return 3;
-	}
-
-	template <typename valType> 
-	bool tmat3x4<valType>::is_matrix()
-	{
-		return true;
 	}
 
 	//////////////////////////////////////
 	// Accesses
 
-	template <typename valType>
+	template <typename T>
-	detail::tvec4<valType>& tmat3x4<valType>::operator[](typename tmat3x4<valType>::size_type i)
+	inline typename tmat3x4<T>::col_type & 
+	tmat3x4<T>::operator[]
+	(
+		size_type i
+	)
 	{
-		assert(
+		assert(i >= size_type(0) && i < col_size());
-			i >= typename tmat3x4<valType>::size_type(0) && 
+		return this->value[i];
-			i < tmat3x4<valType>::col_size());
-
-		return value[i];
 	}
 
-	template <typename valType>
+	template <typename T>
-	const detail::tvec4<valType>& tmat3x4<valType>::operator[](typename tmat3x4<valType>::size_type i) const
+	inline typename tmat3x4<T>::col_type const & 
+	tmat3x4<T>::operator[]
+	(
+		size_type i
+	) const
 	{
-		assert(
+		assert(i >= size_type(0) && i < col_size());
-			i >= typename tmat3x4<valType>::size_type(0) && 
+		return this->value[i];
-			i < tmat3x4<valType>::col_size());
-
-		return value[i];
 	}
 
     //////////////////////////////////////////////////////////////
@@ -57,38 +53,62 @@ namespace detail{
     template <typename T> 
     inline tmat3x4<T>::tmat3x4()
     {
-        this->value[0] = detail::tvec4<T>(1, 0, 0, 0);
+		value_type const Zero(0);
-        this->value[1] = detail::tvec4<T>(0, 1, 0, 0);
+		value_type const One(1);
-        this->value[2] = detail::tvec4<T>(0, 0, 1, 0);
+        this->value[0] = col_type(1, 0, 0, 0);
-    }
+        this->value[1] = col_type(0, 1, 0, 0);
-
+        this->value[2] = col_type(0, 0, 1, 0);
-    template <typename T> 
-    inline tmat3x4<T>::tmat3x4(const T f)
-    {
-        this->value[0] = detail::tvec4<T>(f, 0, 0, 0);
-        this->value[1] = detail::tvec4<T>(0, f, 0, 0);
-        this->value[2] = detail::tvec4<T>(0, 0, f, 0);
     }
 
     template <typename T> 
     inline tmat3x4<T>::tmat3x4
 	(
-        const T x0, const T y0, const T z0, const T w0,
+		tmat3x4<T> const & m
-        const T x1, const T y1, const T z1, const T w1,
-        const T x2, const T y2, const T z2, const T w2
 	)
     {
-        this->value[0] = detail::tvec4<T>(x0, y0, z0, w0);
+        this->value[0] = m.value[0];
-        this->value[1] = detail::tvec4<T>(x1, y1, z1, w1);
+        this->value[1] = m.value[1];
-        this->value[2] = detail::tvec4<T>(x2, y2, z2, w2);
+        this->value[2] = m.value[2];
     }
 
     template <typename T> 
     inline tmat3x4<T>::tmat3x4
 	(
-        const detail::tvec4<T> & v0, 
+		ctor
-        const detail::tvec4<T> & v1, 
+	)
-        const detail::tvec4<T> & v2
+    {}
+
+    template <typename T> 
+    inline tmat3x4<T>::tmat3x4
+	(
+		value_type const & s
+	)
+    {
+		value_type const Zero(0);
+        this->value[0] = col_type(s, Zero, Zero, Zero);
+        this->value[1] = col_type(Zero, s, Zero, Zero);
+        this->value[2] = col_type(Zero, Zero, s, Zero);
+    }
+
+    template <typename T> 
+    inline tmat3x4<T>::tmat3x4
+    (
+		value_type const & x0, value_type const & y0, value_type const & z0, value_type const & w0,
+        value_type const & x1, value_type const & y1, value_type const & z1, value_type const & w1,
+        value_type const & x2, value_type const & y2, value_type const & z2, value_type const & w2
+    )
+    {
+        this->value[0] = col_type(x0, y0, z0, w0);
+        this->value[1] = col_type(x1, y1, z1, w1);
+        this->value[2] = col_type(x2, y2, z2, w2);
+    }
+
+    template <typename T> 
+    inline tmat3x4<T>::tmat3x4
+    (
+        col_type const & v0, 
+        col_type const & v1, 
+        col_type const & v2
     )
     {
         this->value[0] = v0;
@@ -99,82 +119,112 @@ namespace detail{
     // Conversion
     template <typename T> 
     template <typename U> 
-    inline tmat3x4<T>::tmat3x4(const tmat3x4<U>& m)
+    inline tmat3x4<T>::tmat3x4
+	(
+		tmat3x4<U> const & m
+	)
     {
-        this->value[0] = detail::tvec4<T>(m[0]);
+        this->value[0] = col_type(m[0]);
-        this->value[1] = detail::tvec4<T>(m[1]);
+        this->value[1] = col_type(m[1]);
-        this->value[2] = detail::tvec4<T>(m[2]);
+        this->value[2] = col_type(m[2]);
 	}
 
     template <typename T> 
-    inline tmat3x4<T>::tmat3x4(tmat2x2<T> const & m)
+    inline tmat3x4<T>::tmat3x4
+	(
+		tmat2x2<T> const & m
+	)
     {
-        this->value[0] = detail::tvec4<T>(m[0], detail::tvec2<T>(0));
+        this->value[0] = col_type(m[0], detail::tvec2<T>(0));
-        this->value[1] = detail::tvec4<T>(m[1], detail::tvec2<T>(0));
+        this->value[1] = col_type(m[1], detail::tvec2<T>(0));
-        this->value[2] = detail::tvec4<T>(T(0), T(0), T(1), T(0));
+        this->value[2] = col_type(T(0), T(0), T(1), T(0));
     }
 
     template <typename T> 
-    inline tmat3x4<T>::tmat3x4(const tmat3x3<T>& m)
+    inline tmat3x4<T>::tmat3x4
+	(
+		tmat3x3<T> const & m
+	)
     {
-        this->value[0] = detail::tvec4<T>(m[0], T(0));
+        this->value[0] = col_type(m[0], T(0));
-        this->value[1] = detail::tvec4<T>(m[1], T(0));
+        this->value[1] = col_type(m[1], T(0));
-        this->value[2] = detail::tvec4<T>(m[2], T(0));
+        this->value[2] = col_type(m[2], T(0));
     }
 
     template <typename T> 
-    inline tmat3x4<T>::tmat3x4(const tmat4x4<T>& m)
+    inline tmat3x4<T>::tmat3x4
+	(
+		tmat4x4<T> const & m
+	)
     {
-        this->value[0] = detail::tvec4<T>(m[0]);
+        this->value[0] = col_type(m[0]);
-        this->value[1] = detail::tvec4<T>(m[1]);
+        this->value[1] = col_type(m[1]);
-        this->value[2] = detail::tvec4<T>(m[2]);
+        this->value[2] = col_type(m[2]);
     }
 
     template <typename T> 
-    inline tmat3x4<T>::tmat3x4(const tmat2x3<T>& m)
+    inline tmat3x4<T>::tmat3x4
+	(
+		tmat2x3<T> const & m
+	)
     {
-        this->value[0] = detail::tvec4<T>(m[0], T(0));
+        this->value[0] = col_type(m[0], T(0));
-        this->value[1] = detail::tvec4<T>(m[1], T(0));
+        this->value[1] = col_type(m[1], T(0));
-        this->value[2] = detail::tvec4<T>(T(0), T(0), T(1), T(0));
+        this->value[2] = col_type(T(0), T(0), T(1), T(0));
     }
 
     template <typename T> 
-    inline tmat3x4<T>::tmat3x4(const tmat3x2<T>& m)
+    inline tmat3x4<T>::tmat3x4
+	(
+		tmat3x2<T> const & m
+	)
     {
-        this->value[0] = detail::tvec4<T>(m[0], detail::tvec2<T>(0));
+        this->value[0] = col_type(m[0], detail::tvec2<T>(0));
-        this->value[1] = detail::tvec4<T>(m[1], detail::tvec2<T>(0));
+        this->value[1] = col_type(m[1], detail::tvec2<T>(0));
-        this->value[2] = detail::tvec4<T>(m[2], T(0), T(1));
+        this->value[2] = col_type(m[2], T(0), T(1));
     }
 
     template <typename T> 
-    inline tmat3x4<T>::tmat3x4(const tmat2x4<T>& m)
+    inline tmat3x4<T>::tmat3x4
+	(
+		tmat2x4<T> const & m
+	)
     {
-        this->value[0] = detail::tvec4<T>(m[0]);
+        this->value[0] = col_type(m[0]);
-        this->value[1] = detail::tvec4<T>(m[1]);
+        this->value[1] = col_type(m[1]);
-        this->value[2] = detail::tvec4<T>(T(0), T(0), T(1), T(0));
+        this->value[2] = col_type(T(0), T(0), T(1), T(0));
     }
 
     template <typename T> 
-    inline tmat3x4<T>::tmat3x4(const tmat4x2<T>& m)
+    inline tmat3x4<T>::tmat3x4
+	(
+		tmat4x2<T> const & m
+	)
     {
-        this->value[0] = detail::tvec4<T>(m[0], detail::tvec2<T>(T(0)));
+        this->value[0] = col_type(m[0], detail::tvec2<T>(T(0)));
-        this->value[1] = detail::tvec4<T>(m[1], detail::tvec2<T>(T(0)));
+        this->value[1] = col_type(m[1], detail::tvec2<T>(T(0)));
-        this->value[2] = detail::tvec4<T>(m[2], detail::tvec2<T>(T(1), T(0)));
+        this->value[2] = col_type(m[2], detail::tvec2<T>(T(1), T(0)));
     }
 
     template <typename T> 
-    inline tmat3x4<T>::tmat3x4(const tmat4x3<T>& m)
+    inline tmat3x4<T>::tmat3x4
+	(
+		tmat4x3<T> const & m
+	)
     {
-        this->value[0] = detail::tvec4<T>(m[0], T(0));
+        this->value[0] = col_type(m[0], T(0));
-        this->value[1] = detail::tvec4<T>(m[1], T(0));
+        this->value[1] = col_type(m[1], T(0));
-        this->value[2] = detail::tvec4<T>(m[2], T(0));
+        this->value[2] = col_type(m[2], T(0));
     }
 
     //////////////////////////////////////////////////////////////
     // Unary updatable operators
 
     template <typename T> 
-    inline tmat3x4<T>& tmat3x4<T>::operator= (const tmat3x4<T>& m)
+    inline tmat3x4<T>& tmat3x4<T>::operator= 
+	(
+		tmat3x4<T> const & m
+	)
     {
         this->value[0] = m[0];
         this->value[1] = m[1];
@@ -183,7 +233,24 @@ namespace detail{
     }
 
     template <typename T> 
-    inline tmat3x4<T>& tmat3x4<T>::operator+= (const T & s)
+	template <typename U> 
+    inline tmat3x4<T>& tmat3x4<T>::operator= 
+	(
+		tmat3x4<U> const & m
+	)
+    {
+        this->value[0] = m[0];
+        this->value[1] = m[1];
+        this->value[2] = m[2];
+        return *this;
+    }
+
+    template <typename T> 
+	template <typename U> 
+    inline tmat3x4<T>& tmat3x4<T>::operator+= 
+	(
+		U const & s
+	)
     {
         this->value[0] += s;
         this->value[1] += s;
@@ -192,7 +259,11 @@ namespace detail{
     }
 
     template <typename T> 
-    inline tmat3x4<T>& tmat3x4<T>::operator+= (const tmat3x4<T>& m)
+	template <typename U> 
+    inline tmat3x4<T>& tmat3x4<T>::operator+= 
+	(
+		tmat3x4<U> const & m
+	)
     {
         this->value[0] += m[0];
         this->value[1] += m[1];
@@ -201,7 +272,11 @@ namespace detail{
     }
 
     template <typename T> 
-    inline tmat3x4<T>& tmat3x4<T>::operator-= (const T & s)
+	template <typename U> 
+    inline tmat3x4<T>& tmat3x4<T>::operator-= 
+	(
+		U const & s
+	)
     {
         this->value[0] -= s;
         this->value[1] -= s;
@@ -210,7 +285,11 @@ namespace detail{
     }
 
     template <typename T> 
-    inline tmat3x4<T>& tmat3x4<T>::operator-= (const tmat3x4<T>& m)
+	template <typename U> 
+    inline tmat3x4<T>& tmat3x4<T>::operator-= 
+	(
+		tmat3x4<U> const & m
+	)
     {
         this->value[0] -= m[0];
         this->value[1] -= m[1];
@@ -219,7 +298,11 @@ namespace detail{
     }
 
     template <typename T> 
-    inline tmat3x4<T>& tmat3x4<T>::operator*= (const T & s)
+	template <typename U> 
+    inline tmat3x4<T>& tmat3x4<T>::operator*= 
+	(
+		U const & s
+	)
     {
         this->value[0] *= s;
         this->value[1] *= s;
@@ -228,26 +311,28 @@ namespace detail{
     }
 
     template <typename T> 
-    inline tmat3x4<T>& tmat3x4<T>::operator*= (const tmat4x3<T>& m)
+	template <typename U> 
+    inline tmat3x4<T>& tmat3x4<T>::operator*= 
+	(
+		tmat3x4<U> const & m
+	)
     {
         return (*this = tmat3x4<T>(*this * m));
     }
 
     template <typename T> 
-    inline tmat3x4<T> & tmat3x4<T>::operator/= (const T & s)
+	template <typename U> 
+    inline tmat3x4<T> & tmat3x4<T>::operator/= 
+	(
+		U const & s
+	)
     {
         this->value[0] /= s;
         this->value[1] /= s;
         this->value[2] /= s;
         return *this;
     }
-/* ToDo
+
-    template <typename T> 
-    inline tmat3x4<T>& tmat3x4<T>::operator/= (const tmat4x3<T>& m)
-    {
-        return (*this = tmat3x4<T>(*this / m));
-    }
-*/
     template <typename T> 
     inline tmat3x4<T>& tmat3x4<T>::operator++ ()
     {
@@ -270,7 +355,11 @@ namespace detail{
     // Binary operators
 
     template <typename T> 
-    inline tmat3x4<T> operator+ (const tmat3x4<T>& m, const T & s)
+    inline tmat3x4<T> operator+ 
+	(
+		tmat3x4<T> const & m, 
+		typename tmat3x4<T>::value_type const & s
+	)
     {
         return tmat3x4<T>(
             m[0] + s,
@@ -279,7 +368,11 @@ namespace detail{
     }
 
     template <typename T> 
-    inline tmat3x4<T> operator+ (const tmat3x4<T>& m1, const tmat3x4<T>& m2)
+    inline tmat3x4<T> operator+ 
+	(
+		tmat3x4<T> const & m1, 
+		tmat3x4<T> const & m2
+	)
     {
         return tmat3x4<T>(
             m1[0] + m2[0],
@@ -288,7 +381,11 @@ namespace detail{
     }
 
     template <typename T> 
-    inline tmat3x4<T> operator- (const tmat3x4<T>& m, const T & s)
+	inline tmat3x4<T> operator- 
+	(
+		tmat3x4<T> const & m, 
+		typename tmat3x4<T>::value_type const & s
+	)
     {
         return tmat3x4<T>(
             m[0] - s,
@@ -297,7 +394,11 @@ namespace detail{
     }
 
     template <typename T> 
-    inline tmat3x4<T> operator- (const tmat3x4<T>& m1, const tmat3x4<T>& m2)
+    inline tmat3x4<T> operator- 
+	(
+		tmat3x4<T> const & m1, 
+		tmat3x4<T> const & m2
+	)
     {
         return tmat3x4<T>(
             m1[0] - m2[0],
@@ -306,7 +407,11 @@ namespace detail{
     }
 
     template <typename T> 
-    inline tmat3x4<T> operator* (const tmat3x4<T>& m, const T & s)
+    inline tmat3x4<T> operator* 
+	(
+		tmat3x4<T> const & m, 
+		typename tmat3x4<T>::value_type const & s
+	)
     {
         return tmat3x4<T>(
             m[0] * s,
@@ -315,7 +420,11 @@ namespace detail{
     }
 
     template <typename T> 
-    inline tmat3x4<T> operator* (const T & s, const tmat3x4<T> & m)
+    inline tmat3x4<T> operator* 
+	(
+		typename tmat3x4<T>::value_type const & s, 
+		tmat3x4<T> const & m
+	)
     {
         return tmat3x4<T>(
             m[0] * s,
@@ -324,9 +433,13 @@ namespace detail{
     }
    
     template <typename T>
-    inline detail::tvec4<T> operator* (const tmat3x4<T>& m, const detail::tvec3<T>& v)
+    inline typename tmat3x4<T>::row_type operator* 
+	(
+		tmat3x4<T> const & m, 
+		typename tmat3x4<T>::col_type const & v
+	)
     {
-        return detail::tvec4<T>(
+        return typename tmat3x4<T>::row_type(
             m[0][0] * v.x + m[1][0] * v.y + m[2][0] * v.z,
             m[0][1] * v.x + m[1][1] * v.y + m[2][1] * v.z,
             m[0][2] * v.x + m[1][2] * v.y + m[2][2] * v.z,
@@ -334,16 +447,24 @@ namespace detail{
     }
 
     template <typename T> 
-    inline detail::tvec3<T> operator* (const detail::tvec4<T>& v, const tmat3x4<T>& m) 
+    inline typename tmat3x4<T>::col_type operator* 
+	(
+		typename tmat3x4<T>::row_type const & v, 
+		tmat3x4<T> const & m
+	)
     {
-        return detail::tvec3<T>(
+		return typename tmat3x4<T>::col_type(
             m[0][0] * v.x + m[1][0] * v.y + m[2][0] * v.z + m[3][0] * v.w,
             m[0][1] * v.x + m[1][1] * v.y + m[2][1] * v.z + m[3][1] * v.w,
             m[0][2] * v.x + m[1][2] * v.y + m[2][2] * v.z + m[3][2] * v.w);
     }
 
     template <typename T> 
-    inline tmat4x4<T> operator* (const tmat3x4<T>& m1, const tmat4x3<T>& m2)
+    inline tmat4x4<T> operator* 
+	(
+		tmat3x4<T> const & m1, 
+		tmat4x3<T> const & m2
+	)
     {
         const T SrcA00 = m1[0][0];
         const T SrcA01 = m1[0][1];
@@ -371,7 +492,7 @@ namespace detail{
         const T SrcB31 = m2[3][1];
         const T SrcB32 = m2[3][2];
 
-        tmat4x4<T> Result;
+        tmat4x4<T> Result(tmat4x4<T>::null);
         Result[0][0] = SrcA00 * SrcB00 + SrcA10 * SrcB01 + SrcA20 * SrcB02;
         Result[0][1] = SrcA01 * SrcB00 + SrcA11 * SrcB01 + SrcA21 * SrcB02;
         Result[0][2] = SrcA02 * SrcB00 + SrcA12 * SrcB01 + SrcA22 * SrcB02;
@@ -392,7 +513,11 @@ namespace detail{
     }
 
     template <typename T> 
-    inline tmat3x4<T> operator/ (const tmat3x4<T>& m, const T & s)
+    inline tmat3x4<T> operator/ 
+	(
+		tmat3x4<T> const & m, 
+		typename tmat3x4<T>::value_type const & s
+	)
     {
         return tmat3x4<T>(
             m[0] / s,
@@ -402,7 +527,11 @@ namespace detail{
     }
 
     template <typename T> 
-    inline tmat3x4<T> operator/ (const T & s, const tmat3x4<T>& m)
+    inline tmat3x4<T> operator/
+	(
+		typename tmat3x4<T>::value_type const & s, 
+		tmat3x4<T> const & m
+	)
     {
         return tmat3x4<T>(
             s / m[0],
@@ -411,73 +540,43 @@ namespace detail{
             s / m[3]);        
     }
 
-	//template <typename valType> 
-	//inline tvec4<valType> operator/ 
-	//(
-	//	tmat3x4<valType> const & m, 
-	//	tvec4<valType> const & v
-	//)
-	//{
-	//	return m._inverse() * v;
-	//}
-
-	//template <typename valType> 
-	//inline tvec3<valType> operator/ 
-	//(
-	//	tvec4<valType> const & v, 
-	//	tmat3x4<valType> const & m
-	//)
-	//{
-	//	return v * m._inverse();
-	//}
-
-	//template <typename valType> 
-	//inline tmat4x4<valType> operator/ 
-	//(
-	//	tmat3x4<valType> const & m1, 
-	//	tmat4x3<valType> const & m2
-	//)
-	//{
-	//	return m1 * m2._inverse();
-	//}
-
 	// Unary constant operators
-    template <typename valType> 
+    template <typename T> 
-    inline tmat3x4<valType> const operator- 
+    inline tmat3x4<T> const operator- 
 	(
-		tmat3x4<valType> const & m
+		tmat3x4<T> const & m
 	)
     {
-        return tmat3x4<valType>(
+        return tmat3x4<T>(
             -m[0], 
             -m[1],
             -m[2]);
     }
 
-    template <typename valType> 
+    template <typename T> 
-    inline tmat3x4<valType> const operator++ 
+    inline tmat3x4<T> const operator++ 
 	(
-		tmat3x4<valType> const & m, 
+		tmat3x4<T> const & m, 
 		int
 	) 
     {
-        return tmat3x4<valType>(
+        return tmat3x4<T>(
-            m[0] + valType(1),
+            m[0] + T(1),
-            m[1] + valType(1),
+            m[1] + T(1),
-            m[2] + valType(1));
+            m[2] + T(1));
     }
 
-    template <typename valType> 
+    template <typename T> 
-    inline tmat3x4<valType> const operator-- 
+    inline tmat3x4<T> const operator-- 
 	(
-		tmat3x4<valType> const & m, 
+		tmat3x4<T> const & m, 
 		int
 	) 
     {
-        return tmat3x4<valType>(
+        return tmat3x4<T>(
-            m[0] - valType(1),
+            m[0] - T(1),
-            m[1] - valType(1),
+            m[1] - T(1),
-            m[2] - valType(1));
+            m[2] - T(1));
 	}
 
 } //namespace detail

glm/core/type_mat4x2.hpp

@@ -1,16 +1,16 @@
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-// OpenGL Mathematics Copyright (c) 2005 - 2009 G-Truc Creation (www.g-truc.net)
+// OpenGL Mathematics Copyright (c) 2005 - 2010 G-Truc Creation (www.g-truc.net)
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 // Created : 2006-10-01
-// Updated : 2008-08-30
+// Updated : 2010-02-11
 // Licence : This source is under MIT License
-// File    : glm/core/type_mat4x2.h
+// File    : glm/core/type_mat4x2.hpp
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 #ifndef glm_core_type_mat4x2
 #define glm_core_type_mat4x2
 
-#include "type_size.hpp"
+#include "type_mat.hpp"
 
 namespace glm
 {
@@ -35,77 +35,80 @@ namespace glm
 		template <typename T> struct tmat4x3;
 		template <typename T> struct tmat4x4;
 
-		//!< \brief Template for 4 * 2 matrix of floating-point numbers.
+		//!< \brief Template for 4 columns and 2 rows matrix of floating-point numbers.
 		template <typename T> 
 		struct tmat4x2
 		{
-		public:
+			enum ctor{null};
-			typedef tmat4x2<T>* pointer;
-			typedef const tmat4x2<T>* const_pointer;
-			typedef const tmat4x2<T>*const const_pointer_const;
-			typedef tmat4x2<T>*const pointer_const;
-			typedef tmat4x2<T>& reference;
-			typedef const tmat4x2<T>& const_reference;
-			typedef const tmat4x2<T>& param_type;
-			typedef tmat2x4<T> transpose_type;
-
 			typedef T value_type;
-			typedef detail::tvec4<T> col_type;
+			typedef std::size_t size_type;
-			typedef detail::tvec2<T> row_type;
+			typedef tvec2<T> col_type;
-			typedef glm::sizeType size_type;
+			typedef tvec4<T> row_type;
 			static size_type col_size();
 			static size_type row_size();
-			static bool is_matrix();
 
-		public:
+			typedef tmat4x2<T> type;
-			tmat2x4<T> _inverse() const;
+			typedef tmat2x4<T> transpose_type;
 
 		private:
 			// Data 
-			detail::tvec2<T> value[4];
+			col_type value[4];
 
 		public:
 			// Constructors
 			tmat4x2();
-			explicit tmat4x2(T const & x);
+			tmat4x2(tmat4x2 const & m);
+
 			explicit tmat4x2(
-				T const & x0, T const & y0,
+				ctor Null);
-				T const & x1, T const & y1,
-				T const & x2, T const & y2,
-				T const & x3, T const & y3);
 			explicit tmat4x2(
-				detail::tvec2<T> const & v0, 
+				value_type const & x);
-				detail::tvec2<T> const & v1,
+			explicit tmat4x2(
-				detail::tvec2<T> const & v2,
+				value_type const & x0, value_type const & y0,
-				detail::tvec2<T> const & v3);
+				value_type const & x1, value_type const & y1,
+				value_type const & x2, value_type const & y2,
+				value_type const & x3, value_type const & y3);
+			explicit tmat4x2(
+				col_type const & v0, 
+				col_type const & v1,
+				col_type const & v2,
+				col_type const & v3);
 
 			// Conversions
 			template <typename U> 
-			explicit tmat4x2(const tmat4x2<U>& m);
+			explicit tmat4x2(tmat4x2<U> const & m);
 			
-			explicit tmat4x2(const tmat2x2<T>& x);
+			explicit tmat4x2(tmat2x2<T> const & x);
-			explicit tmat4x2(const tmat3x3<T>& x);
+			explicit tmat4x2(tmat3x3<T> const & x);
-			explicit tmat4x2(const tmat4x4<T>& x);
+			explicit tmat4x2(tmat4x4<T> const & x);
-			explicit tmat4x2(const tmat2x3<T>& x);
+			explicit tmat4x2(tmat2x3<T> const & x);
-			explicit tmat4x2(const tmat3x2<T>& x);
+			explicit tmat4x2(tmat3x2<T> const & x);
-			explicit tmat4x2(const tmat2x4<T>& x);
+			explicit tmat4x2(tmat2x4<T> const & x);
-			explicit tmat4x2(const tmat4x3<T>& x);
+			explicit tmat4x2(tmat4x3<T> const & x);
-			explicit tmat4x2(const tmat3x4<T>& x);
+			explicit tmat4x2(tmat3x4<T> const & x);
 
 			// Accesses
-			detail::tvec2<T>& operator[](size_type i);
+			col_type & operator[](size_type i);
-			detail::tvec2<T> const & operator[](size_type i) const;
+			col_type const & operator[](size_type i) const;
 
 			// Unary updatable operators
-			tmat4x2<T>& operator= (const tmat4x2<T>& m);
+			tmat4x2<T>& operator=  (tmat4x2<T> const & m);
-			tmat4x2<T>& operator+= (const T & s);
+			template <typename U> 
-			tmat4x2<T>& operator+= (const tmat4x2<T>& m);
+			tmat4x2<T>& operator=  (tmat4x2<U> const & m);
-			tmat4x2<T>& operator-= (const T & s);
+			template <typename U> 
-			tmat4x2<T>& operator-= (const tmat4x2<T>& m);
+			tmat4x2<T>& operator+= (U const & s);
-			tmat4x2<T>& operator*= (const T & s);
+			template <typename U> 
-			tmat4x2<T>& operator*= (const tmat2x4<T>& m);
+			tmat4x2<T>& operator+= (tmat4x2<U> const & m);
-			tmat4x2<T>& operator/= (const T & s);
+			template <typename U> 
-			tmat4x2<T>& operator/= (const tmat2x4<T>& m);
+			tmat4x2<T>& operator-= (U const & s);
+			template <typename U> 
+			tmat4x2<T>& operator-= (tmat4x2<U> const & m);
+			template <typename U> 
+			tmat4x2<T>& operator*= (U const & s);
+			template <typename U> 
+			tmat4x2<T>& operator*= (tmat4x2<U> const & m);
+			template <typename U> 
+			tmat4x2<T>& operator/= (U const & s);
 
 			tmat4x2<T>& operator++ ();
 			tmat4x2<T>& operator-- ();
@@ -113,62 +116,79 @@ namespace glm
 
 		// Binary operators
 		template <typename T> 
-		tmat4x2<T> operator+ (const tmat4x2<T>& m, const T & s);
+		tmat4x2<T> operator+ (
+			tmat4x2<T> const & m, 
+			typename tmat4x2<T>::value_type const & s);
 	    
 		template <typename T> 
-		tmat4x2<T> operator+ (const tmat4x2<T>& m1, const tmat4x2<T>& m2);
+		tmat4x2<T> operator+ (
+			tmat4x2<T> const & m1, 
+			tmat4x2<T> const & m2);
 	    
 		template <typename T> 
-		tmat4x2<T> operator- (const tmat4x2<T>& m, const T & s);
+		tmat4x2<T> operator- (
+			tmat4x2<T> const & m, 
+			typename tmat4x2<T>::value_type const & s);
 
 		template <typename T> 
-		tmat4x2<T> operator- (const tmat4x2<T>& m1, const tmat4x2<T>& m2);
+		tmat4x2<T> operator- (
+			tmat4x2<T> const & m1, 
+			tmat4x2<T> const & m2);
 
 		template <typename T> 
-		tmat4x2<T> operator* (const tmat4x2<T>& m, const T & s);
+		tmat4x2<T> operator* (
+			tmat4x2<T> const & m, 
+			typename tmat4x2<T>::value_type const & s);
 
 		template <typename T> 
-		tmat4x2<T> operator* (const T & s, const tmat4x2<T>& m);
+		tmat4x2<T> operator* (
+			typename tmat4x2<T>::value_type const & s, 
+			tmat4x2<T> const & m);
 
 		template <typename T>
-		detail::tvec2<T> operator* (const tmat4x2<T>& m, const detail::tvec4<T>& v);
+		typename tmat4x2<T>::row_type operator* (
+			tmat4x2<T> const & m, 
+			typename tmat4x2<T>::col_type const & v);
 
 		template <typename T> 
-		detail::tvec4<T> operator* (const detail::tvec2<T>& v, const tmat4x2<T>& m);
+		typename tmat4x2<T>::col_type operator* (
+			typename tmat4x2<T>::row_type const & v, 
+			tmat4x2<T> const & m);
 
 		template <typename T> 
-		tmat2x2<T> operator* (const tmat4x2<T>& m1, const tmat2x4<T>& m2);
+		tmat2x2<T> operator* (
+			tmat4x2<T> const & m1, 
+			tmat2x4<T> const & m2);
 
 		template <typename T> 
-		tmat4x2<T> operator/ (const tmat4x2<T>& m, const T & s);
+		tmat4x2<T> operator/ (
+			tmat4x2<T> const & m, 
+			typename tmat4x2<T>::value_type const & s);
 
 		template <typename T> 
-		tmat4x2<T> operator/ (const T & s, const tmat4x2<T>& m);
+		tmat4x2<T> operator/ (
-
+			typename tmat4x2<T>::value_type const & s, 
-		//template <typename T> 
+			tmat4x2<T> const & m);
-		//detail::tvec2<T> operator/ (const tmat4x2<T>& m, const detail::tvec4<T>& v);
-
-		//template <typename T> 
-		//detail::tvec4<T> operator/ (const detail::tvec2<T>& v, const tmat4x2<T>& m);
-
-		//template <typename T> 
-		//tmat2x2<T> operator/ (const tmat4x2<T>& m1, const tmat2x4<T>& m2);
 
 		// Unary constant operators
-		template <typename valType> 
+		template <typename T> 
-		tmat4x2<valType> const operator-  (tmat4x2<valType> const & m);
+		tmat4x2<T> const operator-  (
+			tmat4x2<T> const & m);
 
-		template <typename valType> 
+		template <typename T> 
-		tmat4x2<valType> const operator-- (tmat4x2<valType> const & m, int);
+		tmat4x2<T> const operator-- (
+			tmat4x2<T> const & m, 
+			int);
 
-		template <typename valType> 
+		template <typename T> 
-		tmat4x2<valType> const operator++ (tmat4x2<valType> const & m, int);
+		tmat4x2<T> const operator++ (
+			tmat4x2<T> const & m, 
+			int);
 
 	} //namespace detail
 
 	namespace core{
 	namespace type{
-	namespace matrix{
 
 	namespace precision
 	{
@@ -187,21 +207,6 @@ namespace glm
 	}
 	//namespace precision
 
-#ifndef GLM_PRECISION
-	//! 4 columns of 2 components matrix of floating-point numbers. 
-	//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices)
-	typedef detail::tmat4x2<mediump_float>	mat4x2;
-#elif(GLM_PRECISION & GLM_PRECISION_HIGH)
-	typedef detail::tmat4x2<highp_float>	mat4x2;
-#elif(GLM_PRECISION & GLM_PRECISION_MEDIUM)
-	typedef detail::tmat4x2<mediump_float>	mat4x2;
-#elif(GLM_PRECISION & GLM_PRECISION_LOW)
-	typedef detail::tmat4x2<lowp_float>		mat4x2;
-#else
-	typedef detail::tmat4x2<mediump_float>	mat4x2;
-#endif//GLM_PRECISION
-
-	}//namespace matrix
 	}//namespace type
 	}//namespace core
 } //namespace glm

glm/core/type_mat4x2.inl

@@ -1,108 +1,120 @@
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-// OpenGL Mathematics Copyright (c) 2005 - 2009 G-Truc Creation (www.g-truc.net)
+// OpenGL Mathematics Copyright (c) 2005 - 2010 G-Truc Creation (www.g-truc.net)
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 // Created : 2006-10-01
-// Updated : 2008-10-05
+// Updated : 2010-02-03
 // Licence : This source is under MIT License
 // File    : glm/core/type_mat4x2.inl
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 namespace glm{
-namespace detail{
+namespace detail
-
+{
-	template <typename valType> 
+	template <typename T>
-	typename tmat4x2<valType>::size_type tmat4x2<valType>::col_size()
+	inline typename tmat4x2<T>::size_type tmat4x2<T>::col_size()
 	{
-		return typename tmat4x2<valType>::size_type(4);
+		return 2;
 	}
 
-	template <typename valType> 
+	template <typename T>
-	typename tmat4x2<valType>::size_type tmat4x2<valType>::row_size()
+	inline typename tmat4x2<T>::size_type tmat4x2<T>::row_size()
 	{
-		return typename tmat4x2<valType>::size_type(2);
+		return 4;
-	}
-
-	template <typename valType> 
-	bool tmat4x2<valType>::is_matrix()
-	{
-		return true;
 	}
 
 	//////////////////////////////////////
 	// Accesses
 
-	template <typename valType>
+	template <typename T>
-	detail::tvec2<valType>& tmat4x2<valType>::operator[]
+	inline typename tmat4x2<T>::col_type & 
+	tmat4x2<T>::operator[]
 	(
-		typename tmat4x2<valType>::size_type i
+		size_type i
 	)
 	{
-		assert(
+		assert(i >= size_type(0) && i < col_size());
-			i >= typename tmat4x2<valType>::size_type(0) && 
+		return this->value[i];
-			i < tmat4x2<valType>::col_size());
-
-		return value[i];
 	}
 
-	template <typename valType>
+	template <typename T>
-	const detail::tvec2<valType>& tmat4x2<valType>::operator[]
+	inline typename tmat4x2<T>::col_type const & 
+	tmat4x2<T>::operator[]
 	(
-		typename tmat4x2<valType>::size_type i
+		size_type i
 	) const
 	{
-		assert(
+		assert(i >= size_type(0) && i < col_size());
-			i >= typename tmat4x2<valType>::size_type(0) && 
+		return this->value[i];
-			i < tmat4x2<valType>::col_size());
-
-		return value[i];
 	}
 
     //////////////////////////////////////////////////////////////
     // Constructors
 
-    template <typename valType> 
+    template <typename T> 
-    inline tmat4x2<valType>::tmat4x2()
+    inline tmat4x2<T>::tmat4x2()
     {
-        this->value[0] = detail::tvec2<valType>(1, 0);
+		value_type const Zero(0);
-        this->value[1] = detail::tvec2<valType>(0, 1);
+		value_type const One(1);
-        this->value[2] = detail::tvec2<valType>(0, 0);
+        this->value[0] = col_type(One, Zero);
-        this->value[3] = detail::tvec2<valType>(0, 0);
+        this->value[1] = col_type(Zero, One);
+        this->value[2] = col_type(Zero, Zero);
+        this->value[3] = col_type(Zero, Zero);
     }
 
-    template <typename valType> 
+    template <typename T> 
-    inline tmat4x2<valType>::tmat4x2
+    inline tmat4x2<T>::tmat4x2
 	(
-		valType const & s
+		tmat4x2<T> const & m
 	)
     {
-        this->value[0] = detail::tvec2<valType>(s, 0);
+        this->value[0] = m.value[0];
-        this->value[1] = detail::tvec2<valType>(0, s);
+        this->value[1] = m.value[1];
-        this->value[2] = detail::tvec2<valType>(0, 0);
+        this->value[2] = m.value[2];
-        this->value[3] = detail::tvec2<valType>(0, 0);
+        this->value[3] = m.value[3];
     }
 
-    template <typename valType> 
+    template <typename T> 
-    inline tmat4x2<valType>::tmat4x2
+    inline tmat4x2<T>::tmat4x2
 	(
-        valType const & x0, valType const & y0,
+		ctor
-        valType const & x1, valType const & y1,
+	)
-        valType const & x2, valType const & y2,
+    {}
-        valType const & x3, valType const & y3
+
+    template <typename T> 
+    inline tmat4x2<T>::tmat4x2
+	(
+		value_type const & s
 	)
     {
-        this->value[0] = detail::tvec2<valType>(x0, y0);
+		value_type const Zero(0);
-        this->value[1] = detail::tvec2<valType>(x1, y1);
+        this->value[0] = col_type(s, Zero);
-        this->value[2] = detail::tvec2<valType>(x2, y2);
+        this->value[1] = col_type(Zero, s);
-        this->value[3] = detail::tvec2<valType>(x3, y3);
+        this->value[2] = col_type(Zero, Zero);
+        this->value[3] = col_type(Zero, Zero);
     }
 
-    template <typename valType> 
+    template <typename T> 
-    inline tmat4x2<valType>::tmat4x2
+    inline tmat4x2<T>::tmat4x2
     (
-        const detail::tvec2<valType> & v0, 
+        value_type const & x0, value_type const & y0,
-        const detail::tvec2<valType> & v1, 
+        value_type const & x1, value_type const & y1,
-        const detail::tvec2<valType> & v2,
+        value_type const & x2, value_type const & y2,
-        const detail::tvec2<valType> & v3
+        value_type const & x3, value_type const & y3
+    )
+    {
+        this->value[0] = col_type(x0, y0);
+        this->value[1] = col_type(x1, y1);
+        this->value[2] = col_type(x2, y2);
+        this->value[3] = col_type(x3, y3);
+    }
+
+    template <typename T> 
+    inline tmat4x2<T>::tmat4x2
+    (
+        col_type const & v0, 
+        col_type const & v1, 
+        col_type const & v2,
+        col_type const & v3
     )
     {
         this->value[0] = v0;
@@ -112,93 +124,123 @@ namespace detail{
     }
 
     // Conversion
-    template <typename valType> 
+    template <typename T> 
     template <typename U> 
-    inline tmat4x2<valType>::tmat4x2(const tmat4x2<U>& m)
+    inline tmat4x2<T>::tmat4x2
+	(
+		tmat4x2<U> const & m
+	)
     {
-        this->value[0] = detail::tvec2<valType>(m[0]);
+        this->value[0] = col_type(m[0]);
-        this->value[1] = detail::tvec2<valType>(m[1]);
+        this->value[1] = col_type(m[1]);
-        this->value[2] = detail::tvec2<valType>(m[2]);
+        this->value[2] = col_type(m[2]);
-        this->value[3] = detail::tvec2<valType>(m[3]);
+        this->value[3] = col_type(m[3]);
 	}
 
-    template <typename valType> 
+    template <typename T> 
-    inline tmat4x2<valType>::tmat4x2(tmat2x2<valType> const & m)
+    inline tmat4x2<T>::tmat4x2
+	(
+		tmat2x2<T> const & m
+	)
     {
-        this->value[0] = detail::tvec2<valType>(m[0]);
+        this->value[0] = col_type(m[0]);
-        this->value[1] = detail::tvec2<valType>(m[1]);
+        this->value[1] = col_type(m[1]);
-        this->value[2] = detail::tvec2<valType>(valType(0));
+        this->value[2] = col_type(value_type(0));
-        this->value[3] = detail::tvec2<valType>(valType(0));
+        this->value[3] = col_type(value_type(0));
     }
 
-    template <typename valType> 
+    template <typename T> 
-    inline tmat4x2<valType>::tmat4x2(const tmat3x3<valType>& m)
+    inline tmat4x2<T>::tmat4x2
+	(
+		tmat3x3<T> const & m
+	)
     {
-        this->value[0] = detail::tvec2<valType>(m[0]);
+        this->value[0] = col_type(m[0]);
-        this->value[1] = detail::tvec2<valType>(m[1]);
+        this->value[1] = col_type(m[1]);
-        this->value[2] = detail::tvec2<valType>(m[2]);
+        this->value[2] = col_type(m[2]);
-        this->value[3] = detail::tvec2<valType>(valType(0));
+        this->value[3] = col_type(value_type(0));
     }
 
-    template <typename valType> 
+    template <typename T> 
-    inline tmat4x2<valType>::tmat4x2(const tmat4x4<valType>& m)
+    inline tmat4x2<T>::tmat4x2
+	(
+		tmat4x4<T> const & m
+	)
     {
-        this->value[0] = detail::tvec2<valType>(m[0]);
+        this->value[0] = col_type(m[0]);
-        this->value[1] = detail::tvec2<valType>(m[1]);
+        this->value[1] = col_type(m[1]);
-        this->value[2] = detail::tvec2<valType>(m[2]);
+        this->value[2] = col_type(m[2]);
-        this->value[3] = detail::tvec2<valType>(m[3]);
+        this->value[3] = col_type(m[3]);
     }
 
-    template <typename valType> 
+    template <typename T> 
-    inline tmat4x2<valType>::tmat4x2(const tmat2x3<valType>& m)
+    inline tmat4x2<T>::tmat4x2
+	(
+		tmat2x3<T> const & m
+	)
     {
-        this->value[0] = detail::tvec2<valType>(m[0]);
+        this->value[0] = col_type(m[0]);
-        this->value[1] = detail::tvec2<valType>(m[1]);
+        this->value[1] = col_type(m[1]);
-        this->value[2] = detail::tvec2<valType>(valType(0));
+        this->value[2] = col_type(value_type(0));
-        this->value[3] = detail::tvec2<valType>(valType(0));
+        this->value[3] = col_type(value_type(0));
     }
 
-    template <typename valType> 
+    template <typename T> 
-    inline tmat4x2<valType>::tmat4x2(const tmat3x2<valType>& m)
+    inline tmat4x2<T>::tmat4x2
+	(
+		tmat3x2<T> const & m
+	)
     {
-        this->value[0] = detail::tvec2<valType>(m[0]);
+        this->value[0] = col_type(m[0]);
-        this->value[1] = detail::tvec2<valType>(m[1]);
+        this->value[1] = col_type(m[1]);
-        this->value[2] = detail::tvec2<valType>(m[2]);
+        this->value[2] = col_type(m[2]);
-        this->value[3] = detail::tvec2<valType>(valType(0));
+        this->value[3] = col_type(value_type(0));
     }
 
-    template <typename valType> 
+    template <typename T> 
-    inline tmat4x2<valType>::tmat4x2(const tmat2x4<valType>& m)
+    inline tmat4x2<T>::tmat4x2
+	(
+		tmat2x4<T> const & m
+	)
     {
-        this->value[0] = detail::tvec2<valType>(m[0]);
+        this->value[0] = col_type(m[0]);
-        this->value[1] = detail::tvec2<valType>(m[1]);
+        this->value[1] = col_type(m[1]);
-        this->value[2] = detail::tvec2<valType>(valType(0));
+        this->value[2] = col_type(value_type(0));
-        this->value[3] = detail::tvec2<valType>(valType(0));
+        this->value[3] = col_type(value_type(0));
     }
 
-    template <typename valType> 
+    template <typename T> 
-    inline tmat4x2<valType>::tmat4x2(const tmat4x3<valType>& m)
+    inline tmat4x2<T>::tmat4x2
+	(
+		tmat4x3<T> const & m
+	)
     {
-        this->value[0] = detail::tvec2<valType>(m[0]);
+        this->value[0] = col_type(m[0]);
-        this->value[1] = detail::tvec2<valType>(m[1]);
+        this->value[1] = col_type(m[1]);
-        this->value[2] = detail::tvec2<valType>(m[2]);
+        this->value[2] = col_type(m[2]);
-        this->value[3] = detail::tvec2<valType>(m[3]);
+        this->value[3] = col_type(m[3]);
     }
 
-    template <typename valType> 
+    template <typename T> 
-    inline tmat4x2<valType>::tmat4x2(const tmat3x4<valType>& m)
+    inline tmat4x2<T>::tmat4x2
+	(
+		tmat3x4<T> const & m
+	)
     {
-        this->value[0] = detail::tvec2<valType>(m[0]);
+        this->value[0] = col_type(m[0]);
-        this->value[1] = detail::tvec2<valType>(m[1]);
+        this->value[1] = col_type(m[1]);
-        this->value[2] = detail::tvec2<valType>(m[2]);
+        this->value[2] = col_type(m[2]);
-        this->value[3] = detail::tvec2<valType>(valType(0));
+        this->value[3] = col_type(value_type(0));
     }
 
     //////////////////////////////////////////////////////////////
     // Unary updatable operators
 
-    template <typename valType> 
+    template <typename T> 
-    inline tmat4x2<valType>& tmat4x2<valType>::operator= (const tmat4x2<valType>& m)
+    inline tmat4x2<T>& tmat4x2<T>::operator= 
+	(
+		tmat4x2<T> const & m
+	)
     {
         this->value[0] = m[0];
         this->value[1] = m[1];
@@ -207,8 +249,26 @@ namespace detail{
         return *this;
     }
 
-    template <typename valType> 
+    template <typename T> 
-    inline tmat4x2<valType>& tmat4x2<valType>::operator+= (const valType & s)
+	template <typename U> 
+    inline tmat4x2<T>& tmat4x2<T>::operator= 
+	(
+		tmat4x2<U> const & m
+	)
+    {
+        this->value[0] = m[0];
+        this->value[1] = m[1];
+        this->value[2] = m[2];
+        this->value[3] = m[3];
+        return *this;
+    }
+
+    template <typename T> 
+	template <typename U> 
+    inline tmat4x2<T> & tmat4x2<T>::operator+= 
+	(
+		U const & s
+	)
     {
         this->value[0] += s;
         this->value[1] += s;
@@ -217,8 +277,12 @@ namespace detail{
         return *this;
     }
 
-    template <typename valType> 
+    template <typename T> 
-    inline tmat4x2<valType>& tmat4x2<valType>::operator+= (const tmat4x2<valType>& m)
+	template <typename U> 
+    inline tmat4x2<T> & tmat4x2<T>::operator+= 
+	(
+		tmat4x2<U> const & m
+	)
     {
         this->value[0] += m[0];
         this->value[1] += m[1];
@@ -227,8 +291,12 @@ namespace detail{
         return *this;
     }
 
-    template <typename valType> 
+    template <typename T> 
-    inline tmat4x2<valType>& tmat4x2<valType>::operator-= (const valType & s)
+	template <typename U> 
+    inline tmat4x2<T> & tmat4x2<T>::operator-= 
+	(
+		U const & s
+	)
     {
         this->value[0] -= s;
         this->value[1] -= s;
@@ -237,8 +305,12 @@ namespace detail{
         return *this;
     }
 
-    template <typename valType> 
+    template <typename T> 
-    inline tmat4x2<valType>& tmat4x2<valType>::operator-= (const tmat4x2<valType>& m)
+	template <typename U> 
+    inline tmat4x2<T> & tmat4x2<T>::operator-= 
+	(
+		tmat4x2<U> const & m
+	)
     {
         this->value[0] -= m[0];
         this->value[1] -= m[1];
@@ -247,8 +319,12 @@ namespace detail{
         return *this;
     }
 
-    template <typename valType> 
+    template <typename T> 
-    inline tmat4x2<valType>& tmat4x2<valType>::operator*= (const valType & s)
+	template <typename U> 
+    inline tmat4x2<T> & tmat4x2<T>::operator*= 
+	(
+		U const & s
+	)
     {
         this->value[0] *= s;
         this->value[1] *= s;
@@ -257,14 +333,22 @@ namespace detail{
         return *this;
     }
 
-    template <typename valType> 
+    template <typename T> 
-    inline tmat4x2<valType>& tmat4x2<valType>::operator*= (const tmat2x4<valType>& m)
+	template <typename U> 
+    inline tmat4x2<T> & tmat4x2<T>::operator*= 
+	(
+		tmat4x2<U> const & m
+	)
     {
-        return (*this = tmat4x2<valType>(*this * m));
+        return (*this = tmat4x2<T>(*this * m));
     }
 
-    template <typename valType> 
+    template <typename T>
-    inline tmat4x2<valType> & tmat4x2<valType>::operator/= (const valType & s)
+	template <typename U> 
+    inline tmat4x2<T> & tmat4x2<T>::operator/= 
+	(
+		U const & s
+	)
     {
         this->value[0] /= s;
         this->value[1] /= s;
@@ -273,14 +357,8 @@ namespace detail{
         return *this;
     }
 
-    //template <typename valType> 
+    template <typename T> 
-    //inline tmat2x2<valType>& tmat4x2<valType>::operator/= (const tmat2x4<valType>& m)
+    inline tmat4x2<T> & tmat4x2<T>::operator++ ()
-    //{
-    //    return (*this = *this / m);
-    //}
-
-    template <typename valType> 
-    inline tmat4x2<valType>& tmat4x2<valType>::operator++ ()
     {
         ++this->value[0];
         ++this->value[1];
@@ -289,8 +367,8 @@ namespace detail{
         return *this;
     }
 
-    template <typename valType> 
+    template <typename T> 
-    inline tmat4x2<valType>& tmat4x2<valType>::operator-- ()
+    inline tmat4x2<T> & tmat4x2<T>::operator-- ()
     {
         --this->value[0];
         --this->value[1];
@@ -299,117 +377,145 @@ namespace detail{
         return *this;
     }
 
-    //////////////////////////////////////////////////////////////
-    // inverse
-	template <typename valType> 
-    inline tmat2x4<valType> tmat4x2<valType>::_inverse() const
-    {
-		assert(0); //g.truc.creation[at]gmail.com
-    }
-
     //////////////////////////////////////////////////////////////
     // Binary operators
 
-    template <typename valType> 
+    template <typename T> 
-    inline tmat4x2<valType> operator+ (const tmat4x2<valType>& m, const valType & s)
+    inline tmat4x2<T> operator+ 
+	(
+		tmat4x2<T> const & m, 
+		typename tmat4x2<T>::value_type const & s
+	)
     {
-        return tmat4x2<valType>(
+        return tmat4x2<T>(
             m[0] + s,
             m[1] + s,
             m[2] + s,
             m[3] + s);
     }
 
-    template <typename valType> 
+    template <typename T> 
-    inline tmat4x2<valType> operator+ (const tmat4x2<valType>& m1, const tmat4x2<valType>& m2)
+    inline tmat4x2<T> operator+ 
+	(	
+		tmat4x2<T> const & m1, 
+		tmat4x2<T> const & m2
+	)
     {
-        return tmat4x2<valType>(
+        return tmat4x2<T>(
             m1[0] + m2[0],
             m1[1] + m2[1],
             m1[2] + m2[2],
             m1[3] + m2[3]);
     }
 
-    template <typename valType> 
+    template <typename T> 
-    inline tmat4x2<valType> operator- (const tmat4x2<valType>& m, const valType & s)
+    inline tmat4x2<T> operator- 
+	(
+		tmat4x2<T> const & m, 
+		typename tmat4x2<T>::value_type const & s
+	)
     {
-        return tmat4x2<valType>(
+        return tmat4x2<T>(
             m[0] - s,
             m[1] - s,
             m[2] - s,
             m[3] - s);
     }
 
-    template <typename valType> 
+    template <typename T> 
-    inline tmat4x2<valType> operator- (const tmat4x2<valType>& m1, const tmat4x2<valType>& m2)
+    inline tmat4x2<T> operator- 
+	(	
+		tmat4x2<T> const & m1, 
+		tmat4x2<T> const & m2
+	)
     {
-        return tmat4x2<valType>(
+        return tmat4x2<T>(
             m1[0] - m2[0],
             m1[1] - m2[1],
             m1[2] - m2[2],
             m1[3] - m2[3]);
     }
 
-    template <typename valType> 
+    template <typename T> 
-    inline tmat4x2<valType> operator* (const tmat4x2<valType>& m, const valType & s)
+    inline tmat4x2<T> operator* 
+	(
+		tmat4x2<T> const & m, 
+		typename tmat4x2<T>::value_type const & s
+	)
     {
-        return tmat4x2<valType>(
+        return tmat4x2<T>(
             m[0] * s,
             m[1] * s,
             m[2] * s,
             m[3] * s);
     }
 
-    template <typename valType> 
+    template <typename T> 
-    inline tmat4x2<valType> operator* (const valType & s, const tmat4x2<valType> & m)
+    inline tmat4x2<T> operator* 
+	(
+		typename tmat4x2<T>::value_type const & s, 
+		tmat4x2<T> const & m
+	)
     {
-        return tmat4x2<valType>(
+        return tmat4x2<T>(
             m[0] * s,
             m[1] * s,
             m[2] * s,
             m[3] * s);
     }
    
-    template <typename valType>
+    template <typename T>
-    inline detail::tvec2<valType> operator* (const tmat4x2<valType>& m, const tvec4<valType>& v)
+    inline typename tmat4x2<T>::row_type operator* 
+	(
+		tmat4x2<T> const & m, 
+		typename tmat4x2<T>::col_type const & v
+	)
     {
-        return detail::tvec2<valType>(
+        return typename tmat4x2<T>::row_type(
             m[0][0] * v.x + m[1][0] * v.y + m[2][0] * v.z + m[3][0] * v.w,
             m[0][1] * v.x + m[1][1] * v.y + m[2][1] * v.z + m[3][1] * v.w);
     }
 
-    template <typename valType> 
+    template <typename T> 
-    inline tvec4<valType> operator* (const detail::tvec2<valType>& v, const tmat4x2<valType>& m) 
+    inline typename tmat4x2<T>::row_type operator* 
+	(
+		typename tmat4x2<T>::row_type const & v, 
+		tmat4x2<T> const & m
+	)
     {
-        return tvec4<valType>(
+		return typename tmat4x2<T>::row_type(
             v.x * m[0][0] + v.y * m[0][1],
             v.x * m[1][0] + v.y * m[1][1],
             v.x * m[2][0] + v.y * m[2][1],
             v.x * m[3][0] + v.y * m[3][1]);
     }
 
-    template <typename valType> 
+    template <typename T> 
-    inline tmat2x2<valType> operator* (const tmat4x2<valType>& m1, const tmat2x4<valType>& m2)
+    inline tmat2x2<T> operator* 
+	(
+		tmat4x2<T> const & m1, 
+		tmat2x4<T> const & m2
+	)
     {
-        const valType SrcA00 = m1[0][0];
+        T const SrcA00 = m1[0][0];
-        const valType SrcA01 = m1[0][1];
+        T const SrcA01 = m1[0][1];
-        const valType SrcA10 = m1[1][0];
+        T const SrcA10 = m1[1][0];
-        const valType SrcA11 = m1[1][1];
+        T const SrcA11 = m1[1][1];
-        const valType SrcA20 = m1[2][0];
+        T const SrcA20 = m1[2][0];
-        const valType SrcA21 = m1[2][1];
+        T const SrcA21 = m1[2][1];
-        const valType SrcA30 = m1[3][0];
+        T const SrcA30 = m1[3][0];
-        const valType SrcA31 = m1[3][1];
+        T const SrcA31 = m1[3][1];
 
-        const valType SrcB00 = m2[0][0];
+        T const SrcB00 = m2[0][0];
-        const valType SrcB01 = m2[0][1];
+        T const SrcB01 = m2[0][1];
-        const valType SrcB02 = m2[0][2];
+        T const SrcB02 = m2[0][2];
-        const valType SrcB03 = m2[0][3];
+        T const SrcB03 = m2[0][3];
-        const valType SrcB10 = m2[1][0];
+        T const SrcB10 = m2[1][0];
-        const valType SrcB11 = m2[1][1];
+        T const SrcB11 = m2[1][1];
-        const valType SrcB12 = m2[1][2];
+        T const SrcB12 = m2[1][2];
-        const valType SrcB13 = m2[1][3];
+        T const SrcB13 = m2[1][3];
 
-        tmat2x2<valType> Result;
+        tmat2x2<T> Result(tmat2x2<T>::null);
         Result[0][0] = SrcA00 * SrcB00 + SrcA01 * SrcB01 + SrcA20 * SrcB02 + SrcA30 * SrcB03;
         Result[0][1] = SrcA01 * SrcB00 + SrcA11 * SrcB01 + SrcA21 * SrcB02 + SrcA31 * SrcB03;
         Result[1][0] = SrcA00 * SrcB10 + SrcA10 * SrcB11 + SrcA20 * SrcB12 + SrcA30 * SrcB13;
@@ -417,96 +523,74 @@ namespace detail{
         return Result;
     }
 
-    template <typename valType> 
+    template <typename T> 
-    inline tmat4x2<valType> operator/ (const tmat4x2<valType>& m, const valType & s)
+    inline tmat4x2<T> operator/ 
+	(
+		tmat4x2<T> const & m, 
+		typename tmat4x2<T>::value_type const & s
+	)
     {
-        return tmat4x2<valType>(
+        return tmat4x2<T>(
             m[0] / s,
             m[1] / s,
             m[2] / s,
             m[3] / s);        
     }
 
-    template <typename valType> 
+    template <typename T> 
-    inline tmat4x2<valType> operator/ (const valType & s, const tmat4x2<valType>& m)
+    inline tmat4x2<T> operator/ 
+	(
+		typename tmat4x2<T>::value_type const & s, 
+		tmat4x2<T> const & m
+	)
     {
-        return tmat4x2<valType>(
+        return tmat4x2<T>(
             s / m[0],
             s / m[1],
             s / m[2],
             s / m[3]);        
     }
 
-	//template <typename valType> 
-	//tvec2<valType> operator/ 
-	//(
-	//	tmat4x2<valType> const & m, 
-	//	tvec4<valType> const & v
-	//)
-	//{
-	//	return m._inverse() * v;
-	//}
-
-	//template <typename valType> 
-	//tvec4<valType> operator/ 
-	//(
-	//	tvec2<valType> const & v, 
-	//	tmat4x2<valType> const & m
-	//)
-	//{
-	//	return v * m._inverse();
-	//}
-
-	//template <typename valType> 
-	//inline tmat2x2<valType> operator/ 
-	//(
-	//	tmat4x2<valType> const & m1, 
-	//	tmat2x4<valType> const & m2
-	//)
-	//{
-	//	return m1 * m2._inverse();
-	//}
-
 	// Unary constant operators
-    template <typename valType> 
+    template <typename T> 
-    inline tmat4x2<valType> const operator- 
+    inline tmat4x2<T> const operator- 
 	(
-		tmat4x2<valType> const & m
+		tmat4x2<T> const & m
 	)
     {
-        return tmat4x2<valType>(
+        return tmat4x2<T>(
             -m[0], 
             -m[1], 
             -m[2], 
             -m[3]);
     }
 
-    template <typename valType> 
+    template <typename T> 
-    inline tmat4x2<valType> const operator++ 
+    inline tmat4x2<T> const operator++ 
 	(
-		tmat4x2<valType> const & m, 
+		tmat4x2<T> const & m, 
 		int
 	) 
     {
-        return tmat4x2<valType>(
+        return tmat4x2<T>(
-            m[0] + valType(1),
+			m[0] + typename tmat4x2<T>::value_type(1),
-            m[1] + valType(1),
+            m[1] + typename tmat4x2<T>::value_type(1),
-            m[2] + valType(1),
+            m[2] + typename tmat4x2<T>::value_type(1),
-            m[3] + valType(1));
+            m[3] + typename tmat4x2<T>::value_type(1));
     }
 
-    template <typename valType> 
+    template <typename T> 
-    inline tmat4x2<valType> const operator-- 
+    inline tmat4x2<T> const operator-- 
 	(
-		tmat4x2<valType> const & m, 
+		tmat4x2<T> const & m, 
 		int
 	) 
     {
-        return tmat4x2<valType>(
+        return tmat4x2<T>(
-            m[0] - valType(1),
+            m[0] - typename tmat4x2<T>::value_type(1),
-            m[1] - valType(1),
+            m[1] - typename tmat4x2<T>::value_type(1),
-            m[2] - valType(1),
+            m[2] - typename tmat4x2<T>::value_type(1),
-            m[3] - valType(1));
+            m[3] - typename tmat4x2<T>::value_type(1));
     }
 
 } //namespace detail