mirror/glm
1
0
Fork 0
mirror of https://github.com/g-truc/glm.git synced 2024-11-25 18:04:34 +00:00
Code Issues Packages Projects Releases Wiki Activity

Updated to GLM 0.9.B

Browse Source
This commit is contained in:
Christophe Riccio 2010-04-29 11:56:52 +01:00
parent 7c7b1d0b3d
commit 05439738b8
266 changed files with 15552 additions and 8092 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
CMakeLists.txt Normal file
View File

@ -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)

10
doc/CMakeLists.txt Normal file
View File

@ -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})

BIN
doc/build/XalanMessages_1_7_0.dll vendored Normal file
View File

Binary file not shown.

9
doc/build/build.bat vendored Normal file
View File

@ -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

BIN
doc/build/msvcp71.dll vendored Normal file
View File

Binary file not shown.

BIN
doc/build/msvcr71.dll vendored Normal file
View File

Binary file not shown.

BIN
doc/build/xalan-c_1_7_0.dll vendored Normal file
View File

Binary file not shown.

BIN
doc/build/xalan.exe vendored Normal file
View File

Binary file not shown.

BIN
doc/build/xerces-c_2_5_0.dll vendored Normal file
View File

Binary file not shown.

475
doc/common/doxygen/doxygen.css Normal file
View File

@ -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%;
}

BIN
doc/common/doxygen/doxygen.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 1.7 KiB

BIN
doc/common/doxygen/tab_b.gif Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 807 B

BIN
doc/common/doxygen/tab_l.gif Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 1.3 KiB

BIN
doc/common/doxygen/tab_r.gif Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 3.2 KiB

102
doc/common/doxygen/tabs.css Normal file
View File

@ -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;
}

38
doc/common/style.css
View File

@ -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

61
doc/doxyfile
View File

@ -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)
# there is already a search function so this one should typically
# be disabled.
# HTML help (GENERATE_HTMLHELP), Qt help (GENERATE_QHP), or docsets
# (GENERATE_DOCSET) there is already a search function so this one should
# 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
#---------------------------------------------------------------------------
@ -1008,7 +1048,10 @@ GENERATE_LATEX = NO
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.
# 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

BIN
doc/glm-manual.doc Normal file
View File

Binary file not shown.

BIN
doc/glm-manual.pdf
View File

Binary file not shown.

BIN
doc/goodies/logo1024x0640.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 28 KiB

BIN
doc/goodies/logo1280x0800.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 40 KiB

BIN
doc/goodies/logo1600x1000.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 54 KiB

BIN
doc/goodies/logo1920x1200.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 70 KiB

BIN
doc/goodies/logo2560x1600.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 82 KiB

BIN
doc/goodies/tenby-five.otf Normal file
View File

Binary file not shown.

BIN
doc/image/0029-mini.jpg Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 11 KiB

BIN
doc/image/0029.jpg Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 75 KiB

BIN
doc/image/font-mini.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 1.7 KiB

BIN
doc/image/font.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 8.4 KiB

BIN
doc/image/logo-mini.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 8.3 KiB

BIN
doc/image/logo.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 27 KiB

248
doc/readme.txt Normal file
View File

@ -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

68
doc/src/about.xsl Normal file
View File

@ -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>

116
doc/src/bug.xsl Normal file
View File

@ -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>

55
doc/src/changelog.xsl Normal file
View File

@ -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>

111
doc/src/code.xsl Normal file
View File

@ -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>

2302
doc/src/data.xml Normal file
View File

File diff suppressed because it is too large Load Diff

78
doc/src/download.xsl Normal file
View File

@ -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>

4
doc/src/dummy.cpp Normal file
View File

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

79
doc/src/goodies.xsl Normal file
View File

@ -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>

120
doc/src/issue.xsl Normal file
View File

@ -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>

115
doc/src/link.xsl Normal file
View File

@ -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>

81
doc/src/news.xsl Normal file
View File

@ -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>

143
doc/src/util.xsl Normal file
View File

@ -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>

646
doc/usertype.dat Normal file
View File

@ -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

51
glm/CMakeLists.txt Normal file
View File

@ -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})

2
glm/core/_detail.hpp
View File

@ -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

2
glm/core/_swizzle.hpp
View File

@ -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

2
glm/core/_swizzle.inl
View File

@ -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

137
glm/core/func_common.hpp
View File

@ -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>
genTypeT mod(
genTypeT const & x,
genTypeU const & y);
template <typename genType>
genType mod(
genType const & x,
genType const & y);
//! Modulus. Returns x - y * floor(x / y)
//! for each component in x using the floating point value y.
//! (From GLSL 1.30.08 specification, section 8.3)
template <typename genType>
genType mod(
genType const & x,
typename genType::value_type const & y);
//! Returns the fractional part of x and sets i to the integer
//! part (as a whole number floating point value). Both the
@ -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>
genUIFTypeT min(
genUIFTypeT const & x,
genUIFTypeU const & y);
template <typename genType>
genType min(
genType const & x,
genType const & y);
template <typename genType>
genType min(
genType const & x,
typename genType::value_type const & y);
//! Returns y if x < y; otherwise, it returns x.
//! (From GLSL 1.30.08 specification, section 8.3)
template <typename genUIFTypeT, typename genUIFTypeU>
genUIFTypeT max(
genUIFTypeT const & x,
genUIFTypeU const & y);
template <typename genType>
genType max(
genType const & x,
genType const & y);
template <typename genType>
genType max(
genType const & x,
typename genType::value_type const & y);
//! Returns min(max(x, minVal), maxVal) for each component in x
//! using the floating-point values minVal and maxVal.
//! (From GLSL 1.30.08 specification, section 8.3)
template <typename genUIFTypeT, typename genUIFTypeU>
genUIFTypeT clamp(
genUIFTypeT const & x,
genUIFTypeU const & minVal,
genUIFTypeU const & maxVal);
template <typename genType>
genType clamp(
genType const & x,
genType const & minVal,
genType const & maxVal);
template <typename genType>
genType clamp(
genType const & x,
typename genType::value_type const & minVal,
typename genType::value_type const & maxVal);
//! \return If genTypeU is a floating scalar or vector:
//! Returns x * (1.0 - a) + y * a, i.e., the linear blend of
@ -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>
genTypeU step(genTypeT const & edge, genTypeU const & x);
template <typename genType>
genType step(
genType const & edge,
genType const & x);
template <typename genType>
genType step(
typename genType::value_type const & edge,
genType const & x);
//! Returns 0.0 if x <= edge0 and 1.0 if x >= edge1 and
//! performs smooth Hermite interpolation between 0 and 1
@ -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>
genTypeU smoothstep(genTypeT const & edge0, genTypeT const & edge1, genTypeU const & x);
template <typename genType>
genType smoothstep(
genType const & edge0,
genType const & edge1,
genType const & x);
template <typename genType>
genType smoothstep(
typename genType::value_type const & edge0,
typename genType::value_type const & edge1,
genType const & x);
//! Returns true if x holds a NaN (not a number)
//! representation in the underlying implementation's set of
@ -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

771
glm/core/func_common.inl
View File

File diff suppressed because it is too large Load Diff

6
glm/core/func_exponential.hpp
View File

@ -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

178
glm/core/func_exponential.inl
View File

@ -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>
inline detail::tvec2<valType> pow
template <typename T>
inline detail::tvec2<T> pow
(
detail::tvec2<valType> const & x,
detail::tvec2<valType> const & y
detail::tvec2<T> const & x,
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>
inline detail::tvec3<valType> pow
template <typename T>
inline detail::tvec3<T> pow
(
detail::tvec3<valType> const & x,
detail::tvec3<valType> const & y
detail::tvec3<T> const & x,
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>
inline detail::tvec4<valType> pow
template <typename T>
inline detail::tvec4<T> pow
(
detail::tvec4<valType> const & x,
detail::tvec4<valType> const & y
detail::tvec4<T> const & x,
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>
inline detail::tvec2<valType> exp
template <typename T>
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>
inline detail::tvec3<valType> exp
template <typename T>
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>
inline detail::tvec4<valType> exp
template <typename T>
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>
inline detail::tvec2<valType> log
template <typename T>
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>
inline detail::tvec3<valType> log
template <typename T>
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>
inline detail::tvec4<valType> log
template <typename T>
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>
inline detail::tvec2<valType> exp2
template <typename T>
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>
inline detail::tvec3<valType> exp2
template <typename T>
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>
inline detail::tvec4<valType> exp2
template <typename T>
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>
inline detail::tvec2<valType> log2
template <typename T>
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>
inline detail::tvec3<valType> log2
template <typename T>
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>
inline detail::tvec4<valType> log2
template <typename T>
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>
inline detail::tvec2<valType> sqrt
template <typename T>
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>
inline detail::tvec3<valType> sqrt
template <typename T>
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>
inline detail::tvec4<valType> sqrt
template <typename T>
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>
inline detail::tvec2<valType> inversesqrt
template <typename T>
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>
inline detail::tvec3<valType> inversesqrt
template <typename T>
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>
inline detail::tvec4<valType> inversesqrt
template <typename T>
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),

40
glm/core/func_geometric.hpp
View File

@ -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>
detail::tvec3<valType> cross(detail::tvec3<valType> const & x, detail::tvec3<valType> const & y);
template <typename T>
detail::tvec3<T> cross(
detail::tvec3<T> const & x,
detail::tvec3<T> const & y);
//! Returns a vector in the same direction as x but with length of 1.
//! (From GLSL 1.30.08 specification, section 8.4)
template <typename genType>
genType normalize(genType const & x);
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

138
glm/core/func_geometric.inl
View File

@ -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
///////////////////////////////////////////////////////////////////////////////////////////////////
@ -25,40 +25,40 @@ namespace glm
genType sqr = x * x;
return sqrt(sqr);
}
template <typename valType>
inline typename detail::tvec2<valType>::value_type length
template <typename T>
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>
inline typename detail::tvec3<valType>::value_type length
template <typename T>
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>
inline typename detail::tvec4<valType>::value_type length
template <typename T>
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>
inline typename detail::tvec2<valType>::value_type distance
template <typename T>
inline typename detail::tvec2<T>::value_type distance
(
detail::tvec2<valType> const & p0,
detail::tvec2<valType> const & p1
detail::tvec2<T> const & p0,
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>
inline typename detail::tvec3<valType>::value_type distance
template <typename T>
inline typename detail::tvec3<T>::value_type distance
(
detail::tvec3<valType> const & p0,
detail::tvec3<valType> const & p1
detail::tvec3<T> const & p0,
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>
inline typename detail::tvec4<valType>::value_type distance
template <typename T>
inline typename detail::tvec4<T>::value_type distance
(
detail::tvec4<valType> const & p0,
detail::tvec4<valType> const & p1
detail::tvec4<T> const & p0,
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>
inline typename detail::tvec2<valType>::value_type dot
template <typename T>
inline typename detail::tvec2<T>::value_type dot
(
detail::tvec2<valType> const & x,
detail::tvec2<valType> const & y
detail::tvec2<T> const & x,
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>
inline valType dot
template <typename T>
inline T dot
(
detail::tvec3<valType> const & x,
detail::tvec3<valType> const & y
detail::tvec3<T> const & x,
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>
inline valType dot
template <typename T>
inline T dot
(
detail::tvec4<valType> const & x,
detail::tvec4<valType> const & y
detail::tvec4<T> const & x,
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>
inline detail::tvec3<valType> cross
template <typename T>
inline detail::tvec3<T> cross
(
detail::tvec3<valType> const & x,
detail::tvec3<valType> const & y
detail::tvec3<T> const & x,
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>
inline detail::tvec2<valType> normalize
template <typename T>
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>
inline detail::tvec3<valType> normalize
template <typename T>
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>
inline detail::tvec4<valType> normalize
template <typename T>
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);
}

142
glm/core/func_integer.hpp Normal file
View File

@ -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

600
glm/core/func_integer.inl Normal file
View File

@ -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

61
glm/core/func_matrix.hpp
View File

@ -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.
//! (From GLSL 1.50.09 specification, section 8.5). genType: mat2, mat3, mat4.
template <typename genType>
typename genType::value_type determinant(
genType const & m);
//! Return the determinant of a mat2 matrix.
//! (From GLSL 1.50.09 specification, section 8.5)..
template <typename T>
typename detail::tmat2x2<T>::value_type determinant(
detail::tmat2x2<T> const & m);
//! Return the inverse of a matrix.
//! (From GLSL 1.40.07 specification, section 8.5). genType: mat2, mat3, mat4.
template <typename genType>
genType inverse(
genType const & m);
//! Return the determinant of a mat3 matrix.
//! (From GLSL 1.50.09 specification, section 8.5).
template <typename T>
typename detail::tmat3x3<T>::value_type determinant(
detail::tmat3x3<T> const & m);
//! Return the determinant of a mat4 matrix.
//! (From GLSL 1.50.09 specification, section 8.5).
template <typename T>
typename detail::tmat4x4<T>::value_type determinant(
detail::tmat4x4<T> const & m);
//! Return the inverse of a mat2 matrix.
//! (From GLSL 1.40.07 specification, section 8.5).
template <typename T>
detail::tmat2x2<T> inverse(
detail::tmat2x2<T> const & m);
//! Return the inverse of a mat3 matrix.
//! (From GLSL 1.40.07 specification, section 8.5).
template <typename T>
detail::tmat3x3<T> inverse(
detail::tmat3x3<T> const & m);
//! Return the inverse of a mat4 matrix.
//! (From GLSL 1.40.07 specification, section 8.5).
template <typename T>
detail::tmat4x4<T> inverse(
detail::tmat4x4<T> const & m);
}//namespace matrix
}//namespace function

545
glm/core/func_matrix.inl
View File

@ -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>
inline detail::tmat2x2<valType> outerProduct
template <typename T>
inline detail::tmat2x2<T> outerProduct
(
detail::tvec2<valType> const & c,
detail::tvec2<valType> const & r
detail::tvec2<T> const & c,
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>
inline detail::tmat3x3<valType> outerProduct
template <typename T>
inline detail::tmat3x3<T> outerProduct
(
detail::tvec3<valType> const & c,
detail::tvec3<valType> const & r
detail::tvec3<T> const & c,
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;
for(typename detail::tmat3x3<valType>::size_type i = 0; i < detail::tmat3x3<valType>::col_size(); ++i)
detail::tmat3x3<T> m(detail::tmat3x3<T>::null);
for(typename detail::tmat3x3<T>::size_type i = 0; i < detail::tmat3x3<T>::col_size(); ++i)
m[i] = c * r[i];
return m;
}
template <typename valType>
inline detail::tmat4x4<valType> outerProduct
template <typename T>
inline detail::tmat4x4<T> outerProduct
(
detail::tvec4<valType> const & c,
detail::tvec4<valType> const & r
detail::tvec4<T> const & c,
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;
for(typename detail::tmat4x4<valType>::size_type i = 0; i < detail::tmat4x4<valType>::col_size(); ++i)
detail::tmat4x4<T> m(detail::tmat4x4<T>::null);
for(typename detail::tmat4x4<T>::size_type i = 0; i < detail::tmat4x4<T>::col_size(); ++i)
m[i] = c * r[i];
return m;
}
template <typename valType>
inline detail::tmat2x3<valType> outerProduct
template <typename T>
inline detail::tmat2x3<T> outerProduct
(
detail::tvec3<valType> const & c,
detail::tvec2<valType> const & r
detail::tvec3<T> const & c,
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>
inline detail::tmat3x2<valType> outerProduct
template <typename T>
inline detail::tmat3x2<T> outerProduct
(
detail::tvec2<valType> const & c,
detail::tvec3<valType> const & r
detail::tvec2<T> const & c,
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>
inline detail::tmat2x4<valType> outerProduct
template <typename T>
inline detail::tmat2x4<T> outerProduct
(
detail::tvec2<valType> const & c,
detail::tvec4<valType> const & r
detail::tvec2<T> const & c,
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>
inline detail::tmat4x2<valType> outerProduct
template <typename T>
inline detail::tmat4x2<T> outerProduct
(
detail::tvec4<valType> const & c,
detail::tvec2<valType> const & r
detail::tvec4<T> const & c,
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>
inline detail::tmat3x4<valType> outerProduct
template <typename T>
inline detail::tmat3x4<T> outerProduct
(
detail::tvec4<valType> const & c,
detail::tvec3<valType> const & r
detail::tvec4<T> const & c,
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>
inline detail::tmat4x3<valType> outerProduct
template <typename T>
inline detail::tmat4x3<T> outerProduct
(
detail::tvec3<valType> const & c,
detail::tvec4<valType> const & r
detail::tvec3<T> const & c,
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>
inline detail::tmat2x2<valType> transpose
template <typename T>
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>
inline detail::tmat3x3<valType> transpose
template <typename T>
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>
inline detail::tmat4x4<valType> transpose
template <typename T>
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>
inline detail::tmat2x3<valType> transpose
template <typename T>
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>
inline detail::tmat3x2<valType> transpose
template <typename T>
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>
inline detail::tmat2x4<valType> transpose
template <typename T>
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>
inline detail::tmat4x2<valType> transpose
template <typename T>
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>
inline detail::tmat3x4<valType> transpose
template <typename T>
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>
inline detail::tmat4x3<valType> transpose
template <typename T>
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>
inline typename detail::tmat2x2<valType>::value_type determinant
template <typename T>
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>
inline typename detail::tmat3x3<valType>::value_type determinant
template <typename T>
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>
inline typename detail::tmat4x4<valType>::value_type determinant
template <typename T>
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];
valType 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];
valType 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];
valType SubFactor05 = m[2][0] * m[3][1] - m[3][0] * m[2][1];
T SubFactor00 = m[2][2] * m[3][3] - m[3][2] * m[2][3];
T SubFactor01 = m[2][1] * m[3][3] - m[3][1] * m[2][3];
T SubFactor02 = m[2][1] * m[3][2] - m[3][1] * m[2][2];
T SubFactor03 = m[2][0] * m[3][3] - m[3][0] * m[2][3];
T SubFactor04 = m[2][0] * m[3][2] - m[3][0] * m[2][2];
T SubFactor05 = m[2][0] * m[3][1] - m[3][0] * m[2][1];
detail::tvec4<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>
inline detail::tmat2x2<valType> inverse
template <typename T>
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>
inline detail::tmat3x3<valType> inverse
template <typename T>
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>
inline detail::tmat4x4<valType> inverseOgre
template <typename T>
inline detail::tmat4x4<T> inverse
(
detail::tmat4x4<valType> const & m
)
{
valType m00 = m[0][0], m01 = m[0][1], m02 = m[0][2], m03 = m[0][3];
valType m10 = m[1][0], m11 = m[1][1], m12 = m[1][2], m13 = m[1][3];
valType m20 = m[2][0], m21 = m[2][1], m22 = m[2][2], m23 = m[2][3];
valType m30 = m[3][0], m31 = m[3][1], m32 = m[3][2], m33 = m[3][3];
valType v0 = m20 * m31 - m21 * m30;
valType v1 = m20 * m32 - m22 * m30;
valType v2 = m20 * m33 - m23 * m30;
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);
valType t10 = - (v5 * m10 - v2 * m12 + v1 * m13);
valType t20 = + (v4 * m10 - v2 * m11 + v0 * m13);
valType t30 = - (v3 * m10 - v1 * m11 + v0 * m12);
valType invDet = 1 / (t00 * m00 + t10 * m01 + t20 * m02 + t30 * m03);
valType d00 = t00 * invDet;
valType d10 = t10 * invDet;
valType d20 = t20 * invDet;
valType d30 = t30 * invDet;
valType d01 = - (v5 * m01 - v4 * m02 + v3 * m03) * invDet;
valType d11 = + (v5 * m00 - v2 * m02 + v1 * m03) * invDet;
valType d21 = - (v4 * m00 - v2 * m01 + v0 * m03) * invDet;
valType d31 = + (v3 * m00 - v1 * m01 + v0 * m02) * invDet;
v0 = m10 * m31 - m11 * m30;
v1 = m10 * m32 - m12 * m30;
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;
valType d12 = - (v5 * m00 - v2 * m02 + v1 * m03) * invDet;
valType d22 = + (v4 * m00 - v2 * m01 + v0 * m03) * invDet;
valType d32 = - (v3 * m00 - v1 * m01 + v0 * m02) * invDet;
v0 = m21 * m10 - m20 * m11;
v1 = m22 * m10 - m20 * m12;
v2 = m23 * m10 - m20 * m13;
v3 = m22 * m11 - m21 * m12;
v4 = m23 * m11 - m21 * m13;
v5 = m23 * m12 - m22 * m13;
valType d03 = - (v5 * m01 - v4 * m02 + v3 * m03) * invDet;
valType d13 = + (v5 * m00 - v2 * m02 + v1 * m03) * invDet;
valType d23 = - (v4 * m00 - v2 * m01 + v0 * m03) * invDet;
valType d33 = + (v3 * m00 - v1 * m01 + v0 * m02) * invDet;
return detail::tmat4x4<valType>(
d00, d01, d02, d03,
d10, d11, d12, d13,
d20, d21, d22, d23,
d30, d31, d32, d33);
}
template <typename valType>
inline detail::tmat4x4<valType> inverse
(
detail::tmat4x4<valType> const & m
detail::tmat4x4<T> 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];
T Coef00 = m[2][2] * m[3][3] - m[3][2] * m[2][3];
T Coef02 = m[1][2] * m[3][3] - m[3][2] * m[1][3];
T Coef03 = m[1][2] * m[2][3] - m[2][2] * m[1][3];
valType Coef04 = m[2][1] * m[3][3] - m[3][1] * m[2][3];
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];
T Coef04 = m[2][1] * m[3][3] - m[3][1] * m[2][3];
T Coef06 = m[1][1] * m[3][3] - m[3][1] * m[1][3];
T Coef07 = m[1][1] * m[2][3] - m[2][1] * m[1][3];
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];
T Coef08 = m[2][1] * m[3][2] - m[3][1] * m[2][2];
T Coef10 = m[1][1] * m[3][2] - m[3][1] * m[1][2];
T Coef11 = m[1][1] * m[2][2] - m[2][1] * m[1][2];
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];
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 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];
T Coef16 = m[2][0] * m[3][2] - m[3][0] * m[2][2];
T Coef18 = m[1][0] * m[3][2] - m[3][0] * m[1][2];
T Coef19 = m[1][0] * m[2][2] - m[2][0] * m[1][2];
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];
T Coef20 = m[2][0] * m[3][1] - m[3][0] * m[2][1];
T Coef22 = m[1][0] * m[3][1] - m[3][0] * m[1][1];
T Coef23 = m[1][0] * m[2][1] - m[2][0] * m[1][1];
detail::tvec4<valType> const SignA(+1, -1, +1, -1);
detail::tvec4<valType> const SignB(-1, +1, -1, +1);
detail::tvec4<T> const SignA(+1, -1, +1, -1);
detail::tvec4<T> 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<T> Fac0(Coef00, Coef00, Coef02, Coef03);
detail::tvec4<T> Fac1(Coef04, Coef04, Coef06, Coef07);
detail::tvec4<T> Fac2(Coef08, Coef08, Coef10, Coef11);
detail::tvec4<T> Fac3(Coef12, Coef12, Coef14, Coef15);
detail::tvec4<T> Fac4(Coef16, Coef16, Coef18, Coef19);
detail::tvec4<T> Fac5(Coef20, Coef20, Coef22, Coef23);
detail::tvec4<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<T> Vec0(m[1][0], m[0][0], m[0][0], m[0][0]);
detail::tvec4<T> Vec1(m[1][1], m[0][1], m[0][1], m[0][1]);
detail::tvec4<T> Vec2(m[1][2], m[0][2], m[0][2], m[0][2]);
detail::tvec4<T> Vec3(m[1][3], m[0][3], m[0][3], m[0][3]);
detail::tvec4<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::tvec4<T> Inv0 = SignA * (Vec1 * Fac0 - Vec2 * Fac1 + Vec3 * Fac2);
detail::tvec4<T> Inv1 = SignB * (Vec0 * Fac0 - Vec2 * Fac3 + Vec3 * Fac4);
detail::tvec4<T> Inv2 = SignA * (Vec0 * Fac1 - Vec1 * Fac3 + Vec3 * Fac5);
detail::tvec4<T> Inv3 = SignB * (Vec0 * Fac2 - Vec1 * Fac4 + Vec2 * Fac5);
detail::tmat4x4<valType> Inverse(Inv0, Inv1, Inv2, Inv3);
detail::tmat4x4<T> Inverse(Inv0, Inv1, Inv2, Inv3);
detail::tvec4<valType> Row0(Inverse[0][0], Inverse[1][0], Inverse[2][0], Inverse[3][0]);
detail::tvec4<T> Row0(Inverse[0][0], Inverse[1][0], Inverse[2][0], Inverse[3][0]);
valType Determinant = glm::dot(m[0], Row0);
T Determinant = glm::dot(m[0], Row0);
Inverse /= Determinant;

4
glm/core/func_noise.hpp
View File

@ -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

212
glm/core/func_noise.inl
View File

@ -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>
inline typename detail::tvec2<valType>::value_type noise1
template <typename T>
inline typename detail::tvec2<T>::value_type noise1
(
detail::tvec2<valType> const & x
detail::tvec2<T> const & x
)
{
valType tmp(0);
for(typename detail::tvec2<valType>::size_type i = 0; i < detail::tvec2<valType>::value_size(); ++i)
T tmp(0);
for(typename detail::tvec2<T>::size_type i = 0; i < detail::tvec2<T>::value_size(); ++i)
tmp += x[i];
return noise1(tmp);
}
template <typename valType>
inline typename detail::tvec3<valType>::value_type noise1
template <typename T>
inline typename detail::tvec3<T>::value_type noise1
(
detail::tvec3<valType> const & x
detail::tvec3<T> const & x
)
{
valType tmp(0);
for(typename detail::tvec3<valType>::size_type i = 0; i < detail::tvec3<valType>::value_size(); ++i)
T tmp(0);
for(typename detail::tvec3<T>::size_type i = 0; i < detail::tvec3<T>::value_size(); ++i)
tmp += x[i];
return noise1(tmp);
}
template <typename valType>
inline typename detail::tvec4<valType>::value_type noise1
template <typename T>
inline typename detail::tvec4<T>::value_type noise1
(
detail::tvec4<valType> const & x
detail::tvec4<T> const & x
)
{
valType tmp(0);
for(typename detail::tvec4<valType>::size_type i = 0; i < detail::tvec4<valType>::value_size(); ++i)
T tmp(0);
for(typename detail::tvec4<T>::size_type i = 0; i < detail::tvec4<T>::value_size(); ++i)
tmp += x[i];
return noise1(tmp);
}
@ -78,59 +78,59 @@ namespace glm
noise1(f2));
}
template <typename valType>
inline detail::tvec2<valType> noise2
template <typename T>
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);
for(typename detail::tvec2<valType>::size_type i = 0; i < detail::tvec2<valType>::value_size(); ++i)
T f0(0);
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);
valType f2 = f1 * valType(1103515245) + valType(12345);
return detail::tvec2<valType>(
T f1 = f0 * T(1103515245) + T(12345);
T f2 = f1 * T(1103515245) + T(12345);
return detail::tvec2<T>(
noise1(f1),
noise1(f2));
}
template <typename valType>
inline detail::tvec2<valType> noise2
template <typename T>
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);
for(typename detail::tvec3<valType>::size_type i = 0; i < detail::tvec3<valType>::value_size(); ++i)
T f0(0);
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);
valType f2 = f1 * valType(1103515245) + valType(12345);
return detail::tvec2<valType>(
T f1 = f0 * T(1103515245) + T(12345);
T f2 = f1 * T(1103515245) + T(12345);
return detail::tvec2<T>(
noise1(f1),
noise1(f2));
}
template <typename valType>
inline detail::tvec2<valType> noise2
template <typename T>
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);
for(typename detail::tvec4<valType>::size_type i = 0; i < detail::tvec4<valType>::value_size(); ++i)
T f0(0);
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);
valType f2 = f1 * valType(1103515245) + valType(12345);
return detail::tvec2<valType>(
T f1 = f0 * T(1103515245) + T(12345);
T f2 = f1 * T(1103515245) + T(12345);
return detail::tvec2<T>(
noise1(f1),
noise1(f2));
}
@ -153,61 +153,61 @@ namespace glm
noise1(f3));
}
template <typename valType>
inline detail::tvec3<valType> noise3
template <typename T>
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);
for(typename detail::tvec2<valType>::size_type i = 0; i < detail::tvec2<valType>::value_size(); ++i)
T f0(0);
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);
valType f2 = f1 * valType(1103515245) + valType(12345);
valType f3 = f2 * valType(1103515245) + valType(12345);
return detail::tvec3<valType>(
T f1 = f0 * T(1103515245) + T(12345);
T f2 = f1 * T(1103515245) + T(12345);
T f3 = f2 * T(1103515245) + T(12345);
return detail::tvec3<T>(
noise1(f1),
noise1(f2),
noise1(f3));
}
template <typename valType>
inline detail::tvec3<valType> noise3
template <typename T>
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);
for(typename detail::tvec3<valType>::size_type i = 0; i < detail::tvec3<valType>::value_size(); ++i)
T f0(0);
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);
valType f2 = f1 * valType(1103515245) + valType(12345);
valType f3 = f2 * valType(1103515245) + valType(12345);
return detail::tvec3<valType>(
T f1 = f0 * T(1103515245) + T(12345);
T f2 = f1 * T(1103515245) + T(12345);
T f3 = f2 * T(1103515245) + T(12345);
return detail::tvec3<T>(
noise1(f1),
noise1(f2),
noise1(f3));
}
template <typename valType>
inline detail::tvec3<valType> noise3
template <typename T>
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);
for(typename detail::tvec4<valType>::size_type i = 0; i < detail::tvec4<valType>::value_size(); ++i)
T f0(0);
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);
valType f2 = f1 * valType(1103515245) + valType(12345);
valType f3 = f2 * valType(1103515245) + valType(12345);
return detail::tvec3<valType>(
T f1 = f0 * T(1103515245) + T(12345);
T f2 = f1 * T(1103515245) + T(12345);
T f3 = f2 * T(1103515245) + T(12345);
return detail::tvec3<T>(
noise1(f1),
noise1(f2),
noise1(f3));
@ -233,66 +233,66 @@ namespace glm
noise1(f4));
}
template <typename valType>
inline detail::tvec4<valType> noise4
template <typename T>
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);
for(typename detail::tvec2<valType>::size_type i = 0; i < detail::tvec2<valType>::value_size(); ++i)
T f0(0);
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);
valType f2 = f1 * valType(1103515245) + valType(12345);
valType f3 = f2 * valType(1103515245) + valType(12345);
valType f4 = f3 * valType(1103515245) + valType(12345);
return detail::tvec4<valType>(
T f1 = f0 * T(1103515245) + T(12345);
T f2 = f1 * T(1103515245) + T(12345);
T f3 = f2 * T(1103515245) + T(12345);
T f4 = f3 * T(1103515245) + T(12345);
return detail::tvec4<T>(
noise1(f1),
noise1(f2),
noise1(f3),
noise1(f4));
}
template <typename valType>
inline detail::tvec4<valType> noise4
template <typename T>
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);
for(typename detail::tvec3<valType>::size_type i = 0; i < detail::tvec3<valType>::value_size(); ++i)
T f0(0);
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);
valType f2 = f1 * valType(1103515245) + valType(12345);
valType f3 = f2 * valType(1103515245) + valType(12345);
valType f4 = f3 * valType(1103515245) + valType(12345);
return detail::tvec4<valType>(
T f1 = f0 * T(1103515245) + T(12345);
T f2 = f1 * T(1103515245) + T(12345);
T f3 = f2 * T(1103515245) + T(12345);
T f4 = f3 * T(1103515245) + T(12345);
return detail::tvec4<T>(
noise1(f1),
noise1(f2),
noise1(f3),
noise1(f4));
}
template <typename valType>
inline detail::tvec4<valType> noise4
template <typename T>
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);
for(typename detail::tvec4<valType>::size_type i = 0; i < detail::tvec4<valType>::value_size(); ++i)
T f0(0);
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);
valType f2 = f1 * valType(1103515245) + valType(12345);
valType f3 = f2 * valType(1103515245) + valType(12345);
valType f4 = f3 * valType(1103515245) + valType(12345);
return detail::tvec4<valType>(
T f1 = f0 * T(1103515245) + T(12345);
T f2 = f1 * T(1103515245) + T(12345);
T f3 = f2 * T(1103515245) + T(12345);
T f4 = f3 * T(1103515245) + T(12345);
return detail::tvec4<T>(
noise1(f1),
noise1(f2),
noise1(f3),

45
glm/core/func_packing.hpp Normal file
View File

@ -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

25
glm/core/func_packing.inl Normal file
View File

@ -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

4
glm/core/func_trigonometric.hpp
View File

@ -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

368
glm/core/func_trigonometric.inl
View File

@ -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>
inline detail::tvec2<valType> radians
template <typename T>
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>
inline detail::tvec3<valType> radians
template <typename T>
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>
inline detail::tvec4<valType> radians
template <typename T>
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>
inline detail::tvec2<valType> degrees
template <typename T>
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>
inline detail::tvec3<valType> degrees
template <typename T>
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>
inline detail::tvec4<valType> degrees
template <typename T>
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>
inline detail::tvec2<valType> sin
template <typename T>
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>
inline detail::tvec3<valType> sin
template <typename T>
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>
inline detail::tvec4<valType> sin
template <typename T>
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>
inline detail::tvec2<valType> cos
template <typename T>
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>
inline detail::tvec3<valType> cos
template <typename T>
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>
inline detail::tvec4<valType> cos
template <typename T>
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>
inline detail::tvec2<valType> tan
template <typename T>
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>
inline detail::tvec3<valType> tan
template <typename T>
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>
inline detail::tvec4<valType> tan
template <typename T>
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>
inline detail::tvec2<valType> asin
template <typename T>
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>
inline detail::tvec3<valType> asin
template <typename T>
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>
inline detail::tvec4<valType> asin
template <typename T>
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>
inline detail::tvec2<valType> acos
template <typename T>
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>
inline detail::tvec3<valType> acos
template <typename T>
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>
inline detail::tvec4<valType> acos
template <typename T>
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>
inline detail::tvec2<valType> atan
template <typename T>
inline detail::tvec2<T> atan
(
detail::tvec2<valType> const & y,
detail::tvec2<valType> const & x
detail::tvec2<T> const & y,
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>
inline detail::tvec3<valType> atan
template <typename T>
inline detail::tvec3<T> atan
(
detail::tvec3<valType> const & y,
detail::tvec3<valType> const & x
detail::tvec3<T> const & y,
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>
inline detail::tvec4<valType> atan
template <typename T>
inline detail::tvec4<T> atan
(
detail::tvec4<valType> const & y,
detail::tvec4<valType> const & x
detail::tvec4<T> const & y,
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>
inline detail::tvec2<valType> atan
template <typename T>
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>
inline detail::tvec3<valType> atan
template <typename T>
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>
inline detail::tvec4<valType> atan
template <typename T>
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>
inline detail::tvec2<valType> sinh
template <typename T>
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>
inline detail::tvec3<valType> sinh
template <typename T>
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>
inline detail::tvec4<valType> sinh
template <typename T>
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>
inline detail::tvec2<valType> cosh
template <typename T>
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>
inline detail::tvec3<valType> cosh
template <typename T>
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>
inline detail::tvec4<valType> cosh
template <typename T>
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>
inline detail::tvec2<valType> tanh
template <typename T>
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>
inline detail::tvec3<valType> tanh
template <typename T>
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>
inline detail::tvec4<valType> tanh
template <typename T>
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>
inline detail::tvec2<valType> asinh
template <typename T>
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>
inline detail::tvec3<valType> asinh
template <typename T>
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>
inline detail::tvec4<valType> asinh
template <typename T>
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>
inline detail::tvec2<valType> acosh
template <typename T>
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>
inline detail::tvec3<valType> acosh
template <typename T>
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>
inline detail::tvec4<valType> acosh
template <typename T>
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>
inline detail::tvec2<valType> atanh
template <typename T>
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>
inline detail::tvec3<valType> atanh
template <typename T>
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>
inline detail::tvec4<valType> atanh
template <typename T>
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),

191
glm/core/func_vector_relational.hpp
View File

@ -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.
namespace vector_relational{
//! Define vector relational functions from Section 8.3 of GLSL 1.30.8 specification.
//! Included in glm namespace.
namespace vector_relational
{
//! Returns the component-wise comparison result of x < y.
//! (From GLSL 1.30.08 specification, section 8.6)
template <typename T, template <typename> class vecType>
inline typename vecType<T>::bool_type lessThan
(
vecType<T> const & x,
vecType<T> const & y
)
{
GLM_STATIC_ASSERT(
detail::type<T>::is_float ||
detail::type<T>::is_int ||
detail::type<T>::is_uint);
//! Returns the component-wise compare of x < y.
//! (From GLSL 1.30.08 specification, section 8.6)
template <typename vecType>
typename vecType::bool_type lessThan(vecType const & x, vecType const & 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 compare of x <= y.
//! (From GLSL 1.30.08 specification, section 8.6)
template <typename vecType>
typename vecType::bool_type lessThanEqual(vecType const & x, vecType const & y);
//! Returns the component-wise comparison of result x <= y.
//! (From GLSL 1.30.08 specification, section 8.6)
template <typename T, template <typename> class vecType>
inline typename vecType<T>::bool_type lessThanEqual
(
vecType<T> const & x,
vecType<T> const & y
)
{
GLM_STATIC_ASSERT(
detail::type<T>::is_float ||
detail::type<T>::is_int ||
detail::type<T>::is_uint);
//! Returns the component-wise compare of x > y.
//! (From GLSL 1.30.08 specification, section 8.6)
template <typename vecType>
typename vecType::bool_type greaterThan(vecType const & x, vecType const & 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 compare of x >= y.
//! (From GLSL 1.30.08 specification, section 8.6)
template <typename vecType>
typename vecType::bool_type greaterThanEqual(vecType const & x, vecType const & y);
//! Returns the component-wise comparison of result x > y.
//! (From GLSL 1.30.08 specification, section 8.6)
template <typename T, template <typename> class vecType>
inline typename vecType<T>::bool_type greaterThan
(
vecType<T> const & x,
vecType<T> const & y
)
{
GLM_STATIC_ASSERT(
detail::type<T>::is_float ||
detail::type<T>::is_int ||
detail::type<T>::is_uint);
//! Returns the component-wise compare of x == y.
//! (From GLSL 1.30.08 specification, section 8.6)
template <typename vecType>
typename vecType::bool_type equal(vecType const & x, vecType const & 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 compare of x != y.
//! (From GLSL 1.30.08 specification, section 8.6)
template <typename vecType>
typename vecType::bool_type notEqual(vecType const & x, vecType const & y);
//! Returns the component-wise comparison of result x >= y.
//! (From GLSL 1.30.08 specification, section 8.6)
template <typename T, template <typename> class vecType>
inline typename vecType<T>::bool_type greaterThanEqual
(
vecType<T> const & x,
vecType<T> const & y
)
{
GLM_STATIC_ASSERT(
detail::type<T>::is_float ||
detail::type<T>::is_int ||
detail::type<T>::is_uint);
//! Returns true if any component of x is true.
//! (From GLSL 1.30.08 specification, section 8.6)
template <typename vecType>
bool any(vecType const & x);
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 all components of x are true.
//! (From GLSL 1.30.08 specification, section 8.6)
template <typename vecType>
bool all(vecType const & x);
//! 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);
//! Returns the component-wise logical complement of x.
//! (From GLSL 1.30.08 specification, section 8.6)
template <typename vecType>
typename vecType::bool_type not_(vecType const & x);
typename vecType<bool>::bool_type Result(vecType<bool>::null);
for(typename vecType<bool>::size_type i = 0; i < vecType<bool>::value_size(); ++i)
Result[i] = x[i] == y[i];
return Result;
}
//! Returns the component-wise comparison of result x != y.
//! (From GLSL 1.30.08 specification, section 8.6)
template <typename T, template <typename> class vecType>
inline typename vecType<T>::bool_type notEqual
(
vecType<T> const & x,
vecType<T> const & y
)
{
GLM_STATIC_ASSERT(
detail::type<T>::is_float ||
detail::type<T>::is_int ||
detail::type<T>::is_uint ||
detail::type<T>::is_bool);
typename vecType<bool>::bool_type Result(vecType<bool>::null);
for(typename vecType<bool>::size_type i = 0; i < vecType<bool>::value_size(); ++i)
Result[i] = x[i] != y[i];
return Result;
}
//! Returns true if any component of x is true.
//! (From GLSL 1.30.08 specification, section 8.6)
template <template <typename> class vecType>
inline bool any(vecType<bool> const & v)
{
bool Result = false;
for(typename vecType<bool>::size_type i = 0; i < vecType<bool>::value_size(); ++i)
Result = Result || v[i];
return Result;
}
//! Returns true if all components of x are true.
//! (From GLSL 1.30.08 specification, section 8.6)
template <template <typename> class vecType>
inline bool all(vecType<bool> const & v)
{
bool Result = true;
for(typename vecType<bool>::size_type i = 0; i < vecType<bool>::value_size(); ++i)
Result = Result && v[i];
return Result;
}
//! Returns the component-wise logical complement of x.
//! (From GLSL 1.30.08 specification, section 8.6)
template <template <typename> class vecType>
inline vecType<bool> not_(vecType<bool> const & v)
{
typename vecType<bool>::bool_type Result(vecType<bool>::null);
for(typename vecType<bool>::size_type i = 0; i < vecType<bool>::value_size(); ++i)
Result[i] = !v[i];
return Result;
}
}//namespace vector_relational
}//namespace function

341
glm/core/func_vector_relational.inl
View File

@ -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

4
glm/core/hint.hpp
View File

@ -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

2
glm/core/intrinsic_common.hpp
View File

@ -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

2
glm/core/intrinsic_common.inl
View File

@ -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

34
glm/core/intrinsic_exponential.hpp
View File

@ -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 );
}
*/

2
glm/core/intrinsic_geometric.hpp
View File

@ -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

2
glm/core/intrinsic_geometric.inl
View File

@ -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

2
glm/core/intrinsic_matrix.hpp
View File

@ -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

2
glm/core/intrinsic_matrix.inl
View File

@ -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

2
glm/core/intrinsic_vector_relational.hpp
View File

@ -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

2
glm/core/intrinsic_vector_relational.inl
View File

@ -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

253
glm/core/type.hpp
View File

@ -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

16
glm/core/type_float.hpp
View File

@ -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

186
glm/core/type_gentype.hpp
View File

@ -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,83 +12,139 @@
#include "type_size.hpp"
namespace glm{
enum profile
namespace glm
{
nice,
fast,
simd
};
enum profile
{
nice,
fast,
simd
};
namespace detail{
template <typename valTypeT, uint colT, uint rowT, profile proT = nice>
class genType
namespace detail
{
public:
//////////////////////////////////////
// Traits
template
<
typename VALTYPE,
template <typename> class TYPE
>
struct genType
{
public:
enum ctor{null};
typedef sizeType size_type;
typedef valTypeT value_type;
typedef VALTYPE value_type;
typedef VALTYPE & value_reference;
typedef VALTYPE * value_pointer;
typedef VALTYPE const * value_const_pointer;
typedef TYPE<bool> bool_type;
typedef genType<value_type, colT, rowT> class_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;
typedef genType<bool, colT, rowT> bool_type;
typedef genType<value_type, rowT, 1> col_type;
typedef genType<value_type, colT, 1> row_type;
typedef genType<value_type, rowT, colT> transpose_type;
//////////////////////////////////////
// Address (Implementation details)
static size_type col_size();
static size_type row_size();
static size_type value_size();
static bool is_scalar();
static bool is_vector();
static bool is_matrix();
value_const_pointer value_address() const{return value_pointer(this);}
value_pointer value_address(){return value_pointer(this);}
private:
// Data
col_type value[colT];
//protected:
// enum kind
// {
// GEN_TYPE,
// VEC_TYPE,
// MAT_TYPE
// };
public:
//////////////////////////////////////
// Constructors
genType();
genType(class_type const & m);
// typedef typename TYPE::kind kind;
};
explicit genType(value_type const & x);
explicit genType(value_type const * const x);
explicit genType(col_type const * const x);
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
//////////////////////////////////////
// Conversions
template <typename vU, uint cU, uint rU, profile pU>
explicit genType(genType<vU, cU, rU, pU> const & m);
typedef sizeType size_type;
typedef valTypeT value_type;
//////////////////////////////////////
// Accesses
col_type& operator[](size_type i);
col_type const & operator[](size_type i) const;
typedef base<value_type, colT, rowT> class_type;
//////////////////////////////////////
// Unary updatable operators
class_type& operator= (class_type const & x);
class_type& operator+= (value_type const & x);
class_type& operator+= (class_type const & x);
class_type& operator-= (value_type const & x);
class_type& operator-= (class_type const & x);
class_type& operator*= (value_type const & x);
class_type& operator*= (class_type const & x);
class_type& operator/= (value_type const & x);
class_type& operator/= (class_type const & x);
class_type& operator++ ();
class_type& operator-- ();
};
typedef base<bool, colT, rowT> bool_type;
typedef base<value_type, rowT, 1> col_type;
typedef base<value_type, colT, 1> row_type;
typedef base<value_type, rowT, colT> transpose_type;
}//namespace detail
static size_type col_size();
static size_type row_size();
static size_type value_size();
static bool is_scalar();
static bool is_vector();
static bool is_matrix();
private:
// Data
col_type value[colT];
public:
//////////////////////////////////////
// Constructors
base();
base(class_type const & m);
explicit base(value_type const & x);
explicit base(value_type const * const x);
explicit base(col_type const * const x);
//////////////////////////////////////
// Conversions
template <typename vU, uint cU, uint rU, profile pU>
explicit base(base<vU, cU, rU, pU> const & m);
//////////////////////////////////////
// Accesses
col_type& operator[](size_type i);
col_type const & operator[](size_type i) const;
//////////////////////////////////////
// Unary updatable operators
class_type& operator= (class_type const & x);
class_type& operator+= (value_type const & x);
class_type& operator+= (class_type const & x);
class_type& operator-= (value_type const & x);
class_type& operator-= (class_type const & x);
class_type& operator*= (value_type const & x);
class_type& operator*= (class_type const & x);
class_type& operator/= (value_type const & x);
class_type& operator/= (class_type const & x);
class_type& operator++ ();
class_type& operator-- ();
};
*/
}//namespace detail
}//namespace glm
#include "type_gentype.inl"
//#include "type_gentype.inl"
#endif//glm_core_type_gentype

186
glm/core/type_gentype.inl
View File

@ -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);
i < genType<vT, cT, rT, pT>::col_size();
typename genType<vT, cT, rT, pT>::size_type i = typename base<vT, cT, rT, pT>::size_type(0);
i < base<vT, cT, rT, pT>::col_size();
++i
)
{
@ -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);
i < genType<vT, cT, rT, pT>::col_size();
typename base<vT, cT, rT, pT>::size_type i = typename base<vT, cT, rT, pT>::size_type(0);
i < base<vT, cT, rT, pT>::col_size();
++i
)
{
@ -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);
i < genType<vT, cT, rT, pT>::col_size();
typename base<vT, cT, rT, pT>::size_type i = typename base<vT, cT, rT, pT>::size_type(0);
i < base<vT, cT, rT, pT>::col_size();
++i
)
{
@ -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);
i < genType<vT, cT, rT, pT>::col_size();
typename base<vT, cT, rT, pT>::size_type i = typename base<vT, cT, rT, pT>::size_type(0);
i < base<vT, cT, rT, pT>::col_size();
++i
)
{
this->value[i] = 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 genType<vT, cT, rT, pT>::size_type stop_row = x.row_size();
typename base<vT, cT, rT, pT>::size_type stop_col = x.col_size();
typename base<vT, cT, rT, pT>::size_type stop_row = x.row_size();
for(typename genType<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 j = 0; j < stop_col; ++j)
for(typename base<vT, cT, rT, pT>::size_type i = 0; i < stop_row; ++i)
this->value[j][i] += x;
return *this;
}
template <typename vT, uint cT, uint rT, profile pT>
typename 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 genType<vT, cT, rT, pT>::size_type stop_row = x.row_size();
typename base<vT, cT, rT, pT>::size_type stop_col = x.col_size();
typename base<vT, cT, rT, pT>::size_type stop_row = x.row_size();
for(typename genType<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 j = 0; j < stop_col; ++j)
for(typename base<vT, cT, rT, pT>::size_type i = 0; i < stop_row; ++i)
this->value[j][i] += x[j][i];
return *this;
}
template <typename vT, uint cT, uint rT, profile pT>
typename 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 genType<vT, cT, rT, pT>::size_type stop_row = x.row_size();
typename base<vT, cT, rT, pT>::size_type stop_col = x.col_size();
typename base<vT, cT, rT, pT>::size_type stop_row = x.row_size();
for(typename genType<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 j = 0; j < stop_col; ++j)
for(typename base<vT, cT, rT, pT>::size_type i = 0; i < stop_row; ++i)
this->value[j][i] -= x;
return *this;
}
template <typename vT, uint cT, uint rT, profile pT>
typename 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 genType<vT, cT, rT, pT>::size_type stop_row = x.row_size();
typename base<vT, cT, rT, pT>::size_type stop_col = x.col_size();
typename base<vT, cT, rT, pT>::size_type stop_row = x.row_size();
for(typename genType<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 j = 0; j < stop_col; ++j)
for(typename base<vT, cT, rT, pT>::size_type i = 0; i < stop_row; ++i)
this->value[j][i] -= x[j][i];
return *this;
}
template <typename vT, uint cT, uint rT, profile pT>
typename 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 genType<vT, cT, rT, pT>::size_type stop_row = x.row_size();
typename base<vT, cT, rT, pT>::size_type stop_col = x.col_size();
typename base<vT, cT, rT, pT>::size_type stop_row = x.row_size();
for(typename genType<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 j = 0; j < stop_col; ++j)
for(typename base<vT, cT, rT, pT>::size_type i = 0; i < stop_row; ++i)
this->value[j][i] *= x;
return *this;
}
template <typename vT, uint cT, uint rT, profile pT>
typename 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 genType<vT, cT, rT, pT>::size_type stop_row = x.row_size();
typename base<vT, cT, rT, pT>::size_type stop_col = x.col_size();
typename base<vT, cT, rT, pT>::size_type stop_row = x.row_size();
for(typename genType<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 j = 0; j < stop_col; ++j)
for(typename base<vT, cT, rT, pT>::size_type i = 0; i < stop_row; ++i)
this->value[j][i] *= x[j][i];
return *this;
}
template <typename vT, uint cT, uint rT, profile pT>
typename 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 genType<vT, cT, rT, pT>::size_type stop_row = x.row_size();
typename base<vT, cT, rT, pT>::size_type stop_col = x.col_size();
typename base<vT, cT, rT, pT>::size_type stop_row = x.row_size();
for(typename genType<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 j = 0; j < stop_col; ++j)
for(typename base<vT, cT, rT, pT>::size_type i = 0; i < stop_row; ++i)
this->value[j][i] /= x;
return *this;
}
template <typename vT, uint cT, uint rT, profile pT>
typename 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 genType<vT, cT, rT, pT>::size_type stop_row = x.row_size();
typename base<vT, cT, rT, pT>::size_type stop_col = x.col_size();
typename base<vT, cT, rT, pT>::size_type stop_row = x.row_size();
for(typename genType<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 j = 0; j < stop_col; ++j)
for(typename base<vT, cT, rT, pT>::size_type i = 0; i < stop_row; ++i)
this->value[j][i] /= x[j][i];
return *this;
}
template <typename vT, uint cT, uint rT, profile pT>
typename 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 genType<vT, cT, rT, pT>::size_type stop_row = row_size();
typename base<vT, cT, rT, pT>::size_type stop_col = col_size();
typename base<vT, cT, rT, pT>::size_type stop_row = row_size();
for(typename genType<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 j = 0; j < stop_col; ++j)
for(typename base<vT, cT, rT, pT>::size_type i = 0; i < stop_row; ++i)
++this->value[j][i];
return *this;
}
template <typename vT, uint cT, uint rT, profile pT>
typename 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 genType<vT, cT, rT, pT>::size_type stop_row = row_size();
typename base<vT, cT, rT, pT>::size_type stop_col = col_size();
typename base<vT, cT, rT, pT>::size_type stop_row = row_size();
for(typename genType<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 j = 0; j < stop_col; ++j)
for(typename base<vT, cT, rT, pT>::size_type i = 0; i < stop_row; ++i)
--this->value[j][i];
return *this;

6
glm/core/type_half.hpp
View File

@ -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();

2
glm/core/type_half.inl
View File

@ -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

61
glm/core/type_int.hpp
View File

@ -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 unsigned long highp_uint_t;
typedef signed long long highp_int_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

56
glm/core/type_mat.hpp Normal file
View File

@ -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

0
glm/core/type_mat.inl Normal file
View File

204
glm/core/type_mat2x2.hpp
View File

@ -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:
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;
enum ctor{null};
typedef T value_type;
typedef detail::tvec2<T> col_type;
typedef detail::tvec2<T> row_type;
typedef glm::sizeType size_type;
static size_type value_size();
typedef std::size_t size_type;
typedef tvec2<T> col_type;
typedef tvec2<T> row_type;
static size_type col_size();
static size_type row_size();
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,
const T x2, const T y2);
ctor Null);
explicit tmat2x2(
const detail::tvec2<T> & v1,
const detail::tvec2<T> & v2);
value_type const & x);
explicit tmat2x2(
value_type const & x1, value_type const & y1,
value_type const & x2, value_type const & y2);
explicit tmat2x2(
col_type const & v1,
col_type const & v2);
// Conversions
template <typename U>
explicit tmat2x2(const tmat2x2<U>& m);
explicit tmat2x2(tmat2x2<U> const & m);
explicit tmat2x2(const tmat3x3<T>& x);
explicit tmat2x2(const tmat4x4<T>& x);
explicit tmat2x2(const tmat2x3<T>& x);
explicit tmat2x2(const tmat3x2<T>& x);
explicit tmat2x2(const tmat2x4<T>& x);
explicit tmat2x2(const tmat4x2<T>& x);
explicit tmat2x2(const tmat3x4<T>& x);
explicit tmat2x2(const tmat4x3<T>& x);
explicit tmat2x2(tmat3x3<T> const & x);
explicit tmat2x2(tmat4x4<T> const & x);
explicit tmat2x2(tmat2x3<T> const & x);
explicit tmat2x2(tmat3x2<T> const & x);
explicit tmat2x2(tmat2x4<T> const & x);
explicit tmat2x2(tmat4x2<T> const & x);
explicit tmat2x2(tmat3x4<T> const & x);
explicit tmat2x2(tmat4x3<T> const & x);
//////////////////////////////////////
// Accesses
detail::tvec2<T>& operator[](size_type i);
detail::tvec2<T> const & operator[](size_type i) const;
col_type & operator[](size_type i);
col_type const & operator[](size_type i) const;
// Unary updatable operators
tmat2x2<T>& operator=(tmat2x2<T> const & m);
tmat2x2<T>& operator+=(const T & s);
tmat2x2<T>& operator+=(tmat2x2<T> const & m);
tmat2x2<T>& operator-=(const T & s);
tmat2x2<T>& operator-=(tmat2x2<T> const & m);
tmat2x2<T>& operator*=(const T & s);
tmat2x2<T>& operator*= (tmat2x2<T> const & m);
tmat2x2<T>& operator/= (const T & s);
tmat2x2<T>& operator/= (tmat2x2<T> const & m);
tmat2x2<T>& operator++ ();
tmat2x2<T>& operator-- ();
tmat2x2<T> & operator=(tmat2x2<T> const & m);
template <typename U>
tmat2x2<T> & operator=(tmat2x2<U> const & m);
template <typename U>
tmat2x2<T> & operator+=(U const & s);
template <typename U>
tmat2x2<T> & operator+=(tmat2x2<U> const & m);
template <typename U>
tmat2x2<T> & operator-=(U const & s);
template <typename U>
tmat2x2<T> & operator-=(tmat2x2<U> const & m);
template <typename U>
tmat2x2<T> & operator*=(U const & s);
template <typename U>
tmat2x2<T> & operator*=(tmat2x2<U> const & m);
template <typename U>
tmat2x2<T> & operator/=(U const & s);
template <typename U>
tmat2x2<T> & operator/=(tmat2x2<U> const & m);
tmat2x2<T> & operator++();
tmat2x2<T> & operator--();
};
// Binary operators
template <typename T>
tmat2x2<T> operator+ (tmat2x2<T> const & m, 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>
tmat2x2<valType> const operator- (tmat2x2<valType> const & m);
template <typename T>
tmat2x2<T> const operator- (
tmat2x2<T> const & m);
template <typename valType>
tmat2x2<valType> const operator-- (tmat2x2<valType> const & m, int);
template <typename T>
tmat2x2<T> const operator-- (
tmat2x2<T> const & m,
int);
template <typename valType>
tmat2x2<valType> const operator++ (tmat2x2<valType> const & m, int);
template <typename T>
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

415
glm/core/type_mat2x2.inl
View File

@ -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{
template <typename valType>
typename tmat2x2<valType>::size_type tmat2x2<valType>::value_size()
namespace detail
{
template <typename T>
inline typename tmat2x2<T>::size_type tmat2x2<T>::col_size()
{
return typename tmat2x2<valType>::size_type(2);
return 2;
}
template <typename valType>
typename tmat2x2<valType>::size_type tmat2x2<valType>::col_size()
template <typename T>
inline typename tmat2x2<T>::size_type tmat2x2<T>::row_size()
{
return typename tmat2x2<valType>::size_type(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;
return 2;
}
//////////////////////////////////////
// Accesses
template <typename valType>
detail::tvec2<valType>& tmat2x2<valType>::operator[](typename tmat2x2<valType>::size_type i)
template <typename T>
inline typename tmat2x2<T>::col_type &
tmat2x2<T>::operator[]
(
size_type i
)
{
assert(
i >= typename tmat2x2<valType>::size_type(0) &&
i < tmat2x2<valType>::col_size());
return value[i];
assert(i >= size_type(0) && i < col_size());
return this->value[i];
}
template <typename valType>
const detail::tvec2<valType>& tmat2x2<valType>::operator[](typename tmat2x2<valType>::size_type i) const
template <typename T>
inline typename tmat2x2<T>::col_type const &
tmat2x2<T>::operator[]
(
size_type i
) const
{
assert(
i >= typename tmat2x2<valType>::size_type(0) &&
i < tmat2x2<valType>::col_size());
return value[i];
assert(i >= size_type(0) && i < col_size());
return this->value[i];
}
//////////////////////////////////////////////////////////////
// mat2 constructors
// Constructors
template <typename T>
inline tmat2x2<T>::tmat2x2()
{
this->value[0] = detail::tvec2<T>(1, 0);
this->value[1] = detail::tvec2<T>(0, 1);
this->value[0] = col_type(1, 0);
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);
this->value[1] = detail::tvec2<T>(0, f);
value_type const Zero(0);
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[1] = detail::tvec2<T>(x1, y1);
this->value[0] = col_type(x0, y0);
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[1] = detail::tvec2<T>(m[1]);
this->value[0] = col_type(m[0]);
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[1] = detail::tvec2<T>(m[1]);
this->value[0] = col_type(m[0]);
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[1] = detail::tvec2<T>(m[1]);
this->value[0] = col_type(m[0]);
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[1] = detail::tvec2<T>(m[1]);
this->value[0] = col_type(m[0]);
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[1] = detail::tvec2<T>(m[1]);
this->value[0] = col_type(m[0]);
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[1] = detail::tvec2<T>(m[1]);
this->value[0] = col_type(m[0]);
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[1] = detail::tvec2<T>(m[1]);
this->value[0] = col_type(m[0]);
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,
- value[1][0] / Determinant,
- value[0][1] / Determinant,
+ value[0][0] / Determinant);
+ this->value[1][1] / Determinant,
- this->value[1][0] / Determinant,
- this->value[0][1] / Determinant,
+ this->value[0][0] / Determinant);
return Inverse;
}
@ -189,7 +219,22 @@ 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];
return *this;
}
template <typename T>
template <typename U>
inline tmat2x2<T>& tmat2x2<T>::operator=
(
tmat2x2<U> const & m
)
{
this->value[0] = m[0];
this->value[1] = m[1];
@ -197,7 +242,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;
@ -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>
inline tmat2x2<valType> const operator-
template <typename T>
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>
inline tmat2x2<valType> const operator++
template <typename T>
inline tmat2x2<T> const operator++
(
tmat2x2<valType> const & m,
tmat2x2<T> const & m,
int
)
{
return tmat2x2<valType>(
m[0] + valType(1),
m[1] + valType(1));
return tmat2x2<T>(
m[0] + T(1),
m[1] + T(1));
}
template <typename valType>
inline tmat2x2<valType> const operator--
template <typename T>
inline tmat2x2<T> const operator--
(
tmat2x2<valType> const & m,
tmat2x2<T> const & m,
int
)
{
return tmat2x2<valType>(
m[0] - valType(1),
m[1] - valType(1));
return tmat2x2<T>(
m[0] - T(1),
m[1] - T(1));
}
} //namespace detail

190
glm/core/type_mat2x3.hpp
View File

@ -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:
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;
enum ctor{null};
typedef T value_type;
typedef detail::tvec3<T> col_type;
typedef detail::tvec2<T> row_type;
typedef glm::sizeType size_type;
typedef std::size_t size_type;
typedef tvec3<T> col_type;
typedef tvec2<T> row_type;
static size_type col_size();
static size_type row_size();
static bool is_matrix();
public:
tmat3x2<T> _inverse() const;
typedef tmat2x3<T> type;
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,
const T x1, const T y1, const T z1);
ctor);
explicit tmat2x3(
const detail::tvec3<T>& v0,
const detail::tvec3<T>& v1);
value_type const & s);
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(const tmat3x3<T>& x);
explicit tmat2x3(const tmat4x4<T>& x);
explicit tmat2x3(const tmat2x4<T>& x);
explicit tmat2x3(const tmat3x2<T>& x);
explicit tmat2x3(const tmat3x4<T>& x);
explicit tmat2x3(const tmat4x2<T>& x);
explicit tmat2x3(const tmat4x3<T>& x);
explicit tmat2x3(tmat2x2<T> const & x);
explicit tmat2x3(tmat3x3<T> const & x);
explicit tmat2x3(tmat4x4<T> const & x);
explicit tmat2x3(tmat2x4<T> const & x);
explicit tmat2x3(tmat3x2<T> const & x);
explicit tmat2x3(tmat3x4<T> const & x);
explicit tmat2x3(tmat4x2<T> const & x);
explicit tmat2x3(tmat4x3<T> const & x);
// Accesses
detail::tvec3<T>& operator[](size_type i);
detail::tvec3<T> const & operator[](size_type i) const;
col_type & operator[](size_type i);
col_type const & operator[](size_type i) const;
// Unary updatable operators
tmat2x3<T>& operator= (const tmat2x3<T>& m);
tmat2x3<T>& operator+= (const T & s);
tmat2x3<T>& operator+= (const tmat2x3<T>& m);
tmat2x3<T>& operator-= (const T & s);
tmat2x3<T>& operator-= (const tmat2x3<T>& m);
tmat2x3<T>& operator*= (const T & s);
tmat2x3<T>& operator*= (const tmat3x2<T>& m);
tmat2x3<T>& operator/= (const T & s);
// tmat2x3<T>& operator/= (const tmat3x2<T>& m);
tmat2x3<T> & operator= (tmat2x3<T> const & m);
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);
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-- ();
// Unary constant operators
const tmat2x3<T> operator- () const;
const tmat2x3<T> operator++ (int n) const;
const tmat2x3<T> operator-- (int n) const;
tmat2x3<T> & operator++ ();
tmat2x3<T> & operator-- ();
};
// 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);
//template <typename T>
//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);
tmat3x2<T> operator/ (
typename tmat2x3<T>::value_type const & s,
tmat2x3<T> const & m);
// Unary constant operators
template <typename valType>
tmat2x3<valType> const operator- (tmat2x3<valType> const & m);
template <typename T>
tmat2x3<T> const operator- (
tmat2x3<T> const & m);
template <typename valType>
tmat2x3<valType> const operator-- (tmat2x3<valType> const & m, int);
template <typename T>
tmat2x3<T> const operator-- (
tmat2x3<T> const & m,
int);
template <typename valType>
tmat2x3<valType> const operator++ (tmat2x3<valType> const & m, int);
template <typename T>
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

452
glm/core/type_mat2x3.inl
View File

@ -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{
template <typename valType>
typename tmat2x3<valType>::size_type tmat2x3<valType>::col_size()
namespace detail
{
template <typename T>
inline typename tmat2x3<T>::size_type tmat2x3<T>::col_size()
{
return typename tmat2x3<valType>::size_type(2);
return 3;
}
template <typename valType>
typename tmat2x3<valType>::size_type tmat2x3<valType>::row_size()
template <typename T>
inline typename tmat2x3<T>::size_type tmat2x3<T>::row_size()
{
return typename tmat2x3<valType>::size_type(3);
}
template <typename valType>
bool tmat2x3<valType>::is_matrix()
{
return true;
return 2;
}
//////////////////////////////////////
// Accesses
template <typename valType>
detail::tvec3<valType>& tmat2x3<valType>::operator[](typename tmat2x3<valType>::size_type i)
template <typename T>
inline typename tmat2x3<T>::col_type &
tmat2x3<T>::operator[]
(
size_type i
)
{
assert(
i >= typename tmat2x3<valType>::size_type(0) &&
i < tmat2x3<valType>::col_size());
return value[i];
assert(i >= size_type(0) && i < col_size());
return this->value[i];
}
template <typename valType>
const detail::tvec3<valType>& tmat2x3<valType>::operator[](typename tmat2x3<valType>::size_type i) const
template <typename T>
inline typename tmat2x3<T>::col_type const &
tmat2x3<T>::operator[]
(
size_type i
) const
{
assert(
i >= typename tmat2x3<valType>::size_type(0) &&
i < tmat2x3<valType>::col_size());
return value[i];
assert(i >= size_type(0) && i < col_size());
return this->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[1] = detail::tvec3<T>(T(0), T(1), T(0));
this->value[0] = col_type(T(1), T(0), T(0));
this->value[1] = col_type(T(0), T(1), T(0));
}
template <typename T>
inline tmat2x3<T>::tmat2x3(const T f)
inline tmat2x3<T>::tmat2x3
(
tmat2x3<T> const & m
)
{
this->value[0] = detail::tvec3<T>(f, T(0), T(0));
this->value[1] = detail::tvec3<T>(T(0), f, T(0));
this->value[0] = m.value[0];
this->value[1] = m.value[1];
}
template <typename T>
inline tmat2x3<T>::tmat2x3
(
ctor
)
{}
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
(
const T x0, const T y0, const T z0,
const T x1, const T y1, const T z1
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] = detail::tvec3<T>(x0, y0, z0);
this->value[1] = detail::tvec3<T>(x1, y1, z1);
this->value[0] = col_type(x0, y0, z0);
this->value[1] = col_type(x1, y1, z1);
}
template <typename T>
inline tmat2x3<T>::tmat2x3
(
const detail::tvec3<T> & v0,
const detail::tvec3<T> & v1
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[1] = detail::tvec3<T>(m[1]);
this->value[0] = col_type(m[0]);
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[1] = detail::tvec3<T>(m[1], T(0));
this->value[0] = col_type(m[0], 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[1] = detail::tvec3<T>(m[1]);
this->value[0] = col_type(m[0]);
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[1] = detail::tvec3<T>(m[1]);
this->value[0] = col_type(m[0]);
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[1] = detail::tvec3<T>(m[1]);
this->value[0] = col_type(m[0]);
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[1] = detail::tvec3<T>(m[1], T(0));
this->value[0] = col_type(m[0], 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[1] = detail::tvec3<T>(m[1]);
this->value[0] = col_type(m[0]);
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[1] = detail::tvec3<T>(m[1], T(0));
this->value[0] = col_type(m[0], 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 T>
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)
{
return (*this = tmat2x3<T>(*this / m));
}
*/
template <typename T>
inline tmat2x3<T>& tmat2x3<T>::operator++ ()
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,37 +424,45 @@ 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];
const T SrcA01 = m1[0][1];
const T SrcA02 = m1[0][2];
const T SrcA10 = m1[1][0];
const T SrcA11 = m1[1][1];
const T SrcA12 = m1[1][2];
typename tmat2x3<T>::value_type SrcA00 = m1[0][0];
typename tmat2x3<T>::value_type SrcA01 = m1[0][1];
typename tmat2x3<T>::value_type SrcA02 = m1[0][2];
typename tmat2x3<T>::value_type SrcA10 = m1[1][0];
typename tmat2x3<T>::value_type SrcA11 = m1[1][1];
typename tmat2x3<T>::value_type SrcA12 = m1[1][2];
const T SrcB00 = m2[0][0];
const T SrcB01 = m2[0][1];
const T SrcB10 = m2[1][0];
const T SrcB11 = m2[1][1];
const T SrcB20 = m2[2][0];
const T SrcB21 = m2[2][1];
typename tmat2x3<T>::value_type SrcB00 = m2[0][0];
typename tmat2x3<T>::value_type SrcB01 = m2[0][1];
typename tmat2x3<T>::value_type SrcB10 = m2[1][0];
typename tmat2x3<T>::value_type SrcB11 = m2[1][1];
typename tmat2x3<T>::value_type SrcB20 = m2[2][0];
typename tmat2x3<T>::value_type SrcB21 = m2[2][1];
tmat3x3<T> Result;
Result[0][0] = SrcA00 * SrcB00 + SrcA10 * SrcB01;
Result[0][1] = SrcA01 * SrcB00 + SrcA11 * SrcB01;
Result[0][2] = SrcA02 * SrcB00 + SrcA12 * SrcB01;
Result[1][0] = SrcA00 * SrcB10 + SrcA10 * SrcB11;
Result[1][1] = SrcA01 * SrcB10 + SrcA11 * SrcB11;
Result[1][2] = SrcA02 * SrcB10 + SrcA12 * SrcB11;
Result[2][0] = SrcA00 * SrcB20 + SrcA10 * SrcB21;
Result[2][1] = SrcA01 * SrcB20 + SrcA11 * SrcB21;
Result[2][2] = SrcA02 * SrcB20 + SrcA12 * SrcB21;
return 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;
Result[1][0] = SrcA00 * SrcB10 + SrcA10 * SrcB11;
Result[1][1] = SrcA01 * SrcB10 + SrcA11 * SrcB11;
Result[1][2] = SrcA02 * SrcB10 + SrcA12 * SrcB11;
Result[2][0] = SrcA00 * SrcB20 + SrcA10 * SrcB21;
Result[2][1] = SrcA01 * SrcB20 + SrcA11 * SrcB21;
Result[2][2] = SrcA02 * SrcB20 + SrcA12 * SrcB21;
return Result;
}
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>
inline tmat2x3<valType> const operator-
template <typename T>
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>
inline tmat2x3<valType> const operator++
template <typename T>
inline tmat2x3<T> const operator++
(
tmat2x3<valType> const & m,
tmat2x3<T> const & m,
int
)
{
return tmat2x3<valType>(
m[0] + valType(1),
m[1] + valType(1));
return tmat2x3<T>(
m[0] + typename tmat2x3<T>::value_type(1),
m[1] + typename tmat2x3<T>::value_type(1));
}
template <typename valType>
inline tmat2x3<valType> const operator--
template <typename T>
inline tmat2x3<T> const operator--
(
tmat2x3<valType> const & m,
tmat2x3<T> const & m,
int
)
{
return tmat2x3<valType>(
m[0] - valType(1),
m[1] - valType(1));
return tmat2x3<T>(
m[0] - typename tmat2x3<T>::value_type(1),
m[1] - typename tmat2x3<T>::value_type(1));
}
} //namespace detail

182
glm/core/type_mat2x4.hpp
View File

@ -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:
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;
enum ctor{null};
typedef T value_type;
typedef detail::tvec2<T> col_type;
typedef detail::tvec4<T> row_type;
typedef glm::sizeType size_type;
typedef std::size_t size_type;
typedef tvec4<T> col_type;
typedef tvec2<T> row_type;
static size_type col_size();
static size_type row_size();
static bool is_matrix();
public:
tmat4x2<T> _inverse() const;
typedef tmat2x4<T> type;
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,
const T x1, const T y1, const T z1, const T w1);
ctor Null);
explicit tmat2x4(
const detail::tvec4<T>& v0,
const detail::tvec4<T>& v1);
value_type const & s);
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(const tmat3x3<T>& x);
explicit tmat2x4(const tmat4x4<T>& x);
explicit tmat2x4(const tmat2x3<T>& x);
//explicit tmat2x4(const tmat2x4<T>& x);
explicit tmat2x4(const tmat3x2<T>& x);
explicit tmat2x4(const tmat3x4<T>& x);
explicit tmat2x4(const tmat4x2<T>& x);
explicit tmat2x4(const tmat4x3<T>& x);
explicit tmat2x4(tmat2x2<T> const & x);
explicit tmat2x4(tmat3x3<T> const & x);
explicit tmat2x4(tmat4x4<T> const & x);
explicit tmat2x4(tmat2x3<T> const & x);
explicit tmat2x4(tmat3x2<T> const & x);
explicit tmat2x4(tmat3x4<T> const & x);
explicit tmat2x4(tmat4x2<T> const & x);
explicit tmat2x4(tmat4x3<T> const & x);
// Accesses
detail::tvec4<T>& operator[](size_type i);
detail::tvec4<T> const & operator[](size_type i) const;
col_type & operator[](size_type i);
col_type const & operator[](size_type i) const;
// Unary updatable operators
tmat2x4<T>& operator= (const tmat2x4<T>& m);
tmat2x4<T>& operator+= (const T & s);
tmat2x4<T>& operator+= (const tmat2x4<T>& m);
tmat2x4<T>& operator-= (const T & s);
tmat2x4<T>& operator-= (const tmat2x4<T>& m);
tmat2x4<T>& operator*= (const T & s);
tmat2x4<T>& operator*= (const tmat4x2<T>& m);
tmat2x4<T>& operator/= (const T & s);
//tmat2x4<T>& operator/= (const tmat4x2<T>& m);
tmat2x4<T>& operator= (tmat2x4<T> const & m);
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);
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);
//template <typename T>
//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);
tmat2x4<T> operator/ (
typename tmat2x4<T>::value_type const & s,
tmat2x4<T> const & m);
// Unary constant operators
template <typename valType>
tmat2x4<valType> const operator- (tmat2x4<valType> const & m);
template <typename T>
tmat2x4<T> const operator- (
tmat2x4<T> const & m);
template <typename valType>
tmat2x4<valType> const operator-- (tmat2x4<valType> const & m, int);
template <typename T>
tmat2x4<T> const operator-- (
tmat2x4<T> const & m,
int);
template <typename valType>
tmat2x4<valType> const operator++ (tmat2x4<valType> const & m, int);
template <typename T>
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

453
glm/core/type_mat2x4.inl
View File

@ -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{
template <typename valType>
typename tmat2x4<valType>::size_type tmat2x4<valType>::col_size()
namespace detail
{
template <typename T>
inline typename tmat2x4<T>::size_type tmat2x4<T>::col_size()
{
return typename tmat2x4<valType>::size_type(2);
return 4;
}
template <typename valType>
typename tmat2x4<valType>::size_type tmat2x4<valType>::row_size()
template <typename T>
inline typename tmat2x4<T>::size_type tmat2x4<T>::row_size()
{
return typename tmat2x4<valType>::size_type(4);
}
template <typename valType>
bool tmat2x4<valType>::is_matrix()
{
return true;
return 2;
}
//////////////////////////////////////
// Accesses
template <typename valType>
detail::tvec4<valType>& tmat2x4<valType>::operator[](typename tmat2x4<valType>::size_type i)
template <typename T>
inline typename tmat2x4<T>::col_type &
tmat2x4<T>::operator[]
(
size_type i
)
{
assert(
i >= typename tmat2x4<valType>::size_type(0) &&
i < tmat2x4<valType>::col_size());
return value[i];
assert(i >= size_type(0) && i < col_size());
return this->value[i];
}
template <typename valType>
const detail::tvec4<valType>& tmat2x4<valType>::operator[](typename tmat2x4<valType>::size_type i) const
template <typename T>
inline typename tmat2x4<T>::col_type const &
tmat2x4<T>::operator[]
(
size_type i
) const
{
assert(
i >= typename tmat2x4<valType>::size_type(0) &&
i < tmat2x4<valType>::col_size());
return value[i];
assert(i >= size_type(0) && i < col_size());
return this->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);
this->value[1] = detail::tvec4<T>(0, 1, 0, 0);
value_type const Zero(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)
inline tmat2x4<T>::tmat2x4
(
tmat2x4<T> const & m
)
{
this->value[0] = detail::tvec4<T>(f, 0, 0, 0);
this->value[1] = detail::tvec4<T>(0, f, 0, 0);
this->value[0] = m.value[0];
this->value[1] = m.value[1];
}
template <typename T>
inline tmat2x4<T>::tmat2x4
(
ctor
)
{}
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
(
const T x0, const T y0, const T z0, const T w0,
const T x1, const T y1, const T z1, const T w1
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] = detail::tvec4<T>(x0, y0, z0, w0);
this->value[1] = detail::tvec4<T>(x1, y1, z1, 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
(
const detail::tvec4<T> & v0,
const detail::tvec4<T> & v1
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[1] = detail::tvec4<T>(m[1]);
this->value[0] = col_type(m[0]);
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[1] = detail::tvec4<T>(m[1], detail::tvec2<T>(0));
this->value[0] = col_type(m[0], 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[1] = detail::tvec4<T>(m[1], T(0));
this->value[0] = col_type(m[0], 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[1] = detail::tvec4<T>(m[1]);
this->value[0] = col_type(m[0]);
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[1] = detail::tvec4<T>(m[1], T(0));
this->value[0] = col_type(m[0], 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[1] = detail::tvec4<T>(m[1], detail::tvec2<T>(0));
this->value[0] = col_type(m[0], 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[1] = detail::tvec4<T>(m[1], detail::tvec2<T>(T(0)));
this->value[0] = col_type(m[0], 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[1] = detail::tvec4<T>(m[1], T(0));
this->value[0] = col_type(m[0], 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,56 +415,68 @@ 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];
const T SrcA01 = m1[0][1];
const T SrcA02 = m1[0][2];
const T SrcA03 = m1[0][3];
const T SrcA10 = m1[1][0];
const T SrcA11 = m1[1][1];
const T SrcA12 = m1[1][2];
const T SrcA13 = m1[1][3];
typename tmat2x4<T>::value_type SrcA00 = m1[0][0];
typename tmat2x4<T>::value_type SrcA01 = m1[0][1];
typename tmat2x4<T>::value_type SrcA02 = m1[0][2];
typename tmat2x4<T>::value_type SrcA03 = m1[0][3];
typename tmat2x4<T>::value_type SrcA10 = m1[1][0];
typename tmat2x4<T>::value_type SrcA11 = m1[1][1];
typename tmat2x4<T>::value_type SrcA12 = m1[1][2];
typename tmat2x4<T>::value_type SrcA13 = m1[1][3];
const T SrcB00 = m2[0][0];
const T SrcB01 = m2[0][1];
const T SrcB10 = m2[1][0];
const T SrcB11 = m2[1][1];
const T SrcB20 = m2[2][0];
const T SrcB21 = m2[2][1];
const T SrcB30 = m2[3][0];
const T SrcB31 = m2[3][1];
typename tmat2x4<T>::value_type SrcB00 = m2[0][0];
typename tmat2x4<T>::value_type SrcB01 = m2[0][1];
typename tmat2x4<T>::value_type SrcB10 = m2[1][0];
typename tmat2x4<T>::value_type SrcB11 = m2[1][1];
typename tmat2x4<T>::value_type SrcB20 = m2[2][0];
typename tmat2x4<T>::value_type SrcB21 = m2[2][1];
typename tmat2x4<T>::value_type SrcB30 = m2[3][0];
typename tmat2x4<T>::value_type SrcB31 = m2[3][1];
tmat4x4<T> Result;
Result[0][0] = SrcA00 * SrcB00 + SrcA10 * SrcB01;
Result[0][1] = SrcA01 * SrcB00 + SrcA11 * SrcB01;
Result[0][2] = SrcA02 * SrcB00 + SrcA12 * SrcB01;
Result[0][3] = SrcA03 * SrcB00 + SrcA13 * SrcB01;
Result[1][0] = SrcA00 * SrcB10 + SrcA10 * SrcB11;
Result[1][1] = SrcA01 * SrcB10 + SrcA11 * SrcB11;
Result[1][2] = SrcA02 * SrcB10 + SrcA12 * SrcB11;
Result[1][3] = SrcA03 * SrcB10 + SrcA13 * SrcB11;
Result[2][0] = SrcA00 * SrcB20 + SrcA10 * SrcB21;
Result[2][1] = SrcA01 * SrcB20 + SrcA11 * SrcB21;
Result[2][2] = SrcA02 * SrcB20 + SrcA12 * SrcB21;
Result[2][3] = SrcA03 * SrcB20 + SrcA13 * SrcB21;
Result[3][0] = SrcA00 * SrcB30 + SrcA10 * SrcB31;
Result[3][1] = SrcA01 * SrcB30 + SrcA11 * SrcB31;
Result[3][2] = SrcA02 * SrcB30 + SrcA12 * SrcB31;
Result[3][3] = SrcA03 * SrcB30 + SrcA13 * SrcB31;
return 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;
Result[0][3] = SrcA03 * SrcB00 + SrcA13 * SrcB01;
Result[1][0] = SrcA00 * SrcB10 + SrcA10 * SrcB11;
Result[1][1] = SrcA01 * SrcB10 + SrcA11 * SrcB11;
Result[1][2] = SrcA02 * SrcB10 + SrcA12 * SrcB11;
Result[1][3] = SrcA03 * SrcB10 + SrcA13 * SrcB11;
Result[2][0] = SrcA00 * SrcB20 + SrcA10 * SrcB21;
Result[2][1] = SrcA01 * SrcB20 + SrcA11 * SrcB21;
Result[2][2] = SrcA02 * SrcB20 + SrcA12 * SrcB21;
Result[2][3] = SrcA03 * SrcB20 + SrcA13 * SrcB21;
Result[3][0] = SrcA00 * SrcB30 + SrcA10 * SrcB31;
Result[3][1] = SrcA01 * SrcB30 + SrcA11 * SrcB31;
Result[3][2] = SrcA02 * SrcB30 + SrcA12 * SrcB31;
Result[3][3] = SrcA03 * SrcB30 + SrcA13 * SrcB31;
return Result;
}
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>
inline tmat2x4<valType> const operator-
template <typename T>
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>
inline tmat2x4<valType> const operator++
template <typename T>
inline tmat2x4<T> const operator++
(
tmat2x4<valType> const & m,
tmat2x4<T> const & m,
int
)
{
return tmat2x4<valType>(
m[0] + valType(1),
m[1] + valType(1));
return tmat2x4<T>(
m[0] + typename tmat2x4<T>::value_type(1),
m[1] + typename tmat2x4<T>::value_type(1));
}
template <typename valType>
inline tmat2x4<valType> const operator--
template <typename T>
inline tmat2x4<T> const operator--
(
tmat2x4<valType> const & m,
tmat2x4<T> const & m,
int
)
{
return tmat2x4<valType>(
m[0] - valType(1),
m[1] - valType(1));
return tmat2x4<T>(
m[0] - typename tmat2x4<T>::value_type(1),
m[1] - typename tmat2x4<T>::value_type(1));
}
} //namespace detail

189
glm/core/type_mat3x2.hpp
View File

@ -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:
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;
enum ctor{null};
typedef T value_type;
typedef detail::tvec3<T> col_type;
typedef detail::tvec2<T> row_type;
typedef glm::sizeType size_type;
typedef std::size_t size_type;
typedef tvec2<T> col_type;
typedef tvec3<T> row_type;
static size_type col_size();
static size_type row_size();
static bool is_matrix();
public:
tmat2x3<T> _inverse() const;
typedef tmat3x2<T> type;
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,
const T x1, const T y1,
const T x2, const T y2);
ctor);
explicit tmat3x2(
const detail::tvec2<T>& v0,
const detail::tvec2<T>& v1,
const detail::tvec2<T>& v2);
value_type const & s);
explicit tmat3x2(
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(const tmat3x3<T>& x);
explicit tmat3x2(const tmat4x4<T>& x);
explicit tmat3x2(const tmat2x3<T>& x);
explicit tmat3x2(const tmat2x4<T>& x);
explicit tmat3x2(const tmat3x4<T>& x);
explicit tmat3x2(const tmat4x2<T>& x);
explicit tmat3x2(const tmat4x3<T>& x);
explicit tmat3x2(tmat2x2<T> const & x);
explicit tmat3x2(tmat3x3<T> const & x);
explicit tmat3x2(tmat4x4<T> const & x);
explicit tmat3x2(tmat2x3<T> const & x);
explicit tmat3x2(tmat2x4<T> const & x);
explicit tmat3x2(tmat3x4<T> const & x);
explicit tmat3x2(tmat4x2<T> const & x);
explicit tmat3x2(tmat4x3<T> const & x);
// Accesses
detail::tvec2<T>& operator[](size_type i);
const detail::tvec2<T>& operator[](size_type i) const;
col_type & operator[](size_type i);
col_type const & operator[](size_type i) const;
// Unary updatable operators
tmat3x2<T>& operator= (const tmat3x2<T>& m);
tmat3x2<T>& operator+= (const T & s);
tmat3x2<T>& operator+= (const tmat3x2<T>& m);
tmat3x2<T>& operator-= (const T & s);
tmat3x2<T>& operator-= (const tmat3x2<T>& m);
tmat3x2<T>& operator*= (const T & s);
tmat3x2<T>& operator*= (const tmat2x3<T>& m);
tmat3x2<T>& operator/= (const T & s);
//tmat3x2<T>& operator/= (const tmat2x3<T>& m);
tmat3x2<T> & operator= (tmat3x2<T> const & m);
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);
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);
//template <typename T>
//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);
tmat3x2<T> operator/ (
typename tmat3x2<T>::value_type const & s,
tmat3x2<T> const & m);
// Unary constant operators
template <typename valType>
tmat3x2<valType> const operator- (tmat3x2<valType> const & m);
template <typename T>
tmat3x2<T> const operator- (
tmat3x2<T> const & m);
template <typename valType>
tmat3x2<valType> const operator-- (tmat3x2<valType> const & m, int);
template <typename T>
tmat3x2<T> const operator-- (
tmat3x2<T> const & m,
int);
template <typename valType>
tmat3x2<valType> const operator++ (tmat3x2<valType> const & m, int);
template <typename T>
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

390
glm/core/type_mat3x2.inl
View File

@ -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{
template <typename valType>
typename tmat3x2<valType>::size_type tmat3x2<valType>::col_size()
namespace detail
{
template <typename T>
inline typename tmat3x2<T>::size_type tmat3x2<T>::col_size()
{
return typename tmat3x2<valType>::size_type(3);
return 2;
}
template <typename valType>
typename tmat3x2<valType>::size_type tmat3x2<valType>::row_size()
template <typename T>
inline typename tmat3x2<T>::size_type tmat3x2<T>::row_size()
{
return typename tmat3x2<valType>::size_type(2);
}
template <typename valType>
bool tmat3x2<valType>::is_matrix()
{
return true;
return 3;
}
//////////////////////////////////////
// Accesses
template <typename valType>
detail::tvec2<valType>& tmat3x2<valType>::operator[](typename tmat3x2<valType>::size_type i)
template <typename T>
inline typename tmat3x2<T>::col_type &
tmat3x2<T>::operator[]
(
size_type i
)
{
assert(
i >= typename tmat3x2<valType>::size_type(0) &&
i < tmat3x2<valType>::col_size());
return value[i];
assert(i >= size_type(0) && i < col_size());
return this->value[i];
}
template <typename valType>
const detail::tvec2<valType>& tmat3x2<valType>::operator[](typename tmat3x2<valType>::size_type i) const
template <typename T>
inline typename tmat3x2<T>::col_type const &
tmat3x2<T>::operator[]
(
size_type i
) const
{
assert(
i >= typename tmat3x2<valType>::size_type(0) &&
i < tmat3x2<valType>::col_size());
return value[i];
assert(i >= size_type(0) && i < col_size());
return this->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[1] = detail::tvec2<T>(0, 1);
this->value[2] = detail::tvec2<T>(0, 0);
this->value[0] = col_type(1, 0);
this->value[1] = col_type(0, 1);
this->value[2] = col_type(0, 0);
}
template <typename T>
inline tmat3x2<T>::tmat3x2(const T f)
inline tmat3x2<T>::tmat3x2
(
value_type const & s
)
{
this->value[0] = detail::tvec2<T>(f, 0);
this->value[1] = detail::tvec2<T>(0, f);
this->value[2] = detail::tvec2<T>(0, 0);
this->value[0] = col_type(s, 0);
this->value[1] = col_type(0, s);
this->value[2] = col_type(0, 0);
}
template <typename T>
inline tmat3x2<T>::tmat3x2
(
const T x0, const T y0,
const T x1, const T y1,
const T x2, const T y2
value_type const & x0, value_type const & y0,
value_type const & x1, value_type const & y1,
value_type const & x2, value_type const & y2
)
{
this->value[0] = detail::tvec2<T>(x0, y0);
this->value[1] = detail::tvec2<T>(x1, y1);
this->value[2] = detail::tvec2<T>(x2, 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
(
const detail::tvec2<T> & v0,
const detail::tvec2<T> & v1,
const detail::tvec2<T> & v2
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[1] = detail::tvec2<T>(m[1]);
this->value[2] = detail::tvec2<T>(m[2]);
this->value[0] = col_type(m[0]);
this->value[1] = col_type(m[1]);
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[1] = detail::tvec2<T>(m[1]);
this->value[2] = detail::tvec2<T>(m[2]);
this->value[0] = col_type(m[0]);
this->value[1] = col_type(m[1]);
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[1] = detail::tvec2<T>(m[1]);
this->value[2] = detail::tvec2<T>(m[2]);
this->value[0] = col_type(m[0]);
this->value[1] = col_type(m[1]);
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[1] = detail::tvec2<T>(m[1]);
this->value[2] = detail::tvec2<T>(T(0));
this->value[0] = col_type(m[0]);
this->value[1] = col_type(m[1]);
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[1] = detail::tvec2<T>(m[1]);
this->value[2] = detail::tvec2<T>(T(0));
this->value[0] = col_type(m[0]);
this->value[1] = col_type(m[1]);
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[1] = detail::tvec2<T>(m[1]);
this->value[2] = detail::tvec2<T>(m[2]);
this->value[0] = col_type(m[0]);
this->value[1] = col_type(m[1]);
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[1] = detail::tvec2<T>(m[1]);
this->value[2] = detail::tvec2<T>(m[2]);
this->value[0] = col_type(m[0]);
this->value[1] = col_type(m[1]);
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>
inline tmat3x2<valType> const operator-
template <typename T>
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>
inline tmat3x2<valType> const operator++
template <typename T>
inline tmat3x2<T> const operator++
(
tmat3x2<valType> const & m,
tmat3x2<T> const & m,
int
)
{
return tmat3x2<valType>(
m[0] + valType(1),
m[1] + valType(1),
m[2] + valType(1));
typename tmat3x2<T>::value_type One(1);
return tmat3x2<T>(
m[0] + One,
m[1] + One,
m[2] + One);
}
template <typename valType>
inline tmat3x2<valType> const operator--
template <typename T>
inline tmat3x2<T> const operator--
(
tmat3x2<valType> const & m,
tmat3x2<T> const & m,
int
)
{
return tmat3x2<valType>(
m[0] - valType(1),
m[1] - valType(1),
m[2] - valType(1));
typename tmat3x2<T>::value_type One(1);
return tmat3x2<T>(
m[0] - One,
m[1] - One,
m[2] - One);
}
} //namespace detail

203
glm/core/type_mat3x3.hpp
View File

@ -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:
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;
enum ctor{null};
typedef T value_type;
typedef detail::tvec3<T> col_type;
typedef detail::tvec3<T> row_type;
typedef glm::sizeType size_type;
static size_type value_size();
typedef std::size_t size_type;
typedef tvec3<T> col_type;
typedef tvec3<T> row_type;
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,
const T x1, const T y1, const T z1,
const T x2, const T y2, const T z2);
ctor Null);
explicit tmat3x3(
const detail::tvec3<T> & v0,
const detail::tvec3<T> & v1,
const detail::tvec3<T> & v2);
value_type const & s);
explicit 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);
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(const tmat4x4<T>& x);
explicit tmat3x3(const tmat2x3<T>& x);
explicit tmat3x3(const tmat3x2<T>& x);
explicit tmat3x3(const tmat2x4<T>& x);
explicit tmat3x3(const tmat4x2<T>& x);
explicit tmat3x3(const tmat3x4<T>& x);
explicit tmat3x3(const tmat4x3<T>& x);
explicit tmat3x3(tmat2x2<T> const & x);
explicit tmat3x3(tmat4x4<T> const & x);
explicit tmat3x3(tmat2x3<T> const & x);
explicit tmat3x3(tmat3x2<T> const & x);
explicit tmat3x3(tmat2x4<T> const & x);
explicit tmat3x3(tmat4x2<T> const & x);
explicit tmat3x3(tmat3x4<T> const & x);
explicit tmat3x3(tmat4x3<T> const & x);
// Accesses
detail::tvec3<T>& operator[](size_type i);
detail::tvec3<T> const & operator[](size_type i) const;
col_type & operator[](size_type i);
col_type const & operator[](size_type i) const;
// Unary updatable operators
tmat3x3<T>& operator=(const tmat3x3<T>& m);
tmat3x3<T>& operator+= (const T & s);
tmat3x3<T>& operator+= (const tmat3x3<T>& m);
tmat3x3<T>& operator-= (const T & s);
tmat3x3<T>& operator-= (const tmat3x3<T>& m);
tmat3x3<T>& operator*= (const T & s);
tmat3x3<T>& operator*= (const tmat3x3<T>& m);
tmat3x3<T>& operator/= (const T & s);
tmat3x3<T>& operator/= (const tmat3x3<T>& m);
tmat3x3<T>& operator= (tmat3x3<T> const & m);
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);
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>
tmat3x3<valType> const operator- (tmat3x3<valType> const & m);
template <typename T>
tmat3x3<T> const operator- (
tmat3x3<T> const & m);
template <typename valType>
tmat3x3<valType> const operator-- (tmat3x3<valType> const & m, int);
template <typename T>
tmat3x3<T> const operator-- (
tmat3x3<T> const & m,
int);
template <typename valType>
tmat3x3<valType> const operator++ (tmat3x3<valType> const & m, int);
template <typename T>
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

542
glm/core/type_mat3x3.inl
View File

@ -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{
template <typename valType>
typename tmat3x3<valType>::size_type tmat3x3<valType>::value_size()
namespace detail
{
template <typename T>
inline typename tmat3x3<T>::size_type tmat3x3<T>::col_size()
{
return typename tmat3x3<valType>::size_type(3);
return 3;
}
template <typename valType>
typename tmat3x3<valType>::size_type tmat3x3<valType>::col_size()
template <typename T>
inline typename tmat3x3<T>::size_type tmat3x3<T>::row_size()
{
return typename tmat3x3<valType>::size_type(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;
return 3;
}
//////////////////////////////////////
// Accesses
template <typename valType>
detail::tvec3<valType>& tmat3x3<valType>::operator[](typename tmat3x3<valType>::size_type i)
template <typename T>
inline typename tmat3x3<T>::col_type &
tmat3x3<T>::operator[]
(
size_type i
)
{
assert(
i >= typename tmat3x3<valType>::size_type(0) &&
i < tmat3x3<valType>::col_size());
return value[i];
assert(i >= size_type(0) && i < col_size());
return this->value[i];
}
template <typename valType>
const detail::tvec3<valType>& tmat3x3<valType>::operator[](typename tmat3x3<valType>::size_type i) const
template <typename T>
inline typename tmat3x3<T>::col_type const &
tmat3x3<T>::operator[]
(
size_type i
) const
{
assert(
i >= typename tmat3x3<valType>::size_type(0) &&
i < tmat3x3<valType>::col_size());
return value[i];
assert(i >= size_type(0) && i < col_size());
return this->value[i];
}
//////////////////////////////////////////////////////////////
// mat3 constructors
// Constructors
template <typename T>
inline tmat3x3<T>::tmat3x3()
{
this->value[0] = detail::tvec3<T>(1, 0, 0);
this->value[1] = detail::tvec3<T>(0, 1, 0);
this->value[2] = detail::tvec3<T>(0, 0, 1);
value_type const Zero(0);
value_type const One(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)
inline tmat3x3<T>::tmat3x3
(
tmat3x3<T> const & m
)
{
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);
this->value[0] = m.value[0];
this->value[1] = m.value[1];
this->value[2] = m.value[2];
}
template <typename T>
inline tmat3x3<T>::tmat3x3
(
ctor
)
{}
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
(
const T x0, const T y0, const T z0,
const T x1, const T y1, const T z1,
const T x2, const T y2, const T z2
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] = detail::tvec3<T>(x0, y0, z0);
this->value[1] = detail::tvec3<T>(x1, y1, z1);
this->value[2] = detail::tvec3<T>(x2, y2, 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
(
const detail::tvec3<T>& v0,
const detail::tvec3<T>& v1,
const detail::tvec3<T>& v2
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[1] = detail::tvec3<T>(m[1]);
this->value[2] = detail::tvec3<T>(m[2]);
this->value[0] = col_type(m[0]);
this->value[1] = col_type(m[1]);
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[1] = detail::tvec3<T>(m[1], T(0));
this->value[2] = detail::tvec3<T>(detail::tvec2<T>(0), T(1));
this->value[0] = col_type(m[0], value_type(0));
this->value[1] = col_type(m[1], value_type(0));
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[1] = detail::tvec3<T>(m[1]);
this->value[2] = detail::tvec3<T>(m[2]);
this->value[0] = col_type(m[0]);
this->value[1] = col_type(m[1]);
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[1] = detail::tvec3<T>(m[1], T(0));
this->value[2] = detail::tvec3<T>(m[2], T(1));
this->value[0] = col_type(m[0], value_type(0));
this->value[1] = col_type(m[1], value_type(0));
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[1] = detail::tvec3<T>(m[1]);
this->value[2] = detail::tvec3<T>(detail::tvec2<T>(0), T(1));
this->value[0] = col_type(m[0]);
this->value[1] = col_type(m[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[1] = detail::tvec3<T>(m[1], T(0));
this->value[2] = detail::tvec3<T>(m[2], T(1));
this->value[0] = col_type(m[0], value_type(0));
this->value[1] = col_type(m[1], value_type(0));
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[1] = detail::tvec3<T>(m[1]);
this->value[2] = detail::tvec3<T>(m[2]);
this->value[0] = col_type(m[0]);
this->value[1] = col_type(m[1]);
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
/*
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
// 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,62 +505,78 @@ 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];
const T SrcA01 = m1[0][1];
const T SrcA02 = m1[0][2];
const T SrcA10 = m1[1][0];
const T SrcA11 = m1[1][1];
const T SrcA12 = m1[1][2];
const T SrcA20 = m1[2][0];
const T SrcA21 = m1[2][1];
const T SrcA22 = m1[2][2];
typename tmat3x3<T>::value_type const SrcA00 = m1[0][0];
typename tmat3x3<T>::value_type const SrcA01 = m1[0][1];
typename tmat3x3<T>::value_type const SrcA02 = m1[0][2];
typename tmat3x3<T>::value_type const SrcA10 = m1[1][0];
typename tmat3x3<T>::value_type const SrcA11 = m1[1][1];
typename tmat3x3<T>::value_type const SrcA12 = m1[1][2];
typename tmat3x3<T>::value_type const SrcA20 = m1[2][0];
typename tmat3x3<T>::value_type const SrcA21 = m1[2][1];
typename tmat3x3<T>::value_type const SrcA22 = m1[2][2];
const T SrcB00 = m2[0][0];
const T SrcB01 = m2[0][1];
const T SrcB02 = m2[0][2];
const T SrcB10 = m2[1][0];
const T SrcB11 = m2[1][1];
const T SrcB12 = m2[1][2];
const T SrcB20 = m2[2][0];
const T SrcB21 = m2[2][1];
const T SrcB22 = m2[2][2];
typename tmat3x3<T>::value_type const SrcB00 = m2[0][0];
typename tmat3x3<T>::value_type const SrcB01 = m2[0][1];
typename tmat3x3<T>::value_type const SrcB02 = m2[0][2];
typename tmat3x3<T>::value_type const SrcB10 = m2[1][0];
typename tmat3x3<T>::value_type const SrcB11 = m2[1][1];
typename tmat3x3<T>::value_type const SrcB12 = m2[1][2];
typename tmat3x3<T>::value_type const SrcB20 = m2[2][0];
typename tmat3x3<T>::value_type const SrcB21 = m2[2][1];
typename tmat3x3<T>::value_type const SrcB22 = m2[2][2];
tmat3x3<T> Result;
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;
Result[1][0] = SrcA00 * SrcB10 + SrcA10 * SrcB11 + SrcA20 * SrcB12;
Result[1][1] = SrcA01 * SrcB10 + SrcA11 * SrcB11 + SrcA21 * SrcB12;
Result[1][2] = SrcA02 * SrcB10 + SrcA12 * SrcB11 + SrcA22 * SrcB12;
Result[2][0] = SrcA00 * SrcB20 + SrcA10 * SrcB21 + SrcA20 * SrcB22;
Result[2][1] = SrcA01 * SrcB20 + SrcA11 * SrcB21 + SrcA21 * SrcB22;
Result[2][2] = SrcA02 * SrcB20 + SrcA12 * SrcB21 + SrcA22 * SrcB22;
return 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;
Result[1][0] = SrcA00 * SrcB10 + SrcA10 * SrcB11 + SrcA20 * SrcB12;
Result[1][1] = SrcA01 * SrcB10 + SrcA11 * SrcB11 + SrcA21 * SrcB12;
Result[1][2] = SrcA02 * SrcB10 + SrcA12 * SrcB11 + SrcA22 * SrcB12;
Result[2][0] = SrcA00 * SrcB20 + SrcA10 * SrcB21 + SrcA20 * SrcB22;
Result[2][1] = SrcA01 * SrcB20 + SrcA11 * SrcB21 + SrcA21 * SrcB22;
Result[2][2] = SrcA02 * SrcB20 + SrcA12 * SrcB21 + SrcA22 * SrcB22;
return Result;
}
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>
inline tmat3x3<valType> const operator-
template <typename T>
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>
inline tmat3x3<valType> const operator++
template <typename T>
inline tmat3x3<T> const operator++
(
tmat3x3<valType> const & m,
tmat3x3<T> const & m,
int
)
{
return tmat3x3<valType>(
m[0] + valType(1),
m[1] + valType(1),
m[2] + valType(1));
return tmat3x3<T>(
m[0] + T(1),
m[1] + T(1),
m[2] + T(1));
}
template <typename valType>
inline tmat3x3<valType> const operator--
template <typename T>
inline tmat3x3<T> const operator--
(
tmat3x3<valType> const & m,
tmat3x3<T> const & m,
int
)
{
return tmat3x3<valType>(
m[0] - valType(1),
m[1] - valType(1),
m[2] - valType(1));
return tmat3x3<T>(
m[0] - T(1),
m[1] - T(1),
m[2] - T(1));
}
} //namespace detail

189
glm/core/type_mat3x4.hpp
View File

@ -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:
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;
enum ctor{null};
typedef T value_type;
typedef detail::tvec3<T> col_type;
typedef detail::tvec4<T> row_type;
typedef glm::sizeType size_type;
typedef std::size_t size_type;
typedef tvec4<T> col_type;
typedef tvec3<T> row_type;
static size_type col_size();
static size_type row_size();
static bool is_matrix();
public:
tmat4x3<T> _inverse() const;
typedef tmat3x4<T> type;
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,
const T x1, const T y1, const T z1, const T w1,
const T x2, const T y2, const T z2, const T w2);
ctor Null);
explicit tmat3x4(
const detail::tvec4<T>& v0,
const detail::tvec4<T>& v1,
const detail::tvec4<T>& v2);
value_type const & s);
explicit 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);
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(const tmat3x3<T>& x);
explicit tmat3x4(const tmat4x4<T>& x);
explicit tmat3x4(const tmat2x3<T>& x);
explicit tmat3x4(const tmat3x2<T>& x);
explicit tmat3x4(const tmat2x4<T>& x);
explicit tmat3x4(const tmat4x2<T>& x);
explicit tmat3x4(const tmat4x3<T>& x);
explicit tmat3x4(tmat2x2<T> const & x);
explicit tmat3x4(tmat3x3<T> const & x);
explicit tmat3x4(tmat4x4<T> const & x);
explicit tmat3x4(tmat2x3<T> const & x);
explicit tmat3x4(tmat3x2<T> const & x);
explicit tmat3x4(tmat2x4<T> const & x);
explicit tmat3x4(tmat4x2<T> const & x);
explicit tmat3x4(tmat4x3<T> const & x);
// Accesses
detail::tvec4<T>& operator[](size_type i);
detail::tvec4<T> const & operator[](size_type i) const;
col_type & operator[](size_type i);
col_type const & operator[](size_type i) const;
// Unary updatable operators
tmat3x4<T>& operator= (const tmat3x4<T>& m);
tmat3x4<T>& operator+= (const T & s);
tmat3x4<T>& operator+= (const tmat3x4<T>& m);
tmat3x4<T>& operator-= (const T & s);
tmat3x4<T>& operator-= (const tmat3x4<T>& m);
tmat3x4<T>& operator*= (const T & s);
tmat3x4<T>& operator*= (const tmat4x3<T>& m);
tmat3x4<T>& operator/= (const T & s);
//tmat3x4<T>& operator/= (const tmat4x3<T>& m);
tmat3x4<T> & operator= (tmat3x4<T> const & m);
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);
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);
//template <typename T>
//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);
tmat3x4<T> operator/ (
typename tmat3x4<T>::value_type const & s,
tmat3x4<T> const & m);
// Unary constant operators
template <typename valType>
tmat3x4<valType> const operator- (tmat3x4<valType> const & m);
template <typename T>
tmat3x4<T> const operator- (
tmat3x4<T> const & m);
template <typename valType>
tmat3x4<valType> const operator-- (tmat3x4<valType> const & m, int);
template <typename T>
tmat3x4<T> const operator-- (
tmat3x4<T> const & m,
int);
template <typename valType>
tmat3x4<valType> const operator++ (tmat3x4<valType> const & m, int);
template <typename T>
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

417
glm/core/type_mat3x4.inl
View File

@ -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{
template <typename valType>
typename tmat3x4<valType>::size_type tmat3x4<valType>::col_size()
namespace detail
{
template <typename T>
inline typename tmat3x4<T>::size_type tmat3x4<T>::col_size()
{
return typename tmat3x4<valType>::size_type(3);
return 4;
}
template <typename valType>
typename tmat3x4<valType>::size_type tmat3x4<valType>::row_size()
template <typename T>
inline typename tmat3x4<T>::size_type tmat3x4<T>::row_size()
{
return typename tmat3x4<valType>::size_type(4);
}
template <typename valType>
bool tmat3x4<valType>::is_matrix()
{
return true;
return 3;
}
//////////////////////////////////////
// Accesses
template <typename valType>
detail::tvec4<valType>& tmat3x4<valType>::operator[](typename tmat3x4<valType>::size_type i)
template <typename T>
inline typename tmat3x4<T>::col_type &
tmat3x4<T>::operator[]
(
size_type i
)
{
assert(
i >= typename tmat3x4<valType>::size_type(0) &&
i < tmat3x4<valType>::col_size());
return value[i];
assert(i >= size_type(0) && i < col_size());
return this->value[i];
}
template <typename valType>
const detail::tvec4<valType>& tmat3x4<valType>::operator[](typename tmat3x4<valType>::size_type i) const
template <typename T>
inline typename tmat3x4<T>::col_type const &
tmat3x4<T>::operator[]
(
size_type i
) const
{
assert(
i >= typename tmat3x4<valType>::size_type(0) &&
i < tmat3x4<valType>::col_size());
return value[i];
assert(i >= size_type(0) && i < col_size());
return this->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);
this->value[1] = detail::tvec4<T>(0, 1, 0, 0);
this->value[2] = detail::tvec4<T>(0, 0, 1, 0);
value_type const Zero(0);
value_type const One(1);
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)
inline tmat3x4<T>::tmat3x4
(
tmat3x4<T> const & m
)
{
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);
this->value[0] = m.value[0];
this->value[1] = m.value[1];
this->value[2] = m.value[2];
}
template <typename T>
inline tmat3x4<T>::tmat3x4
(
ctor
)
{}
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
(
const T x0, const T y0, const T z0, const T w0,
const T x1, const T y1, const T z1, const T w1,
const T x2, const T y2, const T z2, const T w2
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] = detail::tvec4<T>(x0, y0, z0, w0);
this->value[1] = detail::tvec4<T>(x1, y1, z1, w1);
this->value[2] = detail::tvec4<T>(x2, y2, z2, 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
(
const detail::tvec4<T> & v0,
const detail::tvec4<T> & v1,
const detail::tvec4<T> & v2
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[1] = detail::tvec4<T>(m[1]);
this->value[2] = detail::tvec4<T>(m[2]);
this->value[0] = col_type(m[0]);
this->value[1] = col_type(m[1]);
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[1] = detail::tvec4<T>(m[1], detail::tvec2<T>(0));
this->value[2] = detail::tvec4<T>(T(0), T(0), T(1), T(0));
this->value[0] = col_type(m[0], detail::tvec2<T>(0));
this->value[1] = col_type(m[1], detail::tvec2<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[1] = detail::tvec4<T>(m[1], T(0));
this->value[2] = detail::tvec4<T>(m[2], T(0));
this->value[0] = col_type(m[0], T(0));
this->value[1] = col_type(m[1], 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[1] = detail::tvec4<T>(m[1]);
this->value[2] = detail::tvec4<T>(m[2]);
this->value[0] = col_type(m[0]);
this->value[1] = col_type(m[1]);
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[1] = detail::tvec4<T>(m[1], T(0));
this->value[2] = detail::tvec4<T>(T(0), T(0), T(1), T(0));
this->value[0] = col_type(m[0], T(0));
this->value[1] = col_type(m[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[1] = detail::tvec4<T>(m[1], detail::tvec2<T>(0));
this->value[2] = detail::tvec4<T>(m[2], T(0), T(1));
this->value[0] = col_type(m[0], detail::tvec2<T>(0));
this->value[1] = col_type(m[1], detail::tvec2<T>(0));
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[1] = detail::tvec4<T>(m[1]);
this->value[2] = detail::tvec4<T>(T(0), T(0), T(1), T(0));
this->value[0] = col_type(m[0]);
this->value[1] = col_type(m[1]);
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[1] = detail::tvec4<T>(m[1], detail::tvec2<T>(T(0)));
this->value[2] = detail::tvec4<T>(m[2], detail::tvec2<T>(T(1), T(0)));
this->value[0] = col_type(m[0], detail::tvec2<T>(T(0)));
this->value[1] = col_type(m[1], detail::tvec2<T>(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[1] = detail::tvec4<T>(m[1], T(0));
this->value[2] = detail::tvec4<T>(m[2], T(0));
this->value[0] = col_type(m[0], T(0));
this->value[1] = col_type(m[1], 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>
inline tmat3x4<valType> const operator-
template <typename T>
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>
inline tmat3x4<valType> const operator++
template <typename T>
inline tmat3x4<T> const operator++
(
tmat3x4<valType> const & m,
tmat3x4<T> const & m,
int
)
{
return tmat3x4<valType>(
m[0] + valType(1),
m[1] + valType(1),
m[2] + valType(1));
return tmat3x4<T>(
m[0] + T(1),
m[1] + T(1),
m[2] + T(1));
}
template <typename valType>
inline tmat3x4<valType> const operator--
template <typename T>
inline tmat3x4<T> const operator--
(
tmat3x4<valType> const & m,
tmat3x4<T> const & m,
int
)
{
return tmat3x4<valType>(
m[0] - valType(1),
m[1] - valType(1),
m[2] - valType(1));
return tmat3x4<T>(
m[0] - T(1),
m[1] - T(1),
m[2] - T(1));
}
} //namespace detail

191
glm/core/type_mat4x2.hpp
View File

@ -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:
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;
enum ctor{null};
typedef T value_type;
typedef detail::tvec4<T> col_type;
typedef detail::tvec2<T> row_type;
typedef glm::sizeType size_type;
typedef std::size_t size_type;
typedef tvec2<T> col_type;
typedef tvec4<T> row_type;
static size_type col_size();
static size_type row_size();
static bool is_matrix();
public:
tmat2x4<T> _inverse() const;
typedef tmat4x2<T> type;
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,
T const & x1, T const & y1,
T const & x2, T const & y2,
T const & x3, T const & y3);
ctor Null);
explicit tmat4x2(
detail::tvec2<T> const & v0,
detail::tvec2<T> const & v1,
detail::tvec2<T> const & v2,
detail::tvec2<T> const & v3);
value_type const & x);
explicit tmat4x2(
value_type const & x0, value_type const & y0,
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(const tmat3x3<T>& x);
explicit tmat4x2(const tmat4x4<T>& x);
explicit tmat4x2(const tmat2x3<T>& x);
explicit tmat4x2(const tmat3x2<T>& x);
explicit tmat4x2(const tmat2x4<T>& x);
explicit tmat4x2(const tmat4x3<T>& x);
explicit tmat4x2(const tmat3x4<T>& x);
explicit tmat4x2(tmat2x2<T> const & x);
explicit tmat4x2(tmat3x3<T> const & x);
explicit tmat4x2(tmat4x4<T> const & x);
explicit tmat4x2(tmat2x3<T> const & x);
explicit tmat4x2(tmat3x2<T> const & x);
explicit tmat4x2(tmat2x4<T> const & x);
explicit tmat4x2(tmat4x3<T> const & x);
explicit tmat4x2(tmat3x4<T> const & x);
// Accesses
detail::tvec2<T>& operator[](size_type i);
detail::tvec2<T> const & operator[](size_type i) const;
col_type & operator[](size_type i);
col_type const & operator[](size_type i) const;
// Unary updatable operators
tmat4x2<T>& operator= (const tmat4x2<T>& m);
tmat4x2<T>& operator+= (const T & s);
tmat4x2<T>& operator+= (const tmat4x2<T>& m);
tmat4x2<T>& operator-= (const T & s);
tmat4x2<T>& operator-= (const tmat4x2<T>& m);
tmat4x2<T>& operator*= (const T & s);
tmat4x2<T>& operator*= (const tmat2x4<T>& m);
tmat4x2<T>& operator/= (const T & s);
tmat4x2<T>& operator/= (const tmat2x4<T>& m);
tmat4x2<T>& operator= (tmat4x2<T> const & m);
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);
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);
//template <typename T>
//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);
tmat4x2<T> operator/ (
typename tmat4x2<T>::value_type const & s,
tmat4x2<T> const & m);
// Unary constant operators
template <typename valType>
tmat4x2<valType> const operator- (tmat4x2<valType> const & m);
template <typename T>
tmat4x2<T> const operator- (
tmat4x2<T> const & m);
template <typename valType>
tmat4x2<valType> const operator-- (tmat4x2<valType> const & m, int);
template <typename T>
tmat4x2<T> const operator-- (
tmat4x2<T> const & m,
int);
template <typename valType>
tmat4x2<valType> const operator++ (tmat4x2<valType> const & m, int);
template <typename T>
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

582
glm/core/type_mat4x2.inl
View File

@ -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{
template <typename valType>
typename tmat4x2<valType>::size_type tmat4x2<valType>::col_size()
namespace detail
{
template <typename T>
inline typename tmat4x2<T>::size_type tmat4x2<T>::col_size()
{
return typename tmat4x2<valType>::size_type(4);
return 2;
}
template <typename valType>
typename tmat4x2<valType>::size_type tmat4x2<valType>::row_size()
template <typename T>
inline typename tmat4x2<T>::size_type tmat4x2<T>::row_size()
{
return typename tmat4x2<valType>::size_type(2);
}
template <typename valType>
bool tmat4x2<valType>::is_matrix()
{
return true;
return 4;
}
//////////////////////////////////////
// Accesses
template <typename valType>
detail::tvec2<valType>& tmat4x2<valType>::operator[]
template <typename T>
inline typename tmat4x2<T>::col_type &
tmat4x2<T>::operator[]
(
typename tmat4x2<valType>::size_type i
size_type i
)
{
assert(
i >= typename tmat4x2<valType>::size_type(0) &&
i < tmat4x2<valType>::col_size());
return value[i];
assert(i >= size_type(0) && i < col_size());
return this->value[i];
}
template <typename valType>
const detail::tvec2<valType>& tmat4x2<valType>::operator[]
template <typename T>
inline typename tmat4x2<T>::col_type const &
tmat4x2<T>::operator[]
(
typename tmat4x2<valType>::size_type i
size_type i
) const
{
assert(
i >= typename tmat4x2<valType>::size_type(0) &&
i < tmat4x2<valType>::col_size());
return value[i];
assert(i >= size_type(0) && i < col_size());
return this->value[i];
}
//////////////////////////////////////////////////////////////
// Constructors
template <typename valType>
inline tmat4x2<valType>::tmat4x2()
template <typename T>
inline tmat4x2<T>::tmat4x2()
{
this->value[0] = detail::tvec2<valType>(1, 0);
this->value[1] = detail::tvec2<valType>(0, 1);
this->value[2] = detail::tvec2<valType>(0, 0);
this->value[3] = detail::tvec2<valType>(0, 0);
value_type const Zero(0);
value_type const One(1);
this->value[0] = col_type(One, Zero);
this->value[1] = col_type(Zero, One);
this->value[2] = col_type(Zero, Zero);
this->value[3] = col_type(Zero, Zero);
}
template <typename valType>
inline tmat4x2<valType>::tmat4x2
template <typename T>
inline tmat4x2<T>::tmat4x2
(
valType const & s
tmat4x2<T> const & m
)
{
this->value[0] = detail::tvec2<valType>(s, 0);
this->value[1] = detail::tvec2<valType>(0, s);
this->value[2] = detail::tvec2<valType>(0, 0);
this->value[3] = detail::tvec2<valType>(0, 0);
this->value[0] = m.value[0];
this->value[1] = m.value[1];
this->value[2] = m.value[2];
this->value[3] = m.value[3];
}
template <typename valType>
inline tmat4x2<valType>::tmat4x2
template <typename T>
inline tmat4x2<T>::tmat4x2
(
ctor
)
{}
template <typename T>
inline tmat4x2<T>::tmat4x2
(
value_type const & s
)
{
value_type const Zero(0);
this->value[0] = col_type(s, Zero);
this->value[1] = col_type(Zero, s);
this->value[2] = col_type(Zero, Zero);
this->value[3] = col_type(Zero, Zero);
}
template <typename T>
inline tmat4x2<T>::tmat4x2
(
valType const & x0, valType const & y0,
valType const & x1, valType const & y1,
valType const & x2, valType const & y2,
valType const & x3, valType const & y3
value_type const & x0, value_type const & y0,
value_type const & x1, value_type const & y1,
value_type const & x2, value_type const & y2,
value_type const & x3, value_type const & y3
)
{
this->value[0] = detail::tvec2<valType>(x0, y0);
this->value[1] = detail::tvec2<valType>(x1, y1);
this->value[2] = detail::tvec2<valType>(x2, y2);
this->value[3] = detail::tvec2<valType>(x3, 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 valType>
inline tmat4x2<valType>::tmat4x2
template <typename T>
inline tmat4x2<T>::tmat4x2
(
const detail::tvec2<valType> & v0,
const detail::tvec2<valType> & v1,
const detail::tvec2<valType> & v2,
const detail::tvec2<valType> & v3
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[1] = detail::tvec2<valType>(m[1]);
this->value[2] = detail::tvec2<valType>(m[2]);
this->value[3] = detail::tvec2<valType>(m[3]);
this->value[0] = col_type(m[0]);
this->value[1] = col_type(m[1]);
this->value[2] = col_type(m[2]);
this->value[3] = col_type(m[3]);
}
template <typename valType>
inline tmat4x2<valType>::tmat4x2(tmat2x2<valType> const & m)
template <typename T>
inline tmat4x2<T>::tmat4x2
(
tmat2x2<T> const & m
)
{
this->value[0] = detail::tvec2<valType>(m[0]);
this->value[1] = detail::tvec2<valType>(m[1]);
this->value[2] = detail::tvec2<valType>(valType(0));
this->value[3] = detail::tvec2<valType>(valType(0));
this->value[0] = col_type(m[0]);
this->value[1] = col_type(m[1]);
this->value[2] = col_type(value_type(0));
this->value[3] = col_type(value_type(0));
}
template <typename valType>
inline tmat4x2<valType>::tmat4x2(const tmat3x3<valType>& m)
template <typename T>
inline tmat4x2<T>::tmat4x2
(
tmat3x3<T> const & m
)
{
this->value[0] = detail::tvec2<valType>(m[0]);
this->value[1] = detail::tvec2<valType>(m[1]);
this->value[2] = detail::tvec2<valType>(m[2]);
this->value[3] = detail::tvec2<valType>(valType(0));
this->value[0] = col_type(m[0]);
this->value[1] = col_type(m[1]);
this->value[2] = col_type(m[2]);
this->value[3] = col_type(value_type(0));
}
template <typename valType>
inline tmat4x2<valType>::tmat4x2(const tmat4x4<valType>& m)
template <typename T>
inline tmat4x2<T>::tmat4x2
(
tmat4x4<T> const & m
)
{
this->value[0] = detail::tvec2<valType>(m[0]);
this->value[1] = detail::tvec2<valType>(m[1]);
this->value[2] = detail::tvec2<valType>(m[2]);
this->value[3] = detail::tvec2<valType>(m[3]);
this->value[0] = col_type(m[0]);
this->value[1] = col_type(m[1]);
this->value[2] = col_type(m[2]);
this->value[3] = col_type(m[3]);
}
template <typename valType>
inline tmat4x2<valType>::tmat4x2(const tmat2x3<valType>& m)
template <typename T>
inline tmat4x2<T>::tmat4x2
(
tmat2x3<T> const & m
)
{
this->value[0] = detail::tvec2<valType>(m[0]);
this->value[1] = detail::tvec2<valType>(m[1]);
this->value[2] = detail::tvec2<valType>(valType(0));
this->value[3] = detail::tvec2<valType>(valType(0));
this->value[0] = col_type(m[0]);
this->value[1] = col_type(m[1]);
this->value[2] = col_type(value_type(0));
this->value[3] = col_type(value_type(0));
}
template <typename valType>
inline tmat4x2<valType>::tmat4x2(const tmat3x2<valType>& m)
template <typename T>
inline tmat4x2<T>::tmat4x2
(
tmat3x2<T> const & m
)
{
this->value[0] = detail::tvec2<valType>(m[0]);
this->value[1] = detail::tvec2<valType>(m[1]);
this->value[2] = detail::tvec2<valType>(m[2]);
this->value[3] = detail::tvec2<valType>(valType(0));
this->value[0] = col_type(m[0]);
this->value[1] = col_type(m[1]);
this->value[2] = col_type(m[2]);
this->value[3] = col_type(value_type(0));
}
template <typename valType>
inline tmat4x2<valType>::tmat4x2(const tmat2x4<valType>& m)
template <typename T>
inline tmat4x2<T>::tmat4x2
(
tmat2x4<T> const & m
)
{
this->value[0] = detail::tvec2<valType>(m[0]);
this->value[1] = detail::tvec2<valType>(m[1]);
this->value[2] = detail::tvec2<valType>(valType(0));
this->value[3] = detail::tvec2<valType>(valType(0));
this->value[0] = col_type(m[0]);
this->value[1] = col_type(m[1]);
this->value[2] = col_type(value_type(0));
this->value[3] = col_type(value_type(0));
}
template <typename valType>
inline tmat4x2<valType>::tmat4x2(const tmat4x3<valType>& m)
template <typename T>
inline tmat4x2<T>::tmat4x2
(
tmat4x3<T> const & m
)
{
this->value[0] = detail::tvec2<valType>(m[0]);
this->value[1] = detail::tvec2<valType>(m[1]);
this->value[2] = detail::tvec2<valType>(m[2]);
this->value[3] = detail::tvec2<valType>(m[3]);
this->value[0] = col_type(m[0]);
this->value[1] = col_type(m[1]);
this->value[2] = col_type(m[2]);
this->value[3] = col_type(m[3]);
}
template <typename valType>
inline tmat4x2<valType>::tmat4x2(const tmat3x4<valType>& m)
template <typename T>
inline tmat4x2<T>::tmat4x2
(
tmat3x4<T> const & m
)
{
this->value[0] = detail::tvec2<valType>(m[0]);
this->value[1] = detail::tvec2<valType>(m[1]);
this->value[2] = detail::tvec2<valType>(m[2]);
this->value[3] = detail::tvec2<valType>(valType(0));
this->value[0] = col_type(m[0]);
this->value[1] = col_type(m[1]);
this->value[2] = col_type(m[2]);
this->value[3] = col_type(value_type(0));
}
//////////////////////////////////////////////////////////////
// Unary updatable operators
template <typename valType>
inline tmat4x2<valType>& tmat4x2<valType>::operator= (const tmat4x2<valType>& m)
template <typename T>
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>
inline tmat4x2<valType>& tmat4x2<valType>::operator+= (const valType & s)
template <typename T>
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>
inline tmat4x2<valType>& tmat4x2<valType>::operator+= (const tmat4x2<valType>& m)
template <typename T>
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>
inline tmat4x2<valType>& tmat4x2<valType>::operator-= (const valType & s)
template <typename T>
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>
inline tmat4x2<valType>& tmat4x2<valType>::operator-= (const tmat4x2<valType>& m)
template <typename T>
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>
inline tmat4x2<valType>& tmat4x2<valType>::operator*= (const valType & s)
template <typename T>
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>
inline tmat4x2<valType>& tmat4x2<valType>::operator*= (const tmat2x4<valType>& m)
template <typename T>
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>
inline tmat4x2<valType> & tmat4x2<valType>::operator/= (const valType & s)
template <typename T>
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>
//inline tmat2x2<valType>& tmat4x2<valType>::operator/= (const tmat2x4<valType>& m)
//{
// return (*this = *this / m);
//}
template <typename valType>
inline tmat4x2<valType>& tmat4x2<valType>::operator++ ()
template <typename T>
inline tmat4x2<T> & tmat4x2<T>::operator++ ()
{
++this->value[0];
++this->value[1];
@ -289,8 +367,8 @@ namespace detail{
return *this;
}
template <typename valType>
inline tmat4x2<valType>& tmat4x2<valType>::operator-- ()
template <typename T>
inline tmat4x2<T> & tmat4x2<T>::operator-- ()
{
--this->value[0];
--this->value[1];
@ -298,118 +376,146 @@ namespace detail{
--this->value[3];
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>
inline tmat4x2<valType> operator+ (const tmat4x2<valType>& m, const valType & s)
template <typename T>
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>
inline tmat4x2<valType> operator+ (const tmat4x2<valType>& m1, const tmat4x2<valType>& m2)
template <typename T>
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>
inline tmat4x2<valType> operator- (const tmat4x2<valType>& m, const valType & s)
template <typename T>
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>
inline tmat4x2<valType> operator- (const tmat4x2<valType>& m1, const tmat4x2<valType>& m2)
template <typename T>
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>
inline tmat4x2<valType> operator* (const tmat4x2<valType>& m, const valType & s)
template <typename T>
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>
inline tmat4x2<valType> operator* (const valType & s, const tmat4x2<valType> & m)
template <typename T>
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>
inline detail::tvec2<valType> operator* (const tmat4x2<valType>& m, const tvec4<valType>& v)
template <typename T>
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>
inline tvec4<valType> operator* (const detail::tvec2<valType>& v, const tmat4x2<valType>& m)
template <typename T>
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>
inline tmat2x2<valType> operator* (const tmat4x2<valType>& m1, const tmat2x4<valType>& m2)
template <typename T>
inline tmat2x2<T> operator*
(
tmat4x2<T> const & m1,
tmat2x4<T> const & m2
)
{
const valType SrcA00 = m1[0][0];
const valType SrcA01 = m1[0][1];
const valType SrcA10 = m1[1][0];
const valType SrcA11 = m1[1][1];
const valType SrcA20 = m1[2][0];
const valType SrcA21 = m1[2][1];
const valType SrcA30 = m1[3][0];
const valType SrcA31 = m1[3][1];
T const SrcA00 = m1[0][0];
T const SrcA01 = m1[0][1];
T const SrcA10 = m1[1][0];
T const SrcA11 = m1[1][1];
T const SrcA20 = m1[2][0];
T const SrcA21 = m1[2][1];
T const SrcA30 = m1[3][0];
T const SrcA31 = m1[3][1];
const valType SrcB00 = m2[0][0];
const valType SrcB01 = m2[0][1];
const valType SrcB02 = m2[0][2];
const valType SrcB03 = m2[0][3];
const valType SrcB10 = m2[1][0];
const valType SrcB11 = m2[1][1];
const valType SrcB12 = m2[1][2];
const valType SrcB13 = m2[1][3];
T const SrcB00 = m2[0][0];
T const SrcB01 = m2[0][1];
T const SrcB02 = m2[0][2];
T const SrcB03 = m2[0][3];
T const SrcB10 = m2[1][0];
T const SrcB11 = m2[1][1];
T const SrcB12 = m2[1][2];
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>
inline tmat4x2<valType> operator/ (const tmat4x2<valType>& m, const valType & s)
template <typename T>
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>
inline tmat4x2<valType> operator/ (const valType & s, const tmat4x2<valType>& m)
template <typename T>
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>
inline tmat4x2<valType> const operator-
template <typename T>
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>
inline tmat4x2<valType> const operator++
template <typename T>
inline tmat4x2<T> const operator++
(
tmat4x2<valType> const & m,
tmat4x2<T> const & m,
int
)
{
return tmat4x2<valType>(
m[0] + valType(1),
m[1] + valType(1),
m[2] + valType(1),
m[3] + valType(1));
return tmat4x2<T>(
m[0] + typename tmat4x2<T>::value_type(1),
m[1] + typename tmat4x2<T>::value_type(1),
m[2] + typename tmat4x2<T>::value_type(1),
m[3] + typename tmat4x2<T>::value_type(1));
}
template <typename valType>
inline tmat4x2<valType> const operator--
template <typename T>
inline tmat4x2<T> const operator--
(
tmat4x2<valType> const & m,
tmat4x2<T> const & m,
int
)
{
return tmat4x2<valType>(
m[0] - valType(1),
m[1] - valType(1),
m[2] - valType(1),
m[3] - valType(1));
return tmat4x2<T>(
m[0] - typename tmat4x2<T>::value_type(1),
m[1] - typename tmat4x2<T>::value_type(1),
m[2] - typename tmat4x2<T>::value_type(1),
m[3] - typename tmat4x2<T>::value_type(1));
}
} //namespace detail

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