- Main Page
- Namespaces
- Files

- File List

# extented_min_max.hpp

    00001
    00002 // OpenGL Mathematics Copyright (c) 2005 - 2010 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