- 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 namespace gtx{
    00027 namespace extented_min_max
    00028 {
    00031
    00032         //< Return the minimum component-wise values of 3 inputs
    00033         //< From GLM_GTX_extented_min_max extension
    00034         template <typename T>
    00035         T min(
    00036                 T const & x,
    00037                 T const & y,
    00038                 T const & z);
    00039
    00040         //< Return the minimum component-wise values of 3 inputs
    00041         //< From GLM_GTX_extented_min_max extension
    00042         template
    00043         <
    00044                 typename T,
    00045                 template <typename> class C
    00046         >
    00047         C<T> min(
    00048                 C<T> const & x,
    00049                 typename C<T>::value_type const & y,
    00050                 typename C<T>::value_type const & z);
    00051
    00052         //< Return the minimum component-wise values of 3 inputs
    00053         //< From GLM_GTX_extented_min_max extension
    00054         template
    00055         <
    00056                 typename T,
    00057                 template <typename> class C
    00058         >
    00059         C<T> min(
    00060                 C<T> const & x,
    00061                 C<T> const & y,
    00062                 C<T> const & z);
    00063
    00064         //< Return the minimum component-wise values of 4 inputs
    00065         //< From GLM_GTX_extented_min_max extension
    00066         template <typename T>
    00067         T min(
    00068                 T const & x,
    00069                 T const & y,
    00070                 T const & z,
    00071                 T const & w);
    00072
    00073         //< Return the minimum component-wise values of 4 inputs
    00074         //< From GLM_GTX_extented_min_max extension
    00075         template
    00076         <
    00077                 typename T,
    00078                 template <typename> class C
    00079         >
    00080         C<T> min(
    00081                 C<T> const & x,
    00082                 typename C<T>::value_type const & y,
    00083                 typename C<T>::value_type const & z,
    00084                 typename C<T>::value_type const & w);
    00085
    00086         //< Return the minimum component-wise values of 4 inputs
    00087         //< From GLM_GTX_extented_min_max extension
    00088         template
    00089         <
    00090                 typename T,
    00091                 template <typename> class C
    00092         >
    00093         C<T> min(
    00094                 C<T> const & x,
    00095                 C<T> const & y,
    00096                 C<T> const & z,
    00097                 C<T> const & w);
    00098
    00099         //< Return the maximum component-wise values of 3 inputs
    00100         //< From GLM_GTX_extented_min_max extension
    00101         template <typename T>
    00102         T max(
    00103                 T const & x,
    00104                 T const & y,
    00105                 T const & z);
    00106
    00107         //< Return the maximum component-wise values of 3 inputs
    00108         //< From GLM_GTX_extented_min_max extension
    00109         template
    00110         <
    00111                 typename T,
    00112                 template <typename> class C
    00113         >
    00114         C<T> max(
    00115                 C<T> const & x,
    00116                 typename C<T>::value_type const & y,
    00117                 typename C<T>::value_type const & z);
    00118
    00119         //< Return the maximum component-wise values of 3 inputs
    00120         //< From GLM_GTX_extented_min_max extension
    00121         template
    00122         <
    00123                 typename T,
    00124                 template <typename> class C
    00125         >
    00126         C<T> max(
    00127                 C<T> const & x,
    00128                 C<T> const & y,
    00129                 C<T> const & z);
    00130
    00131         //< Return the maximum component-wise values of 4 inputs
    00132         //< From GLM_GTX_extented_min_max extension
    00133         template <typename T>
    00134         T max(
    00135                 T const & x,
    00136                 T const & y,
    00137                 T const & z,
    00138                 T const & w);
    00139
    00140         //< Return the maximum component-wise values of 4 inputs
    00141         //< From GLM_GTX_extented_min_max extension
    00142         template
    00143         <
    00144                 typename T,
    00145                 template <typename> class C
    00146         >
    00147         C<T> max(
    00148                 C<T> const & x,
    00149                 typename C<T>::value_type const & y,
    00150                 typename C<T>::value_type const & z,
    00151                 typename C<T>::value_type const & w);
    00152
    00153         //< Return the maximum component-wise values of 4 inputs
    00154         //< From GLM_GTX_extented_min_max extension
    00155         template
    00156         <
    00157                 typename T,
    00158                 template <typename> class C
    00159         >
    00160         C<T> max(
    00161                 C<T> const & x,
    00162                 C<T> const & y,
    00163                 C<T> const & z,
    00164                 C<T> const & w);
    00165
    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