- Main Page
- Modules
- Namespaces
- Classes
- Files

- File List

# 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