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
00013 
00014 #ifndef glm_gtx_extented_min_max
00015 #define glm_gtx_extented_min_max
00016 
00017 // Dependency:
00018 #include "../glm.hpp"
00019 #include "../gtc/half_float.hpp"
00020 
00021 #if(defined(GLM_MESSAGES) && !defined(glm_ext))
00022 #       pragma message("GLM: GLM_GTX_extented_min_max extension included")
00023 #endif
00024 
00025 namespace glm
00026 {
00027         namespace test{
00028                 void main_ext_gtx_extented_min_max();
00029         }//namespace test
00030 
00031         namespace gtx{
00033         namespace extented_min_max
00034         {
00037 
00038                 //< Return the minimum component-wise values of 3 inputs 
00039                 //< From GLM_GTX_extented_min_max extension
00040                 template <typename T>
00041                 T min(
00042                         T const & x, 
00043                         T const & y, 
00044                         T const & z);
00045 
00046                 //< Return the minimum component-wise values of 3 inputs
00047                 //< From GLM_GTX_extented_min_max extension
00048                 template 
00049                 <
00050                         typename T, 
00051                         template <typename> class C
00052                 >
00053                 C<T> min(
00054                         C<T> const & x, 
00055                         typename C<T>::value_type const & y, 
00056                         typename C<T>::value_type const & z);
00057 
00058                 //< Return the minimum component-wise values of 3 inputs 
00059                 //< From GLM_GTX_extented_min_max extension
00060                 template 
00061                 <
00062                         typename T, 
00063                         template <typename> class C
00064                 >
00065                 C<T> min(
00066                         C<T> const & x, 
00067                         C<T> const & y, 
00068                         C<T> const & z);
00069 
00070                 //< Return the minimum component-wise values of 4 inputs 
00071                 //< From GLM_GTX_extented_min_max extension
00072                 template <typename T>
00073                 T min(
00074                         T const & x, 
00075                         T const & y, 
00076                         T const & z, 
00077                         T const & w);
00078 
00079                 //< Return the minimum component-wise values of 4 inputs 
00080                 //< From GLM_GTX_extented_min_max extension
00081                 template 
00082                 <
00083                         typename T, 
00084                         template <typename> class C
00085                 >
00086                 C<T> min(
00087                         C<T> const & x, 
00088                         typename C<T>::value_type const & y, 
00089                         typename C<T>::value_type const & z, 
00090                         typename C<T>::value_type const & w);
00091 
00092                 //< Return the minimum component-wise values of 4 inputs
00093                 //< From GLM_GTX_extented_min_max extension
00094                 template 
00095                 <
00096                         typename T, 
00097                         template <typename> class C
00098                 >
00099                 C<T> min(
00100                         C<T> const & x, 
00101                         C<T> const & y, 
00102                         C<T> const & z,
00103                         C<T> const & w);
00104 
00105                 //< Return the maximum component-wise values of 3 inputs 
00106                 //< From GLM_GTX_extented_min_max extension
00107                 template <typename T>
00108                 T max(
00109                         T const & x, 
00110                         T const & y, 
00111                         T const & z);
00112 
00113                 //< Return the maximum component-wise values of 3 inputs
00114                 //< From GLM_GTX_extented_min_max extension
00115                 template 
00116                 <
00117                         typename T, 
00118                         template <typename> class C
00119                 >
00120                 C<T> max(
00121                         C<T> const & x, 
00122                         typename C<T>::value_type const & y, 
00123                         typename C<T>::value_type const & z);
00124 
00125                 //< Return the maximum component-wise values of 3 inputs 
00126                 //< From GLM_GTX_extented_min_max extension
00127                 template 
00128                 <
00129                         typename T, 
00130                         template <typename> class C
00131                 >
00132                 C<T> max(
00133                         C<T> const & x, 
00134                         C<T> const & y, 
00135                         C<T> const & z);
00136 
00137                 //< Return the maximum component-wise values of 4 inputs
00138                 //< From GLM_GTX_extented_min_max extension
00139                 template <typename T>
00140                 T max(
00141                         T const & x, 
00142                         T const & y, 
00143                         T const & z, 
00144                         T const & w);
00145 
00146                 //< Return the maximum component-wise values of 4 inputs 
00147                 //< From GLM_GTX_extented_min_max extension
00148                 template 
00149                 <
00150                         typename T, 
00151                         template <typename> class C
00152                 >
00153                 C<T> max(
00154                         C<T> const & x, 
00155                         typename C<T>::value_type const & y, 
00156                         typename C<T>::value_type const & z, 
00157                         typename C<T>::value_type const & w);
00158 
00159                 //< Return the maximum component-wise values of 4 inputs 
00160                 //< From GLM_GTX_extented_min_max extension
00161                 template 
00162                 <
00163                         typename T, 
00164                         template <typename> class C
00165                 >
00166                 C<T> max(
00167                         C<T> const & x, 
00168                         C<T> const & y, 
00169                         C<T> const & z, 
00170                         C<T> const & w);
00171 
00173 
00174         }//namespace extented_min_max
00175         }//namespace gtx
00176 }//namespace glm
00177 
00178 #include "extented_min_max.inl"
00179 
00180 namespace glm{using namespace gtx::extented_min_max;}
00181 
00182 #endif//glm_gtx_extented_min_max
Generated by  doxygen 1.7.3