GLM Version 0.9.0

extented_min_max.hpp

00001 
00002 // OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
00004 // Created : 2007-03-14
00005 // Updated : 2010-02-19
00006 // Licence : This source is under MIT License
00007 // File    : gtx_extented_min_max.hpp
00009 // Dependency:
00010 // - GLM core
00011 // - GLM_GTX_half_float
00012 // - GLM_GTX_double_float
00014 
00015 #ifndef glm_gtx_extented_min_max
00016 #define glm_gtx_extented_min_max
00017 
00018 // Dependency:
00019 #include "../glm.hpp"
00020 #include "../gtc/half_float.hpp"
00021 #include "../gtc/double_float.hpp"
00022 
00023 namespace glm
00024 {
00025         namespace test{
00026                 void main_ext_gtx_extented_min_max();
00027         }//namespace test
00028 
00029         namespace gtx{
00031         namespace extented_min_max
00032         {
00033                 //< Return the minimum component-wise values of 3 inputs 
00034                 //< From GLM_GTX_extented_min_max extension
00035                 template <typename T>
00036                 T min(
00037                         T const & x, 
00038                         T const & y, 
00039                         T const & z);
00040 
00041                 //< Return the minimum component-wise values of 3 inputs
00042                 //< From GLM_GTX_extented_min_max extension
00043                 template 
00044                 <
00045                         typename T, 
00046                         template <typename> class C
00047                 >
00048                 C<T> min(
00049                         C<T> const & x, 
00050                         typename C<T>::value_type const & y, 
00051                         typename C<T>::value_type const & z);
00052 
00053                 //< Return the minimum component-wise values of 3 inputs 
00054                 //< From GLM_GTX_extented_min_max extension
00055                 template 
00056                 <
00057                         typename T, 
00058                         template <typename> class C
00059                 >
00060                 C<T> min(
00061                         C<T> const & x, 
00062                         C<T> const & y, 
00063                         C<T> const & z);
00064 
00065                 //< Return the minimum component-wise values of 4 inputs 
00066                 //< From GLM_GTX_extented_min_max extension
00067                 template <typename T>
00068                 T min(
00069                         T const & x, 
00070                         T const & y, 
00071                         T const & z, 
00072                         T const & w);
00073 
00074                 //< Return the minimum component-wise values of 4 inputs 
00075                 //< From GLM_GTX_extented_min_max extension
00076                 template 
00077                 <
00078                         typename T, 
00079                         template <typename> class C
00080                 >
00081                 C<T> min(
00082                         C<T> const & x, 
00083                         typename C<T>::value_type const & y, 
00084                         typename C<T>::value_type const & z, 
00085                         typename C<T>::value_type const & w);
00086 
00087                 //< Return the minimum component-wise values of 4 inputs
00088                 //< From GLM_GTX_extented_min_max extension
00089                 template 
00090                 <
00091                         typename T, 
00092                         template <typename> class C
00093                 >
00094                 C<T> min(
00095                         C<T> const & x, 
00096                         C<T> const & y, 
00097                         C<T> const & z,
00098                         C<T> const & w);
00099 
00100                 //< Return the maximum component-wise values of 3 inputs 
00101                 //< From GLM_GTX_extented_min_max extension
00102                 template <typename T>
00103                 T max(
00104                         T const & x, 
00105                         T const & y, 
00106                         T const & z);
00107 
00108                 //< Return the maximum component-wise values of 3 inputs
00109                 //< From GLM_GTX_extented_min_max extension
00110                 template 
00111                 <
00112                         typename T, 
00113                         template <typename> class C
00114                 >
00115                 C<T> max(
00116                         C<T> const & x, 
00117                         typename C<T>::value_type const & y, 
00118                         typename C<T>::value_type const & z);
00119 
00120                 //< Return the maximum component-wise values of 3 inputs 
00121                 //< From GLM_GTX_extented_min_max extension
00122                 template 
00123                 <
00124                         typename T, 
00125                         template <typename> class C
00126                 >
00127                 C<T> max(
00128                         C<T> const & x, 
00129                         C<T> const & y, 
00130                         C<T> const & z);
00131 
00132                 //< Return the maximum component-wise values of 4 inputs
00133                 //< From GLM_GTX_extented_min_max extension
00134                 template <typename T>
00135                 T max(
00136                         T const & x, 
00137                         T const & y, 
00138                         T const & z, 
00139                         T const & w);
00140 
00141                 //< Return the maximum component-wise values of 4 inputs 
00142                 //< From GLM_GTX_extented_min_max extension
00143                 template 
00144                 <
00145                         typename T, 
00146                         template <typename> class C
00147                 >
00148                 C<T> max(
00149                         C<T> const & x, 
00150                         typename C<T>::value_type const & y, 
00151                         typename C<T>::value_type const & z, 
00152                         typename C<T>::value_type const & w);
00153 
00154                 //< Return the maximum component-wise values of 4 inputs 
00155                 //< From GLM_GTX_extented_min_max extension
00156                 template 
00157                 <
00158                         typename T, 
00159                         template <typename> class C
00160                 >
00161                 C<T> max(
00162                         C<T> const & x, 
00163                         C<T> const & y, 
00164                         C<T> const & z, 
00165                         C<T> const & w);
00166 
00167         }//namespace extented_min_max
00168         }//namespace gtx
00169 }//namespace glm
00170 
00171 #include "extented_min_max.inl"
00172 
00173 namespace glm{using namespace gtx::extented_min_max;}
00174 
00175 #endif//glm_gtx_extented_min_max