extented_min_max.hpp Source File

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