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 return MMSLANG_NONE_STR; 00462 } 00463 00464 MMSLanguage getMMSLanguageFromString(string lang) { 00465 strToUpr(&lang); 00466 if (lang == MMSLANG_NONE_STR) 00467 return MMSLANG_NONE; 00468 if (lang == MMSLANG_DE_STR) 00469 return MMSLANG_DE; 00470 if (lang == MMSLANG_EN_STR) 00471 return MMSLANG_EN; 00472 if (lang == MMSLANG_DK_STR) 00473 return MMSLANG_DK; 00474 if (lang == MMSLANG_ES_STR) 00475 return MMSLANG_ES; 00476 if (lang == MMSLANG_FI_STR) 00477 return MMSLANG_FI; 00478 if (lang == MMSLANG_FR_STR) 00479 return MMSLANG_FR; 00480 if (lang == MMSLANG_IT_STR) 00481 return MMSLANG_IT; 00482 if (lang == MMSLANG_NL_STR) 00483 return MMSLANG_NL; 00484 if (lang == MMSLANG_NO_STR) 00485 return MMSLANG_NO; 00486 if (lang == MMSLANG_SE_STR) 00487 return MMSLANG_SE; 00488 if (lang == MMSLANG_TR_STR) 00489 return MMSLANG_TR; 00490 if (lang == MMSLANG_CN_STR) 00491 return MMSLANG_CN; 00492 if (lang == MMSLANG_IL_STR) 00493 return MMSLANG_IL; 00494 if (lang == MMSLANG_AR_STR) 00495 return MMSLANG_AR; 00496 if (lang == MMSLANG_CS_STR) 00497 return MMSLANG_CS; 00498 if (lang == MMSLANG_RU_STR) 00499 return MMSLANG_RU; 00500 return MMSLANG_NONE; 00501 } 00502 00503 00504 00505 00506 MMS_HALF_FLOAT convertFloat2HalfFloat(float f) { 00507 unsigned int x = *(unsigned int *)&f; 00508 unsigned int sign = (unsigned short)(x >> 31); 00509 unsigned int mantissa; 00510 unsigned int exp; 00511 MMS_HALF_FLOAT hf; 00512 00513 // get mantissa 00514 mantissa = x & ((1 << 23) - 1); 00515 00516 // get exponent bits 00517 exp = x & FLOAT_MAX_BIASED_EXP; 00518 00519 if (exp >= HALF_FLOAT_MAX_BIASED_EXP_AS_SINGLE_FP_EXP) { 00520 // check if the original single precision float number is a NaN 00521 if (mantissa && (exp == FLOAT_MAX_BIASED_EXP)) { 00522 // we have a single precision NaN 00523 mantissa = (1 << 23) - 1; 00524 } 00525 else { 00526 // 16-bit half-float representation stores number as Inf 00527 mantissa = 0; 00528 } 00529 00530 hf = (((MMS_HALF_FLOAT)sign) << 15) | (MMS_HALF_FLOAT)(HALF_FLOAT_MAX_BIASED_EXP) | (MMS_HALF_FLOAT)(mantissa >> 13); 00531 } 00532 // check if exponent is <= -15 00533 else if (exp <= HALF_FLOAT_MIN_BIASED_EXP_AS_SINGLE_FP_EXP) { 00534 // store a denorm half-float value or zero 00535 exp = (HALF_FLOAT_MIN_BIASED_EXP_AS_SINGLE_FP_EXP - exp) >> 23; 00536 mantissa >>= (14 + exp); 00537 hf = (((MMS_HALF_FLOAT)sign) << 15) | (MMS_HALF_FLOAT)(mantissa); 00538 } 00539 else { 00540 hf = (((MMS_HALF_FLOAT)sign) << 15) | (MMS_HALF_FLOAT)((exp - HALF_FLOAT_MIN_BIASED_EXP_AS_SINGLE_FP_EXP) >> 13) | 00541 (MMS_HALF_FLOAT)(mantissa >> 13); 00542 } 00543 00544 return hf; 00545 } 00546 00547 float convertHalfFloat2Float(MMS_HALF_FLOAT hf) { 00548 unsigned int sign = (unsigned int)(hf >> 15); 00549 unsigned int mantissa = (unsigned int)(hf & ((1 << 10) - 1)); 00550 unsigned int exp = (unsigned int)(hf & HALF_FLOAT_MAX_BIASED_EXP); 00551 unsigned int f; 00552 00553 if (exp == HALF_FLOAT_MAX_BIASED_EXP) { 00554 // we have a half-float NaN or Inf 00555 // half-float NaNs will be converted to a single precision NaN 00556 // half-float Infs will be converted to a single precision Inf 00557 exp = FLOAT_MAX_BIASED_EXP; 00558 if (mantissa) 00559 mantissa = (1 << 23) - 1; // set all bits to indicate a NaN 00560 } 00561 else if (exp == 0x0) { 00562 // convert half-float zero/denorm to single precision value 00563 if (mantissa) { 00564 mantissa <<= 1; 00565 exp = HALF_FLOAT_MIN_BIASED_EXP_AS_SINGLE_FP_EXP; 00566 00567 // check for leading 1 in denorm mantissa 00568 while ((mantissa & (1 << 10)) == 0) { 00569 // for every leading 0, decrement single precision exponent by 1 00570 // and shift half-float mantissa value to the left 00571 mantissa <<= 1; 00572 exp -= (1 << 23); 00573 } 00574 00575 // clamp the mantissa to 10-bits 00576 mantissa &= ((1 << 10) - 1); 00577 // shift left to generate single-precision mantissa of 23-bits 00578 mantissa <<= 13; 00579 } 00580 } 00581 else { 00582 // shift left to generate single-precision mantissa of 23-bits 00583 mantissa <<= 13; 00584 // generate single precision biased exponent value 00585 exp = (exp << 13) + HALF_FLOAT_MIN_BIASED_EXP_AS_SINGLE_FP_EXP; 00586 } 00587 00588 f = (sign << 31) | exp | mantissa; 00589 return *((float *)&f); 00590 } 00591 00592 00593 00594 bool initVertexArray(MMS_VERTEX_ARRAY *array, int eSize, int eNum, 00595 MMS_VERTEX_DATA_TYPE dtype, void *data) { 00596 if (!array) return false; 00597 array->dtype = dtype; 00598 array->data = data; 00599 if (eSize <= 0 || eNum <= 0) { 00600 array->eSize = 0; 00601 array->eNum = 0; 00602 return false; 00603 } 00604 array->eSize = eSize; 00605 array->eNum = eNum; 00606 00607 if (!array->data) { 00608 // allocate space for vertex data 00609 unsigned int len = getVertexArraySize(array); 00610 if (!len) return false; 00611 array->data = malloc(len); 00612 } 00613 00614 return true; 00615 } 00616 00617 void freeVertexArray(MMS_VERTEX_ARRAY *array) { 00618 if (array && array->data) { 00619 free(array->data); 00620 array->data = NULL; 00621 } 00622 } 00623 00624 unsigned int getVertexArraySize(MMS_VERTEX_ARRAY *array) { 00625 switch (array->dtype) { 00626 case MMS_VERTEX_DATA_TYPE_FLOAT: 00627 return sizeof(float) * array->eSize * array->eNum; 00628 case MMS_VERTEX_DATA_TYPE_HALF_FLOAT: 00629 return sizeof(MMS_HALF_FLOAT) * array->eSize * array->eNum; 00630 default: 00631 return 0; 00632 } 00633 } 00634 00635 00636 bool initIndexArray(MMS_INDEX_ARRAY *array, MMS_INDEX_ARRAY_TYPE type, int eNum, unsigned int *data) { 00637 if (!array) return false; 00638 array->type = type; 00639 array->data = data; 00640 if (eNum < 0) { 00641 array->eNum = 0; 00642 return false; 00643 } 00644 array->eNum = eNum; 00645 00646 if (!array->data) { 00647 // allocate space for index data 00648 // note: it is possible to have an index array size of 0 00649 // this means, that no index data is needed to draw primitives specified with array->type 00650 unsigned int len = getIndexArraySize(array); 00651 if (len) { 00652 array->data = (unsigned int *)malloc(len); 00653 } 00654 } 00655 00656 return true; 00657 } 00658 00659 void freeIndexArray(MMS_INDEX_ARRAY *array) { 00660 if (array && array->data) { 00661 free(array->data); 00662 array->data = NULL; 00663 } 00664 } 00665 00666 unsigned int getIndexArraySize(MMS_INDEX_ARRAY *array) { 00667 return sizeof(unsigned int) * array->eNum; 00668 } 00669 00670 00671 void multiplyMatrix(MMSMatrix result, MMSMatrix srcA, MMSMatrix srcB) { 00672 MMSMatrix tmp; 00673 00674 for (int i = 0; i < 4; i++) { 00675 tmp[i][0] = (srcA[i][0] * srcB[0][0]) + 00676 (srcA[i][1] * srcB[1][0]) + 00677 (srcA[i][2] * srcB[2][0]) + 00678 (srcA[i][3] * srcB[3][0]); 00679 00680 tmp[i][1] = (srcA[i][0] * srcB[0][1]) + 00681 (srcA[i][1] * srcB[1][1]) + 00682 (srcA[i][2] * srcB[2][1]) + 00683 (srcA[i][3] * srcB[3][1]); 00684 00685 tmp[i][2] = (srcA[i][0] * srcB[0][2]) + 00686 (srcA[i][1] * srcB[1][2]) + 00687 (srcA[i][2] * srcB[2][2]) + 00688 (srcA[i][3] * srcB[3][2]); 00689 00690 tmp[i][3] = (srcA[i][0] * srcB[0][3]) + 00691 (srcA[i][1] * srcB[1][3]) + 00692 (srcA[i][2] * srcB[2][3]) + 00693 (srcA[i][3] * srcB[3][3]); 00694 } 00695 memcpy(result, tmp, sizeof(MMSMatrix)); 00696 } 00697 00698 00699 void copyMatrix(MMSMatrix result, MMSMatrix src) { 00700 memcpy(result, src, sizeof(MMSMatrix)); 00701 } 00702 00703 bool equalMatrix(MMSMatrix result, MMSMatrix src) { 00704 return (memcmp(result, src, sizeof(MMSMatrix)) == 0); 00705 } 00706 00707 00708 00709 void loadIdentityMatrix(MMSMatrix result) { 00710 memset(result, 0x0, sizeof(MMSMatrix)); 00711 result[0][0] = 1.0f; 00712 result[1][1] = 1.0f; 00713 result[2][2] = 1.0f; 00714 result[3][3] = 1.0f; 00715 } 00716 00717 00718 void scaleMatrix(MMSMatrix result, float sx, float sy, float sz) { 00719 result[0][0] *= sx; 00720 result[0][1] *= sx; 00721 result[0][2] *= sx; 00722 result[0][3] *= sx; 00723 00724 result[1][0] *= sy; 00725 result[1][1] *= sy; 00726 result[1][2] *= sy; 00727 result[1][3] *= sy; 00728 00729 result[2][0] *= sz; 00730 result[2][1] *= sz; 00731 result[2][2] *= sz; 00732 result[2][3] *= sz; 00733 } 00734 00735 00736 void translateMatrix(MMSMatrix result, float tx, float ty, float tz) { 00737 result[3][0] += (result[0][0] * tx + result[1][0] * ty + result[2][0] * tz); 00738 result[3][1] += (result[0][1] * tx + result[1][1] * ty + result[2][1] * tz); 00739 result[3][2] += (result[0][2] * tx + result[1][2] * ty + result[2][2] * tz); 00740 result[3][3] += (result[0][3] * tx + result[1][3] * ty + result[2][3] * tz); 00741 } 00742 00743 00744 void rotateMatrix(MMSMatrix result, float angle, float x, float y, float z) { 00745 float sinAngle, cosAngle; 00746 float mag = sqrtf(x * x + y * y + z * z); 00747 00748 sinAngle = sinf (angle * MMS_PI / 180.0f); 00749 cosAngle = cosf (angle * MMS_PI / 180.0f); 00750 if (mag > 0.0f) { 00751 float xx, yy, zz, xy, yz, zx, xs, ys, zs; 00752 float oneMinusCos; 00753 MMSMatrix rotMat; 00754 00755 x /= mag; 00756 y /= mag; 00757 z /= mag; 00758 00759 xx = x * x; 00760 yy = y * y; 00761 zz = z * z; 00762 xy = x * y; 00763 yz = y * z; 00764 zx = z * x; 00765 xs = x * sinAngle; 00766 ys = y * sinAngle; 00767 zs = z * sinAngle; 00768 oneMinusCos = 1.0f - cosAngle; 00769 00770 rotMat[0][0] = (oneMinusCos * xx) + cosAngle; 00771 rotMat[0][1] = (oneMinusCos * xy) - zs; 00772 rotMat[0][2] = (oneMinusCos * zx) + ys; 00773 rotMat[0][3] = 0.0f; 00774 00775 rotMat[1][0] = (oneMinusCos * xy) + zs; 00776 rotMat[1][1] = (oneMinusCos * yy) + cosAngle; 00777 rotMat[1][2] = (oneMinusCos * yz) - xs; 00778 rotMat[1][3] = 0.0f; 00779 00780 rotMat[2][0] = (oneMinusCos * zx) - ys; 00781 rotMat[2][1] = (oneMinusCos * yz) + xs; 00782 rotMat[2][2] = (oneMinusCos * zz) + cosAngle; 00783 rotMat[2][3] = 0.0f; 00784 00785 rotMat[3][0] = 0.0f; 00786 rotMat[3][1] = 0.0f; 00787 rotMat[3][2] = 0.0f; 00788 rotMat[3][3] = 1.0f; 00789 00790 multiplyMatrix(result, rotMat, result); 00791 } 00792 } 00793 00794 00795 void frustumMatrix(MMSMatrix result, float left, float right, float bottom, float top, float nearZ, float farZ) { 00796 float deltaX = right - left; 00797 float deltaY = top - bottom; 00798 float deltaZ = farZ - nearZ; 00799 00800 if ( (nearZ <= 0.0f) || (farZ <= 0.0f) || 00801 (deltaX <= 0.0f) || (deltaY <= 0.0f) || (deltaZ <= 0.0f) ) 00802 return; 00803 00804 MMSMatrix frust; 00805 frust[0][0] = 2.0f * nearZ / deltaX; 00806 frust[0][1] = frust[0][2] = frust[0][3] = 0.0f; 00807 00808 frust[1][1] = 2.0f * nearZ / deltaY; 00809 frust[1][0] = frust[1][2] = frust[1][3] = 0.0f; 00810 00811 frust[2][0] = (right + left) / deltaX; 00812 frust[2][1] = (top + bottom) / deltaY; 00813 frust[2][2] = -(nearZ + farZ) / deltaZ; 00814 frust[2][3] = -1.0f; 00815 00816 frust[3][2] = -2.0f * nearZ * farZ / deltaZ; 00817 frust[3][0] = frust[3][1] = frust[3][3] = 0.0f; 00818 00819 multiplyMatrix(result, frust, result); 00820 } 00821 00822 00823 void perspectiveMatrix(MMSMatrix result, float fovy, float aspect, float nearZ, float farZ) { 00824 float frustumW, frustumH; 00825 00826 frustumH = tanf(fovy / 360.0f * MMS_PI) * nearZ; 00827 frustumW = frustumH * aspect; 00828 00829 frustumMatrix(result, -frustumW, frustumW, -frustumH, frustumH, nearZ, farZ); 00830 } 00831 00832 void orthoMatrix(MMSMatrix result, float left, float right, float bottom, float top, float nearZ, float farZ) { 00833 float deltaX = right - left; 00834 float deltaY = top - bottom; 00835 float deltaZ = farZ - nearZ; 00836 00837 if ((deltaX == 0.0f) || (deltaY == 0.0f) || (deltaZ == 0.0f)) 00838 return; 00839 00840 MMSMatrix ortho; 00841 loadIdentityMatrix(ortho); 00842 ortho[0][0] = 2.0f / deltaX; 00843 ortho[3][0] = -(right + left) / deltaX; 00844 ortho[1][1] = 2.0f / deltaY; 00845 ortho[3][1] = -(top + bottom) / deltaY; 00846 ortho[2][2] = -2.0f / deltaZ; 00847 ortho[3][2] = -(nearZ + farZ) / deltaZ; 00848 00849 multiplyMatrix(result, ortho, result); 00850 } 00851 00852 00853 bool isMMS3DObjectShown(MMS3D_OBJECT *object) { 00854 if (!object->shown) { 00855 return false; 00856 } 00857 if (object->parent) { 00858 return isMMS3DObjectShown(object->parent); 00859 } 00860 return true; 00861 } 00862 00863 00864 00865
Generated by
