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