mmstypes.cpp
Go to the documentation of this file.00001 /*************************************************************************** 00002 * Copyright (C) 2005-2007 Stefan Schwarzer, Jens Schneider, * 00003 * Matthias Hardt, Guido Madaus * 00004 * * 00005 * Copyright (C) 2007-2008 BerLinux Solutions GbR * 00006 * Stefan Schwarzer & Guido Madaus * 00007 * * 00008 * Copyright (C) 2009-2013 BerLinux Solutions GmbH * 00009 * * 00010 * Authors: * 00011 * Stefan Schwarzer <stefan.schwarzer@diskohq.org>, * 00012 * Matthias Hardt <matthias.hardt@diskohq.org>, * 00013 * Jens Schneider <jens.schneider@diskohq.org>, * 00014 * Guido Madaus <guido.madaus@diskohq.org>, * 00015 * Patrick Helterhoff <patrick.helterhoff@diskohq.org>, * 00016 * René Bählkow <rene.baehlkow@diskohq.org> * 00017 * * 00018 * This library is free software; you can redistribute it and/or * 00019 * modify it under the terms of the GNU Lesser General Public * 00020 * License version 2.1 as published by the Free Software Foundation. * 00021 * * 00022 * This library is distributed in the hope that it will be useful, * 00023 * but WITHOUT ANY WARRANTY; without even the implied warranty of * 00024 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * 00025 * Lesser General Public License for more details. * 00026 * * 00027 * You should have received a copy of the GNU Lesser General Public * 00028 * License along with this library; if not, write to the * 00029 * Free Software Foundation, Inc., * 00030 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA * 00031 **************************************************************************/ 00032 00033 #include "mmstools/mmstypes.h" 00034 #include "mmstools/tools.h" 00035 #include <string.h> 00036 #include <math.h> 00037 #include <stdlib.h> 00038 00039 00040 string getMMSFBBackendString(MMSFBBackend be) { 00041 if(be == MMSFB_BE_DFB) 00042 return MMSFB_BE_DFB_STR; 00043 if(be == MMSFB_BE_X11) 00044 return MMSFB_BE_X11_STR; 00045 if(be == MMSFB_BE_FBDEV) 00046 return MMSFB_BE_FBDEV_STR; 00047 if(be == MMSFB_BE_KMS) 00048 return MMSFB_BE_KMS_STR; 00049 return MMSFB_BE_NONE_STR; 00050 } 00051 00052 MMSFBBackend getMMSFBBackendFromString(string be) { 00053 if(be == MMSFB_BE_NONE_STR) 00054 return MMSFB_BE_NONE; 00055 if(be == MMSFB_BE_DFB_STR) 00056 return MMSFB_BE_DFB; 00057 if(be == MMSFB_BE_X11_STR) 00058 return MMSFB_BE_X11; 00059 if(be == MMSFB_BE_FBDEV_STR) 00060 return MMSFB_BE_FBDEV; 00061 if(be == MMSFB_BE_KMS_STR) 00062 return MMSFB_BE_KMS; 00063 return MMSFB_BE_NONE; 00064 } 00065 00066 string getMMSFBOutputTypeString(MMSFBOutputType ot) { 00067 if(ot == MMSFB_OT_STDFB) 00068 return MMSFB_OT_STDFB_STR; 00069 if(ot == MMSFB_OT_MATROXFB) 00070 return MMSFB_OT_MATROXFB_STR; 00071 if(ot == MMSFB_OT_VIAFB) 00072 return MMSFB_OT_VIAFB_STR; 00073 if(ot == MMSFB_OT_X11) 00074 return MMSFB_OT_X11_STR; 00075 if(ot == MMSFB_OT_XSHM) 00076 return MMSFB_OT_XSHM_STR; 00077 if(ot == MMSFB_OT_XVSHM) 00078 return MMSFB_OT_XVSHM_STR; 00079 if(ot == MMSFB_OT_DAVINCIFB) 00080 return MMSFB_OT_DAVINCIFB_STR; 00081 if(ot == MMSFB_OT_OMAPFB) 00082 return MMSFB_OT_OMAPFB_STR; 00083 if(ot == MMSFB_OT_OGL) 00084 return MMSFB_OT_OGL_STR; 00085 return MMSFB_OT_NONE_STR; 00086 } 00087 00088 MMSFBOutputType getMMSFBOutputTypeFromString(string ot) { 00089 if(ot == MMSFB_OT_NONE_STR) 00090 return MMSFB_OT_NONE; 00091 if(ot == MMSFB_OT_STDFB_STR) 00092 return MMSFB_OT_STDFB; 00093 if(ot == MMSFB_OT_MATROXFB_STR) 00094 return MMSFB_OT_MATROXFB; 00095 if(ot == MMSFB_OT_VIAFB_STR) 00096 return MMSFB_OT_VIAFB; 00097 if(ot == MMSFB_OT_X11_STR) 00098 return MMSFB_OT_X11; 00099 if(ot == MMSFB_OT_XSHM_STR) 00100 return MMSFB_OT_XSHM; 00101 if(ot == MMSFB_OT_XVSHM_STR) 00102 return MMSFB_OT_XVSHM; 00103 if(ot == MMSFB_OT_DAVINCIFB_STR) 00104 return MMSFB_OT_DAVINCIFB; 00105 if(ot == MMSFB_OT_OMAPFB_STR) 00106 return MMSFB_OT_OMAPFB; 00107 if(ot == MMSFB_OT_OGL_STR) 00108 return MMSFB_OT_OGL; 00109 return MMSFB_OT_NONE; 00110 } 00111 00112 string getMMSFBFullScreenModeString(MMSFBFullScreenMode fsm) { 00113 if(fsm == MMSFB_FSM_FALSE) 00114 return MMSFB_FSM_FALSE_STR; 00115 if(fsm == MMSFB_FSM_TRUE) 00116 return MMSFB_FSM_TRUE_STR; 00117 if(fsm == MMSFB_FSM_ASPECT_RATIO) 00118 return MMSFB_FSM_ASPECT_RATIO_STR; 00119 return MMSFB_FSM_NONE_STR; 00120 } 00121 00122 MMSFBFullScreenMode getMMSFBFullScreenModeFromString(string fsm) { 00123 if(fsm == MMSFB_FSM_NONE_STR) 00124 return MMSFB_FSM_NONE; 00125 if(fsm == MMSFB_FSM_FALSE_STR) 00126 return MMSFB_FSM_FALSE; 00127 if(fsm == MMSFB_FSM_TRUE_STR) 00128 return MMSFB_FSM_TRUE; 00129 if(fsm == MMSFB_FSM_ASPECT_RATIO_STR) 00130 return MMSFB_FSM_ASPECT_RATIO; 00131 return MMSFB_FSM_NONE; 00132 } 00133 00134 00135 00136 string getMMSFBPixelFormatString(MMSFBSurfacePixelFormat pf) { 00137 switch (pf) { 00138 case MMSFB_PF_RGB16: return MMSFB_PF_RGB16_STR; 00139 case MMSFB_PF_RGB24: return MMSFB_PF_RGB24_STR; 00140 case MMSFB_PF_RGB32: return MMSFB_PF_RGB32_STR; 00141 case MMSFB_PF_ARGB: return MMSFB_PF_ARGB_STR; 00142 case MMSFB_PF_A8: return MMSFB_PF_A8_STR; 00143 case MMSFB_PF_YUY2: return MMSFB_PF_YUY2_STR; 00144 case MMSFB_PF_UYVY: return MMSFB_PF_UYVY_STR; 00145 case MMSFB_PF_I420: return MMSFB_PF_I420_STR; 00146 case MMSFB_PF_YV12: return MMSFB_PF_YV12_STR; 00147 case MMSFB_PF_AiRGB: return MMSFB_PF_AiRGB_STR; 00148 case MMSFB_PF_A1: return MMSFB_PF_A1_STR; 00149 case MMSFB_PF_NV12: return MMSFB_PF_NV12_STR; 00150 case MMSFB_PF_NV16: return MMSFB_PF_NV16_STR; 00151 case MMSFB_PF_NV21: return MMSFB_PF_NV21_STR; 00152 case MMSFB_PF_AYUV: return MMSFB_PF_AYUV_STR; 00153 case MMSFB_PF_A4: return MMSFB_PF_A4_STR; 00154 case MMSFB_PF_ARGB1666:return MMSFB_PF_ARGB1666_STR; 00155 case MMSFB_PF_ARGB6666:return MMSFB_PF_ARGB6666_STR; 00156 case MMSFB_PF_RGB18: return MMSFB_PF_RGB18_STR; 00157 case MMSFB_PF_LUT2: return MMSFB_PF_LUT2_STR; 00158 case MMSFB_PF_RGB444: return MMSFB_PF_RGB444_STR; 00159 case MMSFB_PF_RGB555: return MMSFB_PF_RGB555_STR; 00160 case MMSFB_PF_ARGB1555:return MMSFB_PF_ARGB1555_STR; 00161 case MMSFB_PF_RGB332: return MMSFB_PF_RGB332_STR; 00162 case MMSFB_PF_ALUT44: return MMSFB_PF_ALUT44_STR; 00163 case MMSFB_PF_LUT8: return MMSFB_PF_LUT8_STR; 00164 case MMSFB_PF_ARGB2554:return MMSFB_PF_ARGB2554_STR; 00165 case MMSFB_PF_ARGB4444:return MMSFB_PF_ARGB4444_STR; 00166 case MMSFB_PF_ARGB3565:return MMSFB_PF_ARGB3565_STR; 00167 case MMSFB_PF_BGR24: return MMSFB_PF_BGR24_STR; 00168 case MMSFB_PF_BGR555: return MMSFB_PF_BGR555_STR; 00169 case MMSFB_PF_ABGR: return MMSFB_PF_ABGR_STR; 00170 default: return MMSFB_PF_NONE_STR; 00171 } 00172 } 00173 00174 MMSFBSurfacePixelFormat getMMSFBPixelFormatFromString(string pf) { 00175 if(pf == MMSFB_PF_NONE_STR) 00176 return MMSFB_PF_NONE; 00177 if(pf == MMSFB_PF_RGB16_STR) 00178 return MMSFB_PF_RGB16; 00179 if(pf == MMSFB_PF_RGB24_STR) 00180 return MMSFB_PF_RGB24; 00181 if(pf == MMSFB_PF_RGB32_STR) 00182 return MMSFB_PF_RGB32; 00183 if(pf == MMSFB_PF_ARGB_STR) 00184 return MMSFB_PF_ARGB; 00185 if(pf == MMSFB_PF_A8_STR) 00186 return MMSFB_PF_A8; 00187 if(pf == MMSFB_PF_YUY2_STR) 00188 return MMSFB_PF_YUY2; 00189 if(pf == MMSFB_PF_UYVY_STR) 00190 return MMSFB_PF_UYVY; 00191 if(pf == MMSFB_PF_I420_STR) 00192 return MMSFB_PF_I420; 00193 if(pf == MMSFB_PF_YV12_STR) 00194 return MMSFB_PF_YV12; 00195 if(pf == strToUpr(MMSFB_PF_AiRGB_STR)) 00196 return MMSFB_PF_AiRGB; 00197 if(pf == MMSFB_PF_A1_STR) 00198 return MMSFB_PF_A1; 00199 if(pf == MMSFB_PF_NV12_STR) 00200 return MMSFB_PF_NV12; 00201 if(pf == MMSFB_PF_NV16_STR) 00202 return MMSFB_PF_NV16; 00203 if(pf == MMSFB_PF_NV21_STR) 00204 return MMSFB_PF_NV21; 00205 if(pf == MMSFB_PF_AYUV_STR) 00206 return MMSFB_PF_AYUV; 00207 if(pf == MMSFB_PF_A4_STR) 00208 return MMSFB_PF_A4; 00209 if(pf == MMSFB_PF_ARGB1666_STR) 00210 return MMSFB_PF_ARGB1666; 00211 if(pf == MMSFB_PF_ARGB6666_STR) 00212 return MMSFB_PF_ARGB6666; 00213 if(pf == MMSFB_PF_RGB18_STR) 00214 return MMSFB_PF_RGB18; 00215 if(pf == MMSFB_PF_LUT2_STR) 00216 return MMSFB_PF_LUT2; 00217 if(pf == MMSFB_PF_RGB444_STR) 00218 return MMSFB_PF_RGB444; 00219 if(pf == MMSFB_PF_RGB555_STR) 00220 return MMSFB_PF_RGB555; 00221 if(pf == MMSFB_PF_ARGB1555_STR) 00222 return MMSFB_PF_ARGB1555; 00223 if(pf == MMSFB_PF_RGB332_STR) 00224 return MMSFB_PF_RGB332; 00225 if(pf == MMSFB_PF_ALUT44_STR) 00226 return MMSFB_PF_ALUT44; 00227 if(pf == MMSFB_PF_LUT8_STR) 00228 return MMSFB_PF_LUT8; 00229 if(pf == MMSFB_PF_ARGB2554_STR) 00230 return MMSFB_PF_ARGB2554; 00231 if(pf == MMSFB_PF_ARGB4444_STR) 00232 return MMSFB_PF_ARGB4444; 00233 if(pf == MMSFB_PF_ARGB3565_STR) 00234 return MMSFB_PF_ARGB3565; 00235 if(pf == MMSFB_PF_BGR24_STR) 00236 return MMSFB_PF_BGR24; 00237 if(pf == MMSFB_PF_BGR555_STR) 00238 return MMSFB_PF_BGR555; 00239 if(pf == MMSFB_PF_ABGR_STR) 00240 return MMSFB_PF_ABGR; 00241 return MMSFB_PF_NONE; 00242 } 00243 00244 00245 bool getMMSFBColorFromString(string input, MMSFBColor *color) { 00246 // check ret ptr 00247 if (!color) 00248 return false; 00249 00250 // reset color 00251 color->r = 0; 00252 color->g = 0; 00253 color->b = 0; 00254 color->a = 0; 00255 00256 // check input string 00257 if (input == "") 00258 return false; 00259 00260 if (input.size()!=9) 00261 return false; 00262 00263 if (input.substr(0,1)!="#") 00264 return false; 00265 00266 // set color values 00267 color->r = hexToInt(input.substr(1,2).c_str()); 00268 color->g = hexToInt(input.substr(3,2).c_str()); 00269 color->b = hexToInt(input.substr(5,2).c_str()); 00270 color->a = hexToInt(input.substr(7,2).c_str()); 00271 00272 return true; 00273 } 00274 00275 00276 string getMMSFBColorString(MMSFBColor color) { 00277 string ret = "#"; 00278 ret+= ucharToHex(color.r); 00279 ret+= ucharToHex(color.g); 00280 ret+= ucharToHex(color.b); 00281 ret+= ucharToHex(color.a); 00282 return ret; 00283 } 00284 00285 00286 00287 string getMMSFBPointerModeString(MMSFBPointerMode pm) { 00288 if(pm == MMSFB_PM_FALSE) 00289 return MMSFB_PM_FALSE_STR; 00290 if(pm == MMSFB_PM_TRUE) 00291 return MMSFB_PM_TRUE_STR; 00292 if(pm == MMSFB_PM_EXTERNAL) 00293 return MMSFB_PM_EXTERNAL_STR; 00294 return MMSFB_PM_NONE_STR; 00295 } 00296 00297 MMSFBPointerMode getMMSFBPointerModeFromString(string pm) { 00298 if(pm == MMSFB_PM_NONE_STR) 00299 return MMSFB_PM_NONE; 00300 if(pm == MMSFB_PM_FALSE_STR) 00301 return MMSFB_PM_FALSE; 00302 if(pm == MMSFB_PM_TRUE_STR) 00303 return MMSFB_PM_TRUE; 00304 if(pm == MMSFB_PM_EXTERNAL_STR) 00305 return MMSFB_PM_EXTERNAL; 00306 return MMSFB_PM_NONE; 00307 } 00308 00309 00310 const char *convertMMSKeySymbolToXKeysymString(MMSKeySymbol key) { 00311 switch (key) { 00312 case MMSKEY_CURSOR_LEFT: return "Left"; 00313 case MMSKEY_CURSOR_RIGHT: return "Right"; 00314 case MMSKEY_CURSOR_UP: return "Up"; 00315 case MMSKEY_CURSOR_DOWN: return "Down"; 00316 case MMSKEY_0: return "0"; 00317 case MMSKEY_1: return "1"; 00318 case MMSKEY_2: return "2"; 00319 case MMSKEY_3: return "3"; 00320 case MMSKEY_4: return "4"; 00321 case MMSKEY_5: return "5"; 00322 case MMSKEY_6: return "6"; 00323 case MMSKEY_7: return "7"; 00324 case MMSKEY_8: return "8"; 00325 case MMSKEY_9: return "9"; 00326 case MMSKEY_CAPITAL_A: return "A"; 00327 case MMSKEY_CAPITAL_B: return "B"; 00328 case MMSKEY_CAPITAL_C: return "C"; 00329 case MMSKEY_CAPITAL_D: return "D"; 00330 case MMSKEY_CAPITAL_E: return "E"; 00331 case MMSKEY_CAPITAL_F: return "F"; 00332 case MMSKEY_CAPITAL_G: return "G"; 00333 case MMSKEY_CAPITAL_H: return "H"; 00334 case MMSKEY_CAPITAL_I: return "I"; 00335 case MMSKEY_CAPITAL_J: return "J"; 00336 case MMSKEY_CAPITAL_K: return "K"; 00337 case MMSKEY_CAPITAL_L: return "L"; 00338 case MMSKEY_CAPITAL_M: return "M"; 00339 case MMSKEY_CAPITAL_N: return "N"; 00340 case MMSKEY_CAPITAL_O: return "O"; 00341 case MMSKEY_CAPITAL_P: return "P"; 00342 case MMSKEY_CAPITAL_Q: return "Q"; 00343 case MMSKEY_CAPITAL_R: return "R"; 00344 case MMSKEY_CAPITAL_S: return "S"; 00345 case MMSKEY_CAPITAL_T: return "T"; 00346 case MMSKEY_CAPITAL_U: return "U"; 00347 case MMSKEY_CAPITAL_V: return "V"; 00348 case MMSKEY_CAPITAL_W: return "W"; 00349 case MMSKEY_CAPITAL_X: return "X"; 00350 case MMSKEY_CAPITAL_Y: return "Y"; 00351 case MMSKEY_CAPITAL_Z: return "Z"; 00352 case MMSKEY_SMALL_A: return "a"; 00353 case MMSKEY_SMALL_B: return "b"; 00354 case MMSKEY_SMALL_C: return "c"; 00355 case MMSKEY_SMALL_D: return "d"; 00356 case MMSKEY_SMALL_E: return "e"; 00357 case MMSKEY_SMALL_F: return "f"; 00358 case MMSKEY_SMALL_G: return "g"; 00359 case MMSKEY_SMALL_H: return "h"; 00360 case MMSKEY_SMALL_I: return "i"; 00361 case MMSKEY_SMALL_J: return "j"; 00362 case MMSKEY_SMALL_K: return "k"; 00363 case MMSKEY_SMALL_L: return "l"; 00364 case MMSKEY_SMALL_M: return "m"; 00365 case MMSKEY_SMALL_N: return "n"; 00366 case MMSKEY_SMALL_O: return "o"; 00367 case MMSKEY_SMALL_P: return "p"; 00368 case MMSKEY_SMALL_Q: return "q"; 00369 case MMSKEY_SMALL_R: return "r"; 00370 case MMSKEY_SMALL_S: return "s"; 00371 case MMSKEY_SMALL_T: return "t"; 00372 case MMSKEY_SMALL_U: return "u"; 00373 case MMSKEY_SMALL_V: return "v"; 00374 case MMSKEY_SMALL_W: return "w"; 00375 case MMSKEY_SMALL_X: return "x"; 00376 case MMSKEY_SMALL_Y: return "y"; 00377 case MMSKEY_SMALL_Z: return "z"; 00378 case MMSKEY_F1: return "F1"; 00379 case MMSKEY_F2: return "F2"; 00380 case MMSKEY_F3: return "F3"; 00381 case MMSKEY_F4: return "F4"; 00382 case MMSKEY_F5: return "F5"; 00383 case MMSKEY_F6: return "F6"; 00384 case MMSKEY_F7: return "F7"; 00385 case MMSKEY_F8: return "F8"; 00386 case MMSKEY_F9: return "F9"; 00387 case MMSKEY_F10: return "F10"; 00388 case MMSKEY_F11: return "F11"; 00389 case MMSKEY_F12: return "F12"; 00390 case MMSKEY_CAPS_LOCK: return "Caps_Lock"; 00391 case MMSKEY_NUM_LOCK: return "Num_Lock"; 00392 case MMSKEY_SCROLL_LOCK: return "Scroll_Lock"; 00393 case MMSKEY_ESCAPE: return "Escape"; 00394 case MMSKEY_TAB: return "Tab"; 00395 case MMSKEY_RETURN: return "Return"; 00396 case MMSKEY_SPACE: return "space"; 00397 case MMSKEY_BACKSPACE: return "BackSpace"; 00398 case MMSKEY_INSERT: return "Insert"; 00399 case MMSKEY_DELETE: return "Delete"; 00400 case MMSKEY_HOME: return "Home"; 00401 case MMSKEY_END: return "End"; 00402 case MMSKEY_PAGE_UP: return "Prior"; 00403 case MMSKEY_PAGE_DOWN: return "Next"; 00404 case MMSKEY_PRINT: return "Print"; 00405 case MMSKEY_PAUSE: return "Pause"; 00406 case MMSKEY_MINUS_SIGN: return "minus"; 00407 case MMSKEY_EQUALS_SIGN: return "equal"; 00408 case MMSKEY_BACKSLASH: return "backslash"; 00409 case MMSKEY_SEMICOLON: return "semicolon"; 00410 case MMSKEY_COMMA: return "comma"; 00411 case MMSKEY_PERIOD: return "period"; 00412 case MMSKEY_SLASH: return "slash"; 00413 case MMSKEY_SHIFT: return "Shift"; 00414 case MMSKEY_CONTROL: return "Control"; 00415 case MMSKEY_ALT: return "Alt"; 00416 case MMSKEY_META: return "Meta"; 00417 case MMSKEY_SUPER: return "Super"; 00418 case MMSKEY_HYPER: return "Hyper"; 00419 case MMSKEY_ALTGR: return "Mode_switch"; 00420 case MMSKEY_ASTERISK: return "Multiply"; 00421 case MMSKEY_PLUS_SIGN: return "Add"; 00422 case MMSKEY_COLON: return "colon"; 00423 default: return ""; 00424 } 00425 } 00426 00427 00428 string getMMSLanguageString(MMSLanguage lang) { 00429 if (lang == MMSLANG_DE) 00430 return MMSLANG_DE_STR; 00431 if (lang == MMSLANG_EN) 00432 return MMSLANG_EN_STR; 00433 if (lang == MMSLANG_DK) 00434 return MMSLANG_DK_STR; 00435 if (lang == MMSLANG_ES) 00436 return MMSLANG_ES_STR; 00437 if (lang == MMSLANG_FI) 00438 return MMSLANG_FI_STR; 00439 if (lang == MMSLANG_FR) 00440 return MMSLANG_FR_STR; 00441 if (lang == MMSLANG_IT) 00442 return MMSLANG_IT_STR; 00443 if (lang == MMSLANG_NL) 00444 return MMSLANG_NL_STR; 00445 if (lang == MMSLANG_NO) 00446 return MMSLANG_NO_STR; 00447 if (lang == MMSLANG_SE) 00448 return MMSLANG_SE_STR; 00449 if (lang == MMSLANG_TR) 00450 return MMSLANG_TR_STR; 00451 if (lang == MMSLANG_CN) 00452 return MMSLANG_CN_STR; 00453 if (lang == MMSLANG_IL) 00454 return MMSLANG_IL_STR; 00455 if (lang == MMSLANG_AR) 00456 return MMSLANG_AR_STR; 00457 if (lang == MMSLANG_CS) 00458 return MMSLANG_CS_STR; 00459 if (lang == MMSLANG_RU) 00460 return MMSLANG_RU_STR; 00461 if (lang == MMSLANG_HR) 00462 return MMSLANG_HR_STR; 00463 return MMSLANG_NONE_STR; 00464 } 00465 00466 MMSLanguage getMMSLanguageFromString(string lang) { 00467 strToUpr(&lang); 00468 if (lang == MMSLANG_NONE_STR) 00469 return MMSLANG_NONE; 00470 if (lang == MMSLANG_DE_STR) 00471 return MMSLANG_DE; 00472 if (lang == MMSLANG_EN_STR) 00473 return MMSLANG_EN; 00474 if (lang == MMSLANG_DK_STR) 00475 return MMSLANG_DK; 00476 if (lang == MMSLANG_ES_STR) 00477 return MMSLANG_ES; 00478 if (lang == MMSLANG_FI_STR) 00479 return MMSLANG_FI; 00480 if (lang == MMSLANG_FR_STR) 00481 return MMSLANG_FR; 00482 if (lang == MMSLANG_IT_STR) 00483 return MMSLANG_IT; 00484 if (lang == MMSLANG_NL_STR) 00485 return MMSLANG_NL; 00486 if (lang == MMSLANG_NO_STR) 00487 return MMSLANG_NO; 00488 if (lang == MMSLANG_SE_STR) 00489 return MMSLANG_SE; 00490 if (lang == MMSLANG_TR_STR) 00491 return MMSLANG_TR; 00492 if (lang == MMSLANG_CN_STR) 00493 return MMSLANG_CN; 00494 if (lang == MMSLANG_IL_STR) 00495 return MMSLANG_IL; 00496 if (lang == MMSLANG_AR_STR) 00497 return MMSLANG_AR; 00498 if (lang == MMSLANG_CS_STR) 00499 return MMSLANG_CS; 00500 if (lang == MMSLANG_RU_STR) 00501 return MMSLANG_RU; 00502 if (lang == MMSLANG_HR_STR) 00503 return MMSLANG_HR; 00504 return MMSLANG_NONE; 00505 } 00506 00507 00508 00509 00510 MMS_HALF_FLOAT convertFloat2HalfFloat(float f) { 00511 unsigned int x = *(unsigned int *)&f; 00512 unsigned int sign = (unsigned short)(x >> 31); 00513 unsigned int mantissa; 00514 unsigned int exp; 00515 MMS_HALF_FLOAT hf; 00516 00517 // get mantissa 00518 mantissa = x & ((1 << 23) - 1); 00519 00520 // get exponent bits 00521 exp = x & FLOAT_MAX_BIASED_EXP; 00522 00523 if (exp >= HALF_FLOAT_MAX_BIASED_EXP_AS_SINGLE_FP_EXP) { 00524 // check if the original single precision float number is a NaN 00525 if (mantissa && (exp == FLOAT_MAX_BIASED_EXP)) { 00526 // we have a single precision NaN 00527 mantissa = (1 << 23) - 1; 00528 } 00529 else { 00530 // 16-bit half-float representation stores number as Inf 00531 mantissa = 0; 00532 } 00533 00534 hf = (((MMS_HALF_FLOAT)sign) << 15) | (MMS_HALF_FLOAT)(HALF_FLOAT_MAX_BIASED_EXP) | (MMS_HALF_FLOAT)(mantissa >> 13); 00535 } 00536 // check if exponent is <= -15 00537 else if (exp <= HALF_FLOAT_MIN_BIASED_EXP_AS_SINGLE_FP_EXP) { 00538 // store a denorm half-float value or zero 00539 exp = (HALF_FLOAT_MIN_BIASED_EXP_AS_SINGLE_FP_EXP - exp) >> 23; 00540 mantissa >>= (14 + exp); 00541 hf = (((MMS_HALF_FLOAT)sign) << 15) | (MMS_HALF_FLOAT)(mantissa); 00542 } 00543 else { 00544 hf = (((MMS_HALF_FLOAT)sign) << 15) | (MMS_HALF_FLOAT)((exp - HALF_FLOAT_MIN_BIASED_EXP_AS_SINGLE_FP_EXP) >> 13) | 00545 (MMS_HALF_FLOAT)(mantissa >> 13); 00546 } 00547 00548 return hf; 00549 } 00550 00551 float convertHalfFloat2Float(MMS_HALF_FLOAT hf) { 00552 unsigned int sign = (unsigned int)(hf >> 15); 00553 unsigned int mantissa = (unsigned int)(hf & ((1 << 10) - 1)); 00554 unsigned int exp = (unsigned int)(hf & HALF_FLOAT_MAX_BIASED_EXP); 00555 unsigned int f; 00556 00557 if (exp == HALF_FLOAT_MAX_BIASED_EXP) { 00558 // we have a half-float NaN or Inf 00559 // half-float NaNs will be converted to a single precision NaN 00560 // half-float Infs will be converted to a single precision Inf 00561 exp = FLOAT_MAX_BIASED_EXP; 00562 if (mantissa) 00563 mantissa = (1 << 23) - 1; // set all bits to indicate a NaN 00564 } 00565 else if (exp == 0x0) { 00566 // convert half-float zero/denorm to single precision value 00567 if (mantissa) { 00568 mantissa <<= 1; 00569 exp = HALF_FLOAT_MIN_BIASED_EXP_AS_SINGLE_FP_EXP; 00570 00571 // check for leading 1 in denorm mantissa 00572 while ((mantissa & (1 << 10)) == 0) { 00573 // for every leading 0, decrement single precision exponent by 1 00574 // and shift half-float mantissa value to the left 00575 mantissa <<= 1; 00576 exp -= (1 << 23); 00577 } 00578 00579 // clamp the mantissa to 10-bits 00580 mantissa &= ((1 << 10) - 1); 00581 // shift left to generate single-precision mantissa of 23-bits 00582 mantissa <<= 13; 00583 } 00584 } 00585 else { 00586 // shift left to generate single-precision mantissa of 23-bits 00587 mantissa <<= 13; 00588 // generate single precision biased exponent value 00589 exp = (exp << 13) + HALF_FLOAT_MIN_BIASED_EXP_AS_SINGLE_FP_EXP; 00590 } 00591 00592 f = (sign << 31) | exp | mantissa; 00593 return *((float *)&f); 00594 } 00595 00596 00597 00598 bool initVertexArray(MMS_VERTEX_ARRAY *array, int eSize, int eNum, 00599 MMS_VERTEX_DATA_TYPE dtype, void *data) { 00600 if (!array) return false; 00601 array->dtype = dtype; 00602 array->data = data; 00603 if (eSize <= 0 || eNum <= 0) { 00604 array->eSize = 0; 00605 array->eNum = 0; 00606 return false; 00607 } 00608 array->eSize = eSize; 00609 array->eNum = eNum; 00610 00611 if (!array->data) { 00612 // allocate space for vertex data 00613 unsigned int len = getVertexArraySize(array); 00614 if (!len) return false; 00615 array->data = malloc(len); 00616 } 00617 00618 return true; 00619 } 00620 00621 void freeVertexArray(MMS_VERTEX_ARRAY *array) { 00622 if (array && array->data) { 00623 free(array->data); 00624 array->data = NULL; 00625 } 00626 } 00627 00628 unsigned int getVertexArraySize(MMS_VERTEX_ARRAY *array) { 00629 switch (array->dtype) { 00630 case MMS_VERTEX_DATA_TYPE_FLOAT: 00631 return sizeof(float) * array->eSize * array->eNum; 00632 case MMS_VERTEX_DATA_TYPE_HALF_FLOAT: 00633 return sizeof(MMS_HALF_FLOAT) * array->eSize * array->eNum; 00634 default: 00635 return 0; 00636 } 00637 } 00638 00639 00640 bool initIndexArray(MMS_INDEX_ARRAY *array, MMS_INDEX_ARRAY_TYPE type, int eNum, unsigned int *data) { 00641 if (!array) return false; 00642 array->type = type; 00643 array->data = data; 00644 if (eNum < 0) { 00645 array->eNum = 0; 00646 return false; 00647 } 00648 array->eNum = eNum; 00649 00650 if (!array->data) { 00651 // allocate space for index data 00652 // note: it is possible to have an index array size of 0 00653 // this means, that no index data is needed to draw primitives specified with array->type 00654 unsigned int len = getIndexArraySize(array); 00655 if (len) { 00656 array->data = (unsigned int *)malloc(len); 00657 } 00658 } 00659 00660 return true; 00661 } 00662 00663 void freeIndexArray(MMS_INDEX_ARRAY *array) { 00664 if (array && array->data) { 00665 free(array->data); 00666 array->data = NULL; 00667 } 00668 } 00669 00670 unsigned int getIndexArraySize(MMS_INDEX_ARRAY *array) { 00671 return sizeof(unsigned int) * array->eNum; 00672 } 00673 00674 00675 void multiplyMatrix(MMSMatrix result, MMSMatrix srcA, MMSMatrix srcB) { 00676 MMSMatrix tmp; 00677 00678 for (int i = 0; i < 4; i++) { 00679 tmp[i][0] = (srcA[i][0] * srcB[0][0]) + 00680 (srcA[i][1] * srcB[1][0]) + 00681 (srcA[i][2] * srcB[2][0]) + 00682 (srcA[i][3] * srcB[3][0]); 00683 00684 tmp[i][1] = (srcA[i][0] * srcB[0][1]) + 00685 (srcA[i][1] * srcB[1][1]) + 00686 (srcA[i][2] * srcB[2][1]) + 00687 (srcA[i][3] * srcB[3][1]); 00688 00689 tmp[i][2] = (srcA[i][0] * srcB[0][2]) + 00690 (srcA[i][1] * srcB[1][2]) + 00691 (srcA[i][2] * srcB[2][2]) + 00692 (srcA[i][3] * srcB[3][2]); 00693 00694 tmp[i][3] = (srcA[i][0] * srcB[0][3]) + 00695 (srcA[i][1] * srcB[1][3]) + 00696 (srcA[i][2] * srcB[2][3]) + 00697 (srcA[i][3] * srcB[3][3]); 00698 } 00699 memcpy(result, tmp, sizeof(MMSMatrix)); 00700 } 00701 00702 00703 void copyMatrix(MMSMatrix result, MMSMatrix src) { 00704 memcpy(result, src, sizeof(MMSMatrix)); 00705 } 00706 00707 bool equalMatrix(MMSMatrix result, MMSMatrix src) { 00708 return (memcmp(result, src, sizeof(MMSMatrix)) == 0); 00709 } 00710 00711 00712 00713 void loadIdentityMatrix(MMSMatrix result) { 00714 memset(result, 0x0, sizeof(MMSMatrix)); 00715 result[0][0] = 1.0f; 00716 result[1][1] = 1.0f; 00717 result[2][2] = 1.0f; 00718 result[3][3] = 1.0f; 00719 } 00720 00721 00722 void scaleMatrix(MMSMatrix result, float sx, float sy, float sz) { 00723 result[0][0] *= sx; 00724 result[0][1] *= sx; 00725 result[0][2] *= sx; 00726 result[0][3] *= sx; 00727 00728 result[1][0] *= sy; 00729 result[1][1] *= sy; 00730 result[1][2] *= sy; 00731 result[1][3] *= sy; 00732 00733 result[2][0] *= sz; 00734 result[2][1] *= sz; 00735 result[2][2] *= sz; 00736 result[2][3] *= sz; 00737 } 00738 00739 00740 void translateMatrix(MMSMatrix result, float tx, float ty, float tz) { 00741 result[3][0] += (result[0][0] * tx + result[1][0] * ty + result[2][0] * tz); 00742 result[3][1] += (result[0][1] * tx + result[1][1] * ty + result[2][1] * tz); 00743 result[3][2] += (result[0][2] * tx + result[1][2] * ty + result[2][2] * tz); 00744 result[3][3] += (result[0][3] * tx + result[1][3] * ty + result[2][3] * tz); 00745 } 00746 00747 00748 void rotateMatrix(MMSMatrix result, float angle, float x, float y, float z) { 00749 float sinAngle, cosAngle; 00750 float mag = sqrtf(x * x + y * y + z * z); 00751 00752 sinAngle = sinf (angle * MMS_PI / 180.0f); 00753 cosAngle = cosf (angle * MMS_PI / 180.0f); 00754 if (mag > 0.0f) { 00755 float xx, yy, zz, xy, yz, zx, xs, ys, zs; 00756 float oneMinusCos; 00757 MMSMatrix rotMat; 00758 00759 x /= mag; 00760 y /= mag; 00761 z /= mag; 00762 00763 xx = x * x; 00764 yy = y * y; 00765 zz = z * z; 00766 xy = x * y; 00767 yz = y * z; 00768 zx = z * x; 00769 xs = x * sinAngle; 00770 ys = y * sinAngle; 00771 zs = z * sinAngle; 00772 oneMinusCos = 1.0f - cosAngle; 00773 00774 rotMat[0][0] = (oneMinusCos * xx) + cosAngle; 00775 rotMat[0][1] = (oneMinusCos * xy) - zs; 00776 rotMat[0][2] = (oneMinusCos * zx) + ys; 00777 rotMat[0][3] = 0.0f; 00778 00779 rotMat[1][0] = (oneMinusCos * xy) + zs; 00780 rotMat[1][1] = (oneMinusCos * yy) + cosAngle; 00781 rotMat[1][2] = (oneMinusCos * yz) - xs; 00782 rotMat[1][3] = 0.0f; 00783 00784 rotMat[2][0] = (oneMinusCos * zx) - ys; 00785 rotMat[2][1] = (oneMinusCos * yz) + xs; 00786 rotMat[2][2] = (oneMinusCos * zz) + cosAngle; 00787 rotMat[2][3] = 0.0f; 00788 00789 rotMat[3][0] = 0.0f; 00790 rotMat[3][1] = 0.0f; 00791 rotMat[3][2] = 0.0f; 00792 rotMat[3][3] = 1.0f; 00793 00794 multiplyMatrix(result, rotMat, result); 00795 } 00796 } 00797 00798 00799 void frustumMatrix(MMSMatrix result, float left, float right, float bottom, float top, float nearZ, float farZ) { 00800 float deltaX = right - left; 00801 float deltaY = top - bottom; 00802 float deltaZ = farZ - nearZ; 00803 00804 if ( (nearZ <= 0.0f) || (farZ <= 0.0f) || 00805 (deltaX <= 0.0f) || (deltaY <= 0.0f) || (deltaZ <= 0.0f) ) 00806 return; 00807 00808 MMSMatrix frust; 00809 frust[0][0] = 2.0f * nearZ / deltaX; 00810 frust[0][1] = frust[0][2] = frust[0][3] = 0.0f; 00811 00812 frust[1][1] = 2.0f * nearZ / deltaY; 00813 frust[1][0] = frust[1][2] = frust[1][3] = 0.0f; 00814 00815 frust[2][0] = (right + left) / deltaX; 00816 frust[2][1] = (top + bottom) / deltaY; 00817 frust[2][2] = -(nearZ + farZ) / deltaZ; 00818 frust[2][3] = -1.0f; 00819 00820 frust[3][2] = -2.0f * nearZ * farZ / deltaZ; 00821 frust[3][0] = frust[3][1] = frust[3][3] = 0.0f; 00822 00823 multiplyMatrix(result, frust, result); 00824 } 00825 00826 00827 void perspectiveMatrix(MMSMatrix result, float fovy, float aspect, float nearZ, float farZ) { 00828 float frustumW, frustumH; 00829 00830 frustumH = tanf(fovy / 360.0f * MMS_PI) * nearZ; 00831 frustumW = frustumH * aspect; 00832 00833 frustumMatrix(result, -frustumW, frustumW, -frustumH, frustumH, nearZ, farZ); 00834 } 00835 00836 void orthoMatrix(MMSMatrix result, float left, float right, float bottom, float top, float nearZ, float farZ) { 00837 float deltaX = right - left; 00838 float deltaY = top - bottom; 00839 float deltaZ = farZ - nearZ; 00840 00841 if ((deltaX == 0.0f) || (deltaY == 0.0f) || (deltaZ == 0.0f)) 00842 return; 00843 00844 MMSMatrix ortho; 00845 memset(ortho, 0, sizeof(ortho)); 00846 loadIdentityMatrix(ortho); 00847 ortho[0][0] = 2.0f / deltaX; 00848 ortho[3][0] = -(right + left) / deltaX; 00849 ortho[1][1] = 2.0f / deltaY; 00850 ortho[3][1] = -(top + bottom) / deltaY; 00851 ortho[2][2] = -2.0f / deltaZ; 00852 ortho[3][2] = -(nearZ + farZ) / deltaZ; 00853 00854 multiplyMatrix(result, ortho, result); 00855 } 00856 00857 00858 bool isMMS3DObjectShown(MMS3D_OBJECT *object) { 00859 if (!object->shown) { 00860 return false; 00861 } 00862 if (object->parent) { 00863 return isMMS3DObjectShown(object->parent); 00864 } 00865 return true; 00866 } 00867 00868 00869 00870
Generated by
