scilab/modules/graphic_objects/src/cpp/Texture.cpp

   1 /*
   2  *  Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
   3  *  Copyright (C) 2013 - Scilab Enterprises - Calixte DENIZET
   4  *
   5  *  This file must be used under the terms of the CeCILL.
   6  *  This source file is licensed as described in the file COPYING, which
   7  *  you should have received as part of this distribution.  The terms
   8  *  are also available at
   9  *  http://www.cecill.info/licences/Licence_CeCILL_V2.1-en.txt
  10  *
  11  */
  12
  13 #include "Texture.hxx"
  14 #include <cstring>
  15
  16 float Texture::GrayR[256];
  17 float Texture::GrayG[256];
  18 float Texture::GrayB[256];
  19 unsigned char Texture::RGB8R[256];
  20 unsigned char Texture::RGB8G[256];
  21 unsigned char Texture::RGB8B[256];
  22 unsigned char Texture::R12[256];
  23 const bool Texture::isGrayTableInit = Texture::initGrayTables();
  24 const bool Texture::isRGB8TableInit = Texture::initRGB8Tables();
  25 const bool Texture::isR12TableInit = Texture::initR12Table();
  26
  27 #define _DOUBLE_TO_UCHAR_(x) ((x) < 0 ? 0 : ((x) > 1 ? 0xFF : ((unsigned char)((x) * 0xFF))))
  28
  29 bool Texture::getImage(void const * data, const int numElements, const DataType datatype, const ImageType imagetype, void ** dest, unsigned int * dataSize, GLType * gltype)
  30 {
  31     unsigned int size = 0;
  32     bool ret = false;
  33
  34     switch (imagetype)
  35     {
  36         case MATPLOT_RGB :
  37             switch (datatype)
  38             {
  39                 case MATPLOT_HM3_Char :
  40                 case MATPLOT_HM3_UChar :
  41                 case MATPLOT_HM4_Char :
  42                 case MATPLOT_HM4_UChar :
  43                     size = numElements * sizeof(int);
  44                     break;
  45                 case MATPLOT_HM3_Double :
  46                 case MATPLOT_HM4_Double :
  47                     size = numElements * sizeof(float) * 3;
  48                     break;
  49                 case MATPLOT_HM1_Char :
  50                 case MATPLOT_HM1_UChar :
  51                 case MATPLOT_UChar :
  52                 case MATPLOT_Char :
  53                     size = numElements * 3;
  54                     break;
  55                 case MATPLOT_Int :
  56                 case MATPLOT_UInt :
  57                     size = numElements * sizeof(int);
  58                     break;
  59                 case MATPLOT_Short :
  60                 case MATPLOT_UShort :
  61                     size = numElements * sizeof(short);
  62                     break;
  63                 case MATPLOT_HM1_Double :
  64                 case MATPLOT_Double :
  65                     size = numElements * sizeof(int);
  66                     break;
  67             }
  68             break;
  69         case MATPLOT_RGBA :
  70             switch (datatype)
  71             {
  72                 case MATPLOT_HM3_Char :
  73                 case MATPLOT_HM3_UChar :
  74                 case MATPLOT_HM4_Char :
  75                 case MATPLOT_HM4_UChar :
  76                     size = numElements * sizeof(int);
  77                     break;
  78                 case MATPLOT_HM3_Double :
  79                 case MATPLOT_HM4_Double :
  80                     size = numElements * sizeof(float) * 4;
  81                     break;
  82                 case MATPLOT_HM1_Char :
  83                 case MATPLOT_HM1_UChar :
  84                 case MATPLOT_UChar :
  85                 case MATPLOT_Char :
  86                     size = numElements * 4;
  87                     break;
  88                 case MATPLOT_Int :
  89                 case MATPLOT_UInt :
  90                     size = numElements * sizeof(int);
  91                     break;
  92                 case MATPLOT_Short :
  93                 case MATPLOT_UShort :
  94                     size = numElements * sizeof(short);
  95                     break;
  96                 case MATPLOT_HM1_Double :
  97                 case MATPLOT_Double :
  98                     size = numElements * sizeof(int);
  99                     break;
 100             }
 101             break;
 102         case MATPLOT_GRAY :
 103         case MATPLOT_RED :
 104         case MATPLOT_GREEN :
 105         case MATPLOT_BLUE :
 106             if (datatype == MATPLOT_Short || datatype == MATPLOT_UShort)
 107             {
 108                 size = numElements * sizeof(short);
 109             }
 110             else if (datatype == MATPLOT_HM3_Double || datatype == MATPLOT_HM4_Double || datatype == MATPLOT_Double)
 111             {
 112                 size = numElements * sizeof(float);
 113             }
 114             else
 115             {
 116                 size = numElements;
 117             }
 118             break;
 119         case MATPLOT_INDEX :
 120             switch (datatype)
 121             {
 122                 case MATPLOT_HM1_Char :
 123                 case MATPLOT_HM1_UChar :
 124                 case MATPLOT_UChar :
 125                 case MATPLOT_Char :
 126                     size = numElements;
 127                     break;
 128                 case MATPLOT_Int :
 129                 case MATPLOT_UInt :
 130                     size = numElements * sizeof(int);
 131                     break;
 132                 case MATPLOT_Short :
 133                 case MATPLOT_UShort :
 134                     size = numElements * sizeof(short);
 135                     break;
 136                 case MATPLOT_HM1_Double :
 137                 case MATPLOT_Double :
 138                     size = numElements * sizeof(double);
 139                     break;
 140             }
 141             break;
 142         case MATPLOT_RGB_332 :
 143             size = numElements;
 144             break;
 145         case MATPLOT_RGB_444 :
 146         case MATPLOT_RGB_555 :
 147         case MATPLOT_RGBA_4444 :
 148         case MATPLOT_RGBA_5551 :
 149             size = numElements * sizeof(short);
 150             break;
 151     }
 152
 153     if (size != *dataSize)
 154     {
 155         ret = true;
 156         *dataSize = size;
 157         *dest = new unsigned char[size];
 158     }
 159
 160     switch (imagetype)
 161     {
 162         case MATPLOT_RGB :
 163         {
 164             switch (datatype)
 165             {
 166                 case MATPLOT_HM3_Char :
 167                 case MATPLOT_HM3_UChar :
 168                 case MATPLOT_HM4_Char :
 169                 case MATPLOT_HM4_UChar :
 170                 {
 171                     const unsigned char * R = (const unsigned char *)data;
 172                     const unsigned char * G = R + numElements;
 173                     const unsigned char * B = G + numElements;
 174                     unsigned char * ucdata = (unsigned char *) * dest;
 175                     unsigned int k = 0;
 176
 177                     for (int i = 0; i < numElements; i++)
 178                     {
 179                         ucdata[k] = R[i];
 180                         ucdata[k + 1] = G[i];
 181                         ucdata[k + 2] = B[i];
 182                         k += 3;
 183                     }
 184                     *gltype = MATPLOT_GL_RGB;
 185                     break;
 186                 }
 187                 case MATPLOT_HM3_Double :
 188                 case MATPLOT_HM4_Double :
 189                 {
 190                     const double * R = (const double *)data;
 191                     const double * G = R + numElements;
 192                     const double * B = G + numElements;
 193                     float * fdata = (float *) * dest;
 194                     unsigned int k = 0;
 195
 196                     for (int i = 0; i < numElements; i++)
 197                     {
 198                         fdata[k] = (float)R[i];
 199                         fdata[k + 1] = (float)G[i];
 200                         fdata[k + 2] = (float)B[i];
 201                         k += 3;
 202                     }
 203
 204                     *gltype = MATPLOT_GL_RGB_FLOAT;
 205                     break;
 206                 }
 207                 case MATPLOT_HM1_Char :
 208                 case MATPLOT_HM1_UChar :
 209                 case MATPLOT_Char :
 210                 case MATPLOT_UChar :
 211                     memcpy(*dest, data, size);
 212                     *gltype = MATPLOT_GL_RGB;
 213                     break;
 214                 case MATPLOT_Int :
 215                 {
 216                     const unsigned int * ui = (const unsigned int *)data;
 217                     unsigned char * ucdata = (unsigned char *) * dest;
 218                     unsigned int k = 0;
 219
 220                     for (int i = 0; i < numElements; i++)
 221                     {
 222                         ucdata[k] = (ui[i] >> 16) & 0xFF;
 223                         ucdata[k + 1] = (ui[i] >> 8) & 0xFF;
 224                         ucdata[k + 2] = ui[i] & 0xFF;
 225                         k += 3;
 226                     }
 227
 228                     *gltype = MATPLOT_GL_RGB;
 229                     break;
 230                 }
 231                 case MATPLOT_UInt :
 232                 {
 233                     const unsigned int * ui = (const unsigned int *)data;
 234                     unsigned char * ucdata = (unsigned char *) * dest;
 235                     unsigned int k = 0;
 236
 237                     for (int i = 0; i < numElements; i++)
 238                     {
 239                         ucdata[k] = (ui[i] >> 24) & 0xFF;
 240                         ucdata[k + 1] = (ui[i] >> 16) & 0xFF;
 241                         ucdata[k + 2] = (ui[i] >> 8) & 0xFF;
 242                         k += 3;
 243                     }
 244
 245                     *gltype = MATPLOT_GL_RGB;
 246                     break;
 247                 }
 248                 case MATPLOT_Short :
 249                 {
 250                     memcpy(*dest, data, size);
 251                     *gltype = MATPLOT_GL_RGBA_4444;
 252                     break;
 253                 }
 254                 case MATPLOT_UShort :
 255                 {
 256                     memcpy(*dest, data, size);
 257                     *gltype = MATPLOT_GL_RGBA_5551;
 258                     break;
 259                 }
 260                 case MATPLOT_HM1_Double :
 261                 case MATPLOT_Double :
 262                 {
 263                     const double * d = (const double *)data;
 264                     unsigned char * ucdata = (unsigned char *) * dest;
 265                     unsigned int k = 0;
 266
 267                     for (int i = 0; i < numElements; i++)
 268                     {
 269                         ucdata[k] = (((unsigned int)d[i]) >> 16) & 0xFF;
 270                         ucdata[k + 1] = (((unsigned int)d[i]) >> 8) & 0xFF;
 271                         ucdata[k + 2] = ((unsigned int)d[i]) & 0xFF;
 272                         k += 3;
 273                     }
 274                     *gltype = MATPLOT_GL_RGB;
 275                     break;
 276                 }
 277             }
 278             break;
 279         }
 280         case MATPLOT_RGBA :
 281         {
 282             switch (datatype)
 283             {
 284                 case MATPLOT_HM3_Char :
 285                 case MATPLOT_HM3_UChar :
 286                 {
 287                     const unsigned char * R = (const unsigned char *)data;
 288                     const unsigned char * G = R + numElements;
 289                     const unsigned char * B = G + numElements;
 290                     unsigned char * ucdata = (unsigned char *) * dest;
 291                     unsigned int k = 0;
 292
 293                     for (int i = 0; i < numElements; i++)
 294                     {
 295                         ucdata[k] = R[i];
 296                         ucdata[k + 1] = G[i];
 297                         ucdata[k + 2] = B[i];
 298                         ucdata[k + 3] = 0xFF;
 299                         k += 4;
 300                     }
 301                     *gltype = MATPLOT_GL_RGBA_BYTE;
 302                     break;
 303                 }
 304                 case MATPLOT_HM4_Char :
 305                 case MATPLOT_HM4_UChar :
 306                 {
 307                     const unsigned char * R = (const unsigned char *)data;
 308                     const unsigned char * G = R + numElements;
 309                     const unsigned char * B = G + numElements;
 310                     const unsigned char * A = B + numElements;
 311                     unsigned char * ucdata = (unsigned char *) * dest;
 312                     unsigned int k = 0;
 313
 314                     for (int i = 0; i < numElements; i++)
 315                     {
 316                         ucdata[k] = R[i];
 317                         ucdata[k + 1] = G[i];
 318                         ucdata[k + 2] = B[i];
 319                         ucdata[k + 3] = A[i];
 320                         k += 4;
 321                     }
 322                     *gltype = MATPLOT_GL_RGBA_BYTE;
 323                     break;
 324                 }
 325                 case MATPLOT_HM3_Double :
 326                 {
 327                     const double * R = (const double *)data;
 328                     const double * G = R + numElements;
 329                     const double * B = G + numElements;
 330                     float * fdata = (float *) * dest;
 331                     unsigned int k = 0;
 332
 333                     for (int i = 0; i < numElements; i++)
 334                     {
 335                         fdata[k] = (float)R[i];
 336                         fdata[k + 1] = (float)G[i];
 337                         fdata[k + 2] = (float)B[i];
 338                         fdata[k + 3] = 1.0f;
 339                         k += 4;
 340                     }
 341                     *gltype = MATPLOT_GL_RGBA_FLOAT;
 342                     break;
 343                 }
 344                 case MATPLOT_HM4_Double :
 345                 {
 346                     const double * R = (const double *)data;
 347                     const double * G = R + numElements;
 348                     const double * B = G + numElements;
 349                     const double * A = B + numElements;
 350                     float * fdata = (float *) * dest;
 351                     unsigned int k = 0;
 352
 353                     for (int i = 0; i < numElements; i++)
 354                     {
 355                         fdata[k] = (float)R[i];
 356                         fdata[k + 1] = (float)G[i];
 357                         fdata[k + 2] = (float)B[i];
 358                         fdata[k + 3] = (float)A[i];
 359                         k += 4;
 360                     }
 361                     *gltype = MATPLOT_GL_RGBA_FLOAT;
 362                     break;
 363                 }
 364                 case MATPLOT_HM1_Char :
 365                 case MATPLOT_HM1_UChar :
 366                 case MATPLOT_UChar :
 367                 case MATPLOT_Char :
 368                     memcpy(*dest, data, size);
 369                     *gltype = MATPLOT_GL_RGBA_BYTE;
 370                     break;
 371                 case MATPLOT_Int :
 372                 {
 373                     const unsigned int * ui = (const unsigned int *)data;
 374                     unsigned char * ucdata = (unsigned char *) * dest;
 375                     unsigned int k = 0;
 376
 377                     for (int i = 0; i < numElements; i++)
 378                     {
 379                         ucdata[k] = (ui[i] >> 16) & 0xFF;
 380                         ucdata[k + 1] = (ui[i] >> 8) & 0xFF;
 381                         ucdata[k + 2] = ui[i] & 0xFF;
 382                         ucdata[k + 3] = 0xFF;
 383                         k += 4;
 384                     }
 385                     *gltype = MATPLOT_GL_RGBA_BYTE;
 386                     break;
 387                 }
 388                 case MATPLOT_UInt :
 389                 {
 390                     const unsigned int * ui = (const unsigned int *)data;
 391                     unsigned char * ucdata = (unsigned char *) * dest;
 392                     unsigned int k = 0;
 393
 394                     for (int i = 0; i < numElements; i++)
 395                     {
 396                         ucdata[k] = (ui[i] >> 24) & 0xFF;
 397                         ucdata[k + 1] = (ui[i] >> 16) & 0xFF;
 398                         ucdata[k + 2] = (ui[i] >> 8) & 0xFF;
 399                         ucdata[k + 3] = ui[i] & 0xFF;
 400                         k += 4;
 401                     }
 402                     *gltype = MATPLOT_GL_RGBA_BYTE;
 403                     break;
 404                 }
 405                 case MATPLOT_Short :
 406                 {
 407                     memcpy(*dest, data, size);
 408                     *gltype = MATPLOT_GL_RGBA_4444;
 409                     break;
 410                 }
 411                 case MATPLOT_UShort :
 412                 {
 413                     memcpy(*dest, data, size);
 414                     *gltype = MATPLOT_GL_RGBA_5551;
 415                     break;
 416                 }
 417                 case MATPLOT_HM1_Double :
 418                 case MATPLOT_Double :
 419                 {
 420                     const double * d = (const double *)data;
 421                     unsigned char * ucdata = (unsigned char *) * dest;
 422                     unsigned int k = 0;
 423
 424                     for (int i = 0; i < numElements; i++)
 425                     {
 426                         ucdata[k] = (((unsigned int)d[i]) >> 24) & 0xFF;
 427                         ucdata[k + 1] = (((unsigned int)d[i]) >> 16) & 0xFF;
 428                         ucdata[k + 2] = (((unsigned int)d[i]) >> 8) & 0xFF;
 429                         ucdata[k + 3] = ((unsigned int)d[i]) & 0xFF;
 430                         unsigned int k = 0;
 431                     }
 432                     *gltype = MATPLOT_GL_RGBA_BYTE;
 433                 }
 434             }
 435             break;
 436         }
 437         case MATPLOT_GRAY :
 438         {
 439             switch (datatype)
 440             {
 441                 case MATPLOT_HM3_Char :
 442                 case MATPLOT_HM3_UChar :
 443                 case MATPLOT_HM4_Char :
 444                 case MATPLOT_HM4_UChar :
 445                 {
 446                     const unsigned char * R = (const unsigned char *)data;
 447                     const unsigned char * G = R + numElements;
 448                     const unsigned char * B = G + numElements;
 449                     unsigned char * ucdata = (unsigned char *) * dest;
 450
 451                     for (int i = 0; i < numElements; i++)
 452                     {
 453                         ucdata[i] = (unsigned char) (GrayR[R[i]] + GrayG[G[i]] + GrayB[B[i]]);
 454                     }
 455                     *gltype = MATPLOT_GL_GRAY;
 456                     break;
 457                 }
 458                 case MATPLOT_HM3_Double :
 459                 case MATPLOT_HM4_Double :
 460                 {
 461                     const double * R = (const double *)data;
 462                     const double * G = R + numElements;
 463                     const double * B = G + numElements;
 464                     float * fdata = (float *) * dest;
 465
 466                     for (int i = 0; i < numElements; i++)
 467                     {
 468                         fdata[i] = (float) (0.299 * R[i] + 0.587 * G[i] + 0.114 * B[i]);
 469                     }
 470                     *gltype = MATPLOT_GL_GRAY_FLOAT;
 471                     break;
 472                 }
 473                 case MATPLOT_HM1_Char :
 474                 case MATPLOT_HM1_UChar :
 475                 case MATPLOT_UChar :
 476                 case MATPLOT_Char :
 477                 {
 478                     memcpy(*dest, data, size);
 479                     *gltype = MATPLOT_GL_GRAY;
 480                     break;
 481                 }
 482                 case MATPLOT_UShort :
 483                 case MATPLOT_Short :
 484                 {
 485                     memcpy(*dest, data, size);
 486                     *gltype = MATPLOT_GL_GRAY_16;
 487                     break;
 488                 }
 489                 case MATPLOT_Int :
 490                 {
 491                     const unsigned int * ui = (const unsigned int *)data;
 492                     unsigned char * ucdata = (unsigned char *) * dest;
 493
 494                     for (int i = 0; i < numElements; i++)
 495                     {
 496                         ucdata[i] = (unsigned char) (GrayR[(ui[i] >> 24) & 0xFF] + GrayG[(ui[i] >> 16) & 0xFF] + GrayB[(ui[i] >> 8) & 0xFF]);
 497                     }
 498                     *gltype = MATPLOT_GL_GRAY;
 499                     break;
 500                 }
 501                 case MATPLOT_UInt :
 502                 {
 503                     const unsigned int * ui = (const unsigned int *)data;
 504                     unsigned char * ucdata = (unsigned char *) * dest;
 505
 506                     for (int i = 0; i < numElements; i++)
 507                     {
 508                         ucdata[i] = (unsigned char) (GrayR[(ui[i] >> 16) & 0xFF] + GrayG[(ui[i] >> 8) & 0xFF] + GrayB[ui[i] & 0xFF]);
 509                     }
 510                     *gltype = MATPLOT_GL_GRAY;
 511                     break;
 512                 }
 513                 case MATPLOT_HM1_Double :
 514                 case MATPLOT_Double :
 515                 {
 516                     const double * d = (const double *)data;
 517                     float * fdata = (float *) * dest;
 518
 519                     for (int i = 0; i < numElements; i++)
 520                     {
 521                         fdata[i] = (float)d[i];
 522                     }
 523                     *gltype = MATPLOT_GL_GRAY_FLOAT;
 524                     break;
 525                 }
 526             }
 527             break;
 528         }
 529         case MATPLOT_INDEX :
 530         {
 531             memcpy(*dest, data, size);
 532             *gltype = MATPLOT_GL_RGBA_BYTE;
 533             break;
 534         }
 535         case MATPLOT_RED :
 536         {
 537             switch (datatype)
 538             {
 539                 case MATPLOT_HM3_Char :
 540                 case MATPLOT_HM3_UChar :
 541                 case MATPLOT_HM4_Char :
 542                 case MATPLOT_HM4_UChar :
 543                 {
 544                     memcpy(*dest, data, numElements);
 545                     *gltype = MATPLOT_GL_RED;
 546                     break;
 547                 }
 548                 case MATPLOT_HM3_Double :
 549                 case MATPLOT_HM4_Double :
 550                 case MATPLOT_HM1_Double :
 551                 case MATPLOT_Double :
 552                 {
 553                     const double * d = (const double *)data;
 554                     float * fdata = (float *) * dest;
 555
 556                     for (int i = 0; i < numElements; i++)
 557                     {
 558                         fdata[i] = (float)d[i];
 559                     }
 560                     *gltype = MATPLOT_GL_RED_FLOAT;
 561                     break;
 562                 }
 563                 case MATPLOT_HM1_Char :
 564                 case MATPLOT_HM1_UChar :
 565                 case MATPLOT_UChar :
 566                 case MATPLOT_Char :
 567                 {
 568                     memcpy(*dest, data, size);
 569                     *gltype = MATPLOT_GL_RED;
 570                     break;
 571                 }
 572                 case MATPLOT_Short :
 573                 case MATPLOT_UShort :
 574                 {
 575                     memcpy(*dest, data, size);
 576                     *gltype = MATPLOT_GL_RED_16;
 577                     break;
 578                 }
 579                 case MATPLOT_Int :
 580                 {
 581                     const unsigned int * ui = (const unsigned int *)data;
 582                     unsigned char * ucdata = (unsigned char *) * dest;
 583
 584                     for (int i = 0; i < numElements; i++)
 585                     {
 586                         ucdata[i] = (unsigned char) ((ui[i] >> 16) & 0xFF);
 587                     }
 588                     *gltype = MATPLOT_GL_RED;
 589                     break;
 590                 }
 591                 case MATPLOT_UInt :
 592                 {
 593                     const unsigned int * ui = (const unsigned int *)data;
 594                     unsigned char * ucdata = (unsigned char *) * dest;
 595
 596                     for (int i = 0; i < numElements; i++)
 597                     {
 598                         ucdata[i] = (unsigned char) ((ui[i] >> 24) & 0xFF);
 599                     }
 600                     *gltype = MATPLOT_GL_RED;
 601                     break;
 602                 }
 603             }
 604             break;
 605         }
 606         case MATPLOT_GREEN :
 607         {
 608             switch (datatype)
 609             {
 610                 case MATPLOT_HM3_Char :
 611                 case MATPLOT_HM3_UChar :
 612                 case MATPLOT_HM4_Char :
 613                 case MATPLOT_HM4_UChar :
 614                 {
 615                     memcpy(*dest, (unsigned char *)data + numElements, numElements);
 616                     *gltype = MATPLOT_GL_GREEN;
 617                     break;
 618                 }
 619                 case MATPLOT_HM3_Double :
 620                 case MATPLOT_HM4_Double :
 621                 {
 622                     const double * d = (const double *)data + numElements;
 623                     float * fdata = (float *) * dest;
 624
 625                     for (int i = 0; i < numElements; i++)
 626                     {
 627                         fdata[i] = (float)d[i];
 628                     }
 629                     *gltype = MATPLOT_GL_GREEN_FLOAT;
 630                     break;
 631                 }
 632                 case MATPLOT_HM1_Char :
 633                 case MATPLOT_HM1_UChar :
 634                 case MATPLOT_UChar :
 635                 case MATPLOT_Char :
 636                 {
 637                     memcpy(*dest, data, size);
 638                     *gltype = MATPLOT_GL_GREEN;
 639                     break;
 640                 }
 641                 case MATPLOT_Short :
 642                 case MATPLOT_UShort :
 643                 {
 644                     memcpy(*dest, data, size);
 645                     *gltype = MATPLOT_GL_GREEN_16;
 646                     break;
 647                 }
 648                 case MATPLOT_Int :
 649                 {
 650                     const unsigned int * ui = (const unsigned int *)data;
 651                     unsigned char * ucdata = (unsigned char *) * dest;
 652
 653                     for (int i = 0; i < numElements; i++)
 654                     {
 655                         ucdata[i] = (unsigned char) ((ui[i] >> 8) & 0xFF);
 656                     }
 657                     *gltype = MATPLOT_GL_GREEN;
 658                     break;
 659                 }
 660                 case MATPLOT_UInt :
 661                 {
 662                     const unsigned int * ui = (const unsigned int *)data;
 663                     unsigned char * ucdata = (unsigned char *) * dest;
 664
 665                     for (int i = 0; i < numElements; i++)
 666                     {
 667                         ucdata[i] = (unsigned char) ((ui[i] >> 16) & 0xFF);
 668                     }
 669                     *gltype = MATPLOT_GL_GREEN;
 670                     break;
 671                 }
 672                 case MATPLOT_HM1_Double :
 673                 case MATPLOT_Double :
 674                 {
 675                     const double * d = (const double *)data;
 676                     float * fdata = (float *) * dest;
 677
 678                     for (int i = 0; i < numElements; i++)
 679                     {
 680                         fdata[i] = (float)d[i];
 681                     }
 682                     *gltype = MATPLOT_GL_GREEN_FLOAT;
 683                     break;
 684                 }
 685             }
 686             break;
 687         }
 688         case MATPLOT_BLUE :
 689         {
 690             switch (datatype)
 691             {
 692                 case MATPLOT_HM3_Char :
 693                 case MATPLOT_HM3_UChar :
 694                 case MATPLOT_HM4_Char :
 695                 case MATPLOT_HM4_UChar :
 696                 {
 697                     memcpy(*dest, (unsigned char *)data + 2 * numElements, numElements);
 698                     *gltype = MATPLOT_GL_BLUE;
 699                     break;
 700                 }
 701                 case MATPLOT_HM3_Double :
 702                 case MATPLOT_HM4_Double :
 703                 {
 704                     const double * d = (const double *)data + 2 * numElements;
 705                     float * fdata = (float *) * dest;
 706
 707                     for (int i = 0; i < numElements; i++)
 708                     {
 709                         fdata[i] = (float)d[i];
 710                     }
 711                     *gltype = MATPLOT_GL_BLUE_FLOAT;
 712                     break;
 713                 }
 714                 case MATPLOT_HM1_Char :
 715                 case MATPLOT_HM1_UChar :
 716                 case MATPLOT_UChar :
 717                 case MATPLOT_Char :
 718                 {
 719                     memcpy(*dest, data, size);
 720                     *gltype = MATPLOT_GL_BLUE;
 721                     break;
 722                 }
 723                 case MATPLOT_Short :
 724                 case MATPLOT_UShort :
 725                 {
 726                     memcpy(*dest, data, size);
 727                     *gltype = MATPLOT_GL_BLUE_16;
 728                     break;
 729                 }
 730                 case MATPLOT_Int :
 731                 {
 732                     const unsigned int * ui = (const unsigned int *)data;
 733                     unsigned char * ucdata = (unsigned char *) * dest;
 734
 735                     for (int i = 0; i < numElements; i++)
 736                     {
 737                         ucdata[i] = (unsigned char) (ui[i] & 0xFF);
 738                     }
 739                     *gltype = MATPLOT_GL_BLUE;
 740                     break;
 741                 }
 742                 case MATPLOT_UInt :
 743                 {
 744                     const unsigned int * ui = (const unsigned int *)data;
 745                     unsigned char * ucdata = (unsigned char *) * dest;
 746
 747                     for (int i = 0; i < numElements; i++)
 748                     {
 749                         ucdata[i] = (unsigned char) ((ui[i] >> 8) & 0xFF);
 750                     }
 751                     *gltype = MATPLOT_GL_BLUE;
 752                     break;
 753                 }
 754                 case MATPLOT_HM1_Double :
 755                 case MATPLOT_Double :
 756                 {
 757                     const double * d = (const double *)data;
 758                     float * fdata = (float *) * dest;
 759
 760                     for (int i = 0; i < numElements; i++)
 761                     {
 762                         fdata[i] = (float)d[i];
 763                     }
 764                     *gltype = MATPLOT_GL_BLUE_FLOAT;
 765                     break;
 766                 }
 767             }
 768             break;
 769         }
 770         case MATPLOT_RGB_332 :
 771         {
 772             switch (datatype)
 773             {
 774                 case MATPLOT_HM3_Char :
 775                 case MATPLOT_HM3_UChar :
 776                 case MATPLOT_HM4_Char :
 777                 case MATPLOT_HM4_UChar :
 778                 {
 779                     const unsigned char * R = (const unsigned char *)data;
 780                     const unsigned char * G = R + numElements;
 781                     const unsigned char * B = G + numElements;
 782                     unsigned char * ucdata = (unsigned char *) * dest;
 783                     for (int i = 0; i < numElements; i++)
 784                     {
 785                         ucdata[i] = (unsigned char)(RGB8R[R[i]] | RGB8G[G[i]] | RGB8B[B[i]]);
 786                     }
 787                     *gltype = MATPLOT_GL_RGB_332;
 788                     break;
 789                 }
 790                 case MATPLOT_HM3_Double :
 791                 case MATPLOT_HM4_Double :
 792                 {
 793                     const double * R = (const double *)data;
 794                     const double * G = R + numElements;
 795                     const double * B = G + numElements;
 796                     unsigned char * ucdata = (unsigned char *) * dest;
 797                     for (int i = 0; i < numElements; i++)
 798                     {
 799                         ucdata[i] = (unsigned char)(RGB8R[_DOUBLE_TO_UCHAR_(R[i])] | RGB8G[_DOUBLE_TO_UCHAR_(G[i])] | RGB8B[_DOUBLE_TO_UCHAR_(B[i])]);
 800                     }
 801                     *gltype = MATPLOT_GL_RGB_332;
 802                     break;
 803                 }
 804                 case MATPLOT_HM1_Char :
 805                 case MATPLOT_HM1_UChar :
 806                 case MATPLOT_UChar :
 807                 case MATPLOT_Char :
 808                 {
 809                     memcpy(*dest, data, size);
 810                     *gltype = MATPLOT_GL_RGB_332;
 811                     break;
 812                 }
 813                 case MATPLOT_Int :
 814                 {
 815                     const unsigned int * ui = (const unsigned int *)data;
 816                     unsigned char * ucdata = (unsigned char *) * dest;
 817
 818                     for (int i = 0; i < numElements; i++)
 819                     {
 820                         ucdata[i] = (unsigned char)(RGB8R[(ui[i] & 0xFF0000) >> 16] | RGB8G[(ui[i] & 0xFF00) >> 8] | RGB8B[ui[i] & 0xFF]);
 821                     }
 822                     *gltype = MATPLOT_GL_RGB_332;
 823                     break;
 824                 }
 825                 case MATPLOT_UInt :
 826                 {
 827                     const unsigned int * ui = (const unsigned int *)data;
 828                     unsigned char * ucdata = (unsigned char *) * dest;
 829
 830                     for (int i = 0; i < numElements; i++)
 831                     {
 832                         ucdata[i] = (unsigned char)(RGB8R[(ui[i] & 0xFF000000) >> 24] | RGB8G[(ui[i] & 0xFF0000) >> 16] | RGB8B[(ui[i] & 0xFF00) >> 8]);
 833                     }
 834                     *gltype = MATPLOT_GL_RGB_332;
 835                     break;
 836                 }
 837                 case MATPLOT_Short :
 838                 {
 839                     const unsigned short * us = (const unsigned short *)data;
 840                     unsigned char * ucdata = (unsigned char *) * dest;
 841
 842                     for (int i = 0; i < numElements; i++)
 843                     {
 844                         ucdata[i] = (unsigned char)(((us[i] & 0xE00) >> 4) | ((us[i] & 0xE0) >> 3) | ((us[i] & 0xC) >> 2));
 845                     }
 846                     *gltype = MATPLOT_GL_RGB_332;
 847                     break;
 848                 }
 849                 case MATPLOT_UShort :
 850                 {
 851                     const unsigned short * us = (const unsigned short *)data;
 852                     unsigned char * ucdata = (unsigned char *) * dest;
 853
 854                     for (int i = 0; i < numElements; i++)
 855                     {
 856                         ucdata[i] = (unsigned char)(((us[i] & 0xE000) >> 8) | ((us[i] & 0xE00) >> 7) | ((us[i] & 0xC0) >> 6));
 857                     }
 858                     *gltype = MATPLOT_GL_RGB_332;
 859                     break;
 860                 }
 861                 case MATPLOT_HM1_Double :
 862                 case MATPLOT_Double :
 863                 {
 864                     const double * d = (const double *)data;
 865                     unsigned char * ucdata = (unsigned char *) * dest;
 866
 867                     for (int i = 0; i < numElements; i++)
 868                     {
 869                         const unsigned int ui = (unsigned int)d[i];
 870                         ucdata[i] = (unsigned char)(RGB8R[(ui & 0xFF000000) >> 24] | RGB8G[(ui & 0xFF0000) >> 16] | RGB8B[(ui & 0xFF00) >> 8]);
 871                     }
 872                     *gltype = MATPLOT_GL_RGB_332;
 873                     break;
 874                 }
 875             }
 876             break;
 877         }
 878         case MATPLOT_RGB_444 :
 879         {
 880             switch (datatype)
 881             {
 882                 case MATPLOT_HM3_Char :
 883                 case MATPLOT_HM3_UChar :
 884                 case MATPLOT_HM4_Char :
 885                 case MATPLOT_HM4_UChar :
 886                 {
 887                     const unsigned char * R = (const unsigned char *)data;
 888                     const unsigned char * G = R + numElements;
 889                     const unsigned char * B = G + numElements;
 890                     unsigned short * usdata = (unsigned short *) * dest;
 891                     for (int i = 0; i < numElements; i++)
 892                     {
 893                         usdata[i] = (unsigned short)((R12[R[i]] << 12) | (R12[G[i]] << 8) | (R12[B[i]] << 4) | 0xF);
 894                     }
 895                     *gltype = MATPLOT_GL_RGBA_4444;
 896                     break;
 897                 }
 898                 case MATPLOT_HM3_Double :
 899                 case MATPLOT_HM4_Double :
 900                 {
 901                     const double * R = (const double *)data;
 902                     const double * G = R + numElements;
 903                     const double * B = G + numElements;
 904                     unsigned short * usdata = (unsigned short *) * dest;
 905                     for (int i = 0; i < numElements; i++)
 906                     {
 907                         usdata[i] = (unsigned short)((R12[_DOUBLE_TO_UCHAR_(R[i])] << 12) | (R12[_DOUBLE_TO_UCHAR_(G[i])] << 8) | (R12[_DOUBLE_TO_UCHAR_(B[i])] << 4) | 0xF);
 908                     }
 909                     *gltype = MATPLOT_GL_RGBA_4444;
 910                     break;
 911                 }
 912                 case MATPLOT_HM1_Char :
 913                 case MATPLOT_HM1_UChar :
 914                 case MATPLOT_UChar :
 915                 case MATPLOT_Char :
 916                 {
 917                     memcpy(*dest, data, size);
 918                     *gltype = MATPLOT_GL_RGBA_4444;
 919                     break;
 920                 }
 921                 case MATPLOT_Int :
 922                 {
 923                     const unsigned int * ui = (const unsigned int *)data;
 924                     unsigned short * usdata = (unsigned short *) * dest;
 925
 926                     for (int i = 0; i < numElements; i++)
 927                     {
 928                         usdata[i] = (unsigned short)((R12[(ui[i] & 0xFF0000) >> 16] << 12) | (R12[(ui[i] & 0xFF00) >> 8] << 8) | (R12[ui[i] & 0xFF] << 4) | 0xF);
 929                     }
 930                     *gltype = MATPLOT_GL_RGBA_4444;
 931                     break;
 932                 }
 933                 case MATPLOT_UInt :
 934                 {
 935                     const unsigned int * ui = (const unsigned int *)data;
 936                     unsigned short * usdata = (unsigned short *) * dest;
 937
 938                     for (int i = 0; i < numElements; i++)
 939                     {
 940                         usdata[i] = (unsigned short)((R12[(ui[i] & 0xFF000000) >> 24] << 12) | (R12[(ui[i] & 0xFF0000) >> 16] << 8) | (R12[(ui[i] & 0xFF00) >> 8] << 4) | (R12[ui[i] & 0xFF]));
 941                     }
 942                     *gltype = MATPLOT_GL_RGBA_4444;
 943                     break;
 944                 }
 945                 case MATPLOT_UShort :
 946                 case MATPLOT_Short :
 947                 {
 948                     const unsigned short * us = (const unsigned short *)data;
 949                     unsigned short * usdata = (unsigned short *) * dest;
 950                     for (int i = 0; i < numElements; i++)
 951                     {
 952                         usdata[i] = (us[i] << 4) | 0xF;
 953                     }
 954                     *gltype = MATPLOT_GL_RGBA_4444;
 955                     break;
 956                 }
 957                 case MATPLOT_HM1_Double :
 958                 case MATPLOT_Double :
 959                 {
 960                     const double * d = (const double *)data;
 961                     unsigned short * usdata = (unsigned short *) * dest;
 962
 963                     for (int i = 0; i < numElements; i++)
 964                     {
 965                         const unsigned int ui = (unsigned int)d[i];
 966                         usdata[i] = (unsigned short)((R12[(ui & 0xFF0000) >> 16] << 12) | (R12[(ui & 0xFF00) >> 8] << 8) | (R12[ui & 0xFF] << 4) | 0xF);
 967                     }
 968                     *gltype = MATPLOT_GL_RGBA_4444;
 969                     break;
 970                 }
 971             }
 972             break;
 973         }
 974         case MATPLOT_RGB_555 :
 975         {
 976             switch (datatype)
 977             {
 978                 case MATPLOT_HM3_Char :
 979                 case MATPLOT_HM3_UChar :
 980                 case MATPLOT_HM4_Char :
 981                 case MATPLOT_HM4_UChar :
 982                 {
 983                     const unsigned char * R = (const unsigned char *)data;
 984                     const unsigned char * G = R + numElements;
 985                     const unsigned char * B = G + numElements;
 986                     unsigned short * usdata = (unsigned short *) * dest;
 987                     for (int i = 0; i < numElements; i++)
 988                     {
 989                         usdata[i] = (unsigned short)(((R[i] & 0xF8) << 8) | ((G[i] & 0xF8) << 3) | ((B[i] & 0xF8) >> 2) | 0x1);
 990                     }
 991                     *gltype = MATPLOT_GL_RGBA_5551;
 992                     break;
 993                 }
 994                 case MATPLOT_HM3_Double :
 995                 case MATPLOT_HM4_Double :
 996                 {
 997                     const double * R = (const double *)data;
 998                     const double * G = R + numElements;
 999                     const double * B = G + numElements;
1000                     unsigned short * usdata = (unsigned short *) * dest;
1001                     for (int i = 0; i < numElements; i++)
1002                     {
1003                         usdata[i] = (unsigned short)(((_DOUBLE_TO_UCHAR_(R[i]) & 0xF8) << 8) | ((_DOUBLE_TO_UCHAR_(G[i]) & 0xF8) << 3) | ((_DOUBLE_TO_UCHAR_(B[i]) & 0xF8) >> 2) | 0x1);
1004                     }
1005                     *gltype = MATPLOT_GL_RGBA_5551;
1006                     break;
1007                 }
1008                 case MATPLOT_HM1_Char :
1009                 case MATPLOT_HM1_UChar :
1010                 case MATPLOT_UChar :
1011                 case MATPLOT_Char :
1012                 {
1013                     memcpy(*dest, data, size);
1014                     *gltype = MATPLOT_GL_RGBA_5551;
1015                     break;
1016                 }
1017                 case MATPLOT_Int :
1018                 {
1019                     const unsigned int * ui = (const unsigned int *)data;
1020                     unsigned short * usdata = (unsigned short *) * dest;
1021                     for (int i = 0; i < numElements; i++)
1022                     {
1023                         usdata[i] = (unsigned short)(((ui[i] & 0xF80000) >> 8) | ((ui[i] & 0xF800) >> 5) | ((ui[i] & 0xF8) >> 2) | 0x1);
1024                     }
1025                     *gltype = MATPLOT_GL_RGBA_5551;
1026                     break;
1027                 }
1028                 case MATPLOT_UInt :
1029                 {
1030                     const unsigned int * ui = (const unsigned int *)data;
1031                     unsigned short * usdata = (unsigned short *) * dest;
1032                     for (int i = 0; i < numElements; i++)
1033                     {
1034                         usdata[i] = (unsigned short)(((ui[i] & 0xF8000000) >> 16) | ((ui[i] & 0xF80000) >> 13) | ((ui[i] & 0xF800) >> 10) | 0x1);
1035                     }
1036                     *gltype = MATPLOT_GL_RGBA_5551;
1037                     break;
1038                 }
1039                 case MATPLOT_UShort :
1040                 case MATPLOT_Short :
1041                 {
1042                     const unsigned short * ui = (const unsigned short *)data;
1043                     unsigned short * usdata = (unsigned short *) * dest;
1044                     for (int i = 0; i < numElements; i++)
1045                     {
1046                         usdata[i] = (ui[i] << 1) | 0x1;
1047                     }
1048                     *gltype = MATPLOT_GL_RGBA_5551;
1049                     break;
1050                 }
1051                 case MATPLOT_HM1_Double :
1052                 case MATPLOT_Double :
1053                 {
1054                     const double * d = (const double *)data;
1055                     unsigned short * usdata = (unsigned short *) * dest;
1056
1057                     for (int i = 0; i < numElements; i++)
1058                     {
1059                         const unsigned int ui = (unsigned int)d[i];
1060                         usdata[i] = (unsigned short)(((ui & 0xF80000) >> 13) | ((ui & 0xF800) >> 5) | ((ui & 0xF8) >> 2) | 0x1);
1061                     }
1062                     *gltype = MATPLOT_GL_RGBA_4444;
1063                     break;
1064                 }
1065             }
1066             break;
1067         }
1068         case MATPLOT_RGBA_4444 :
1069         {
1070             switch (datatype)
1071             {
1072                 case MATPLOT_HM3_Char :
1073                 case MATPLOT_HM3_UChar :
1074                 {
1075                     const unsigned char * R = (const unsigned char *)data;
1076                     const unsigned char * G = R + numElements;
1077                     const unsigned char * B = G + numElements;
1078                     unsigned short * usdata = (unsigned short *) * dest;
1079                     for (int i = 0; i < numElements; i++)
1080                     {
1081                         usdata[i] = (unsigned short)((R12[R[i]] << 12) | (R12[G[i]] << 8) | (R12[B[i]] << 4) | 0xF);
1082                     }
1083                     *gltype = MATPLOT_GL_RGBA_4444;
1084                     break;
1085                 }
1086                 case MATPLOT_HM4_Char :
1087                 case MATPLOT_HM4_UChar :
1088                 {
1089                     const unsigned char * R = (const unsigned char *)data;
1090                     const unsigned char * G = R + numElements;
1091                     const unsigned char * B = G + numElements;
1092                     const unsigned char * A = B + numElements;
1093                     unsigned short * usdata = (unsigned short *) * dest;
1094                     for (int i = 0; i < numElements; i++)
1095                     {
1096                         usdata[i] = (unsigned short)((R12[R[i]] << 12) | (R12[G[i]] << 8) | (R12[B[i]] << 4) | R12[A[i]]);
1097                     }
1098                     *gltype = MATPLOT_GL_RGBA_4444;
1099                     break;
1100                 }
1101                 case MATPLOT_HM3_Double :
1102                 {
1103                     const double * R = (const double *)data;
1104                     const double * G = R + numElements;
1105                     const double * B = G + numElements;
1106                     unsigned short * usdata = (unsigned short *) * dest;
1107                     for (int i = 0; i < numElements; i++)
1108                     {
1109                         usdata[i] = (unsigned short)((R12[_DOUBLE_TO_UCHAR_(R[i])] << 12) | (R12[_DOUBLE_TO_UCHAR_(G[i])] << 8) | (R12[_DOUBLE_TO_UCHAR_(B[i])] << 4) | 0xF);
1110                     }
1111                     *gltype = MATPLOT_GL_RGBA_4444;
1112                     break;
1113                 }
1114                 case MATPLOT_HM4_Double :
1115                 {
1116                     const double * R = (const double *)data;
1117                     const double * G = R + numElements;
1118                     const double * B = G + numElements;
1119                     const double * A = B + numElements;
1120                     unsigned short * usdata = (unsigned short *) * dest;
1121                     for (int i = 0; i < numElements; i++)
1122                     {
1123                         usdata[i] = (unsigned short)((R12[_DOUBLE_TO_UCHAR_(R[i])] << 12) | (R12[_DOUBLE_TO_UCHAR_(G[i])] << 8) | (R12[_DOUBLE_TO_UCHAR_(B[i])] << 4) | R12[_DOUBLE_TO_UCHAR_(A[i])]);
1124                     }
1125                     *gltype = MATPLOT_GL_RGBA_4444;
1126                     break;
1127                 }
1128                 case MATPLOT_HM1_Char :
1129                 case MATPLOT_HM1_UChar :
1130                 case MATPLOT_UChar :
1131                 case MATPLOT_Char :
1132                 {
1133                     memcpy(*dest, data, size);
1134                     *gltype = MATPLOT_GL_RGBA_4444;
1135                     break;
1136                 }
1137                 case MATPLOT_Int :
1138                 {
1139                     const unsigned int * ui = (const unsigned int *)data;
1140                     unsigned short * usdata = (unsigned short *) * dest;
1141                     for (int i = 0; i < numElements; i++)
1142                     {
1143                         usdata[i] = (unsigned short)((R12[(ui[i] & 0xFF0000) >> 16] << 12) | (R12[(ui[i] & 0xFF00) >> 8] << 8) | (R12[ui[i] & 0xFF] << 4) | 0xF);
1144                     }
1145                     *gltype = MATPLOT_GL_RGBA_4444;
1146                     break;
1147                 }
1148                 case MATPLOT_UInt :
1149                 {
1150                     const unsigned int * ui = (const unsigned int *)data;
1151                     unsigned short * usdata = (unsigned short *) * dest;
1152
1153                     for (int i = 0; i < numElements; i++)
1154                     {
1155                         usdata[i] = (unsigned short)((R12[(ui[i] & 0xFF000000) >> 24] << 12) | (R12[(ui[i] & 0xFF0000) >> 16] << 8) | (R12[(ui[i] & 0xFF00) >> 8] << 4) | R12[ui[i] & 0xFF]);
1156                     }
1157                     *gltype = MATPLOT_GL_RGBA_4444;
1158                     break;
1159                 }
1160                 case MATPLOT_UShort :
1161                 case MATPLOT_Short :
1162                 {
1163                     memcpy(*dest, data, size);
1164                     *gltype = MATPLOT_GL_RGBA_4444;
1165                     break;
1166                 }
1167                 case MATPLOT_HM1_Double :
1168                 case MATPLOT_Double :
1169                 {
1170                     const double * d = (const double *)data;
1171                     unsigned short * usdata = (unsigned short *) * dest;
1172
1173                     for (int i = 0; i < numElements; i++)
1174                     {
1175                         const unsigned int ui = (unsigned int)d[i];
1176                         usdata[i] = (unsigned short)((R12[(ui & 0xFF000000) >> 24] << 12) | (R12[(ui & 0xFF0000) >> 16] << 8) | (R12[(ui & 0xFF) >> 8] << 4) | R12[ui & 0xFF]);
1177                     }
1178                     *gltype = MATPLOT_GL_RGBA_4444;
1179                     break;
1180                 }
1181             }
1182             break;
1183         }
1184         case MATPLOT_RGBA_5551 :
1185         {
1186             switch (datatype)
1187             {
1188                 case MATPLOT_HM3_Char :
1189                 case MATPLOT_HM3_UChar :
1190                 {
1191                     const unsigned char * R = (const unsigned char *)data;
1192                     const unsigned char * G = R + numElements;
1193                     const unsigned char * B = G + numElements;
1194                     unsigned short * usdata = (unsigned short *) * dest;
1195                     for (int i = 0; i < numElements; i++)
1196                     {
1197                         usdata[i] = (unsigned short)(((R[i] & 0xF8) << 8) | ((G[i] & 0xF8) << 3) | ((B[i] & 0xF8) >> 2) | 0x1);
1198                     }
1199                     *gltype = MATPLOT_GL_RGBA_5551;
1200                     break;
1201                 }
1202                 case MATPLOT_HM4_Char :
1203                 case MATPLOT_HM4_UChar :
1204                 {
1205                     const unsigned char * R = (const unsigned char *)data;
1206                     const unsigned char * G = R + numElements;
1207                     const unsigned char * B = G + numElements;
1208                     const unsigned char * A = B + numElements;
1209                     unsigned short * usdata = (unsigned short *) * dest;
1210                     for (int i = 0; i < numElements; i++)
1211                     {
1212                         usdata[i] = (unsigned short)(((R[i] & 0xF8) << 8) | ((G[i] & 0xF8) << 3) | ((B[i] & 0xF8) >> 2) | ((A[i] & 0x1)));
1213                     }
1214                     *gltype = MATPLOT_GL_RGBA_5551;
1215                     break;
1216                 }
1217                 case MATPLOT_HM3_Double :
1218                 {
1219                     const double * R = (const double *)data;
1220                     const double * G = R + numElements;
1221                     const double * B = G + numElements;
1222                     unsigned short * usdata = (unsigned short *) * dest;
1223                     for (int i = 0; i < numElements; i++)
1224                     {
1225                         usdata[i] = (unsigned short)(((_DOUBLE_TO_UCHAR_(R[i]) & 0xF8) << 8) | ((_DOUBLE_TO_UCHAR_(G[i]) & 0xF8) << 3) | ((_DOUBLE_TO_UCHAR_(B[i]) & 0xF8) >> 2) | 0x1);
1226                     }
1227                     *gltype = MATPLOT_GL_RGBA_5551;
1228                     break;
1229                 }
1230                 case MATPLOT_HM4_Double :
1231                 {
1232                     const double * R = (const double *)data;
1233                     const double * G = R + numElements;
1234                     const double * B = G + numElements;
1235                     const double * A = B + numElements;
1236                     unsigned short * usdata = (unsigned short *) * dest;
1237                     for (int i = 0; i < numElements; i++)
1238                     {
1239                         usdata[i] = (unsigned short)(((_DOUBLE_TO_UCHAR_(R[i]) & 0xF8) << 8) | ((_DOUBLE_TO_UCHAR_(G[i]) & 0xF8) << 3) | ((_DOUBLE_TO_UCHAR_(B[i]) & 0xF8) >> 2) | (_DOUBLE_TO_UCHAR_(A[i]) & 0x1));
1240                     }
1241                     *gltype = MATPLOT_GL_RGBA_5551;
1242                     break;
1243                 }
1244                 case MATPLOT_HM1_Char :
1245                 case MATPLOT_HM1_UChar :
1246                 case MATPLOT_UChar :
1247                 case MATPLOT_Char :
1248                 {
1249                     memcpy(*dest, data, size);
1250                     *gltype = MATPLOT_GL_RGBA_5551;
1251                     break;
1252                 }
1253                 case MATPLOT_Int :
1254                 {
1255                     const unsigned int * ui = (const unsigned int *)data;
1256                     unsigned short * usdata = (unsigned short *) * dest;
1257
1258                     for (int i = 0; i < numElements; i++)
1259                     {
1260                         usdata[i] = (unsigned short)(((ui[i] & 0xF80000) >> 13) | ((ui[i] & 0xF800) >> 5) | ((ui[i] & 0xF8) >> 2) | 0x1);
1261                     }
1262                     *gltype = MATPLOT_GL_RGBA_5551;
1263                     break;
1264                 }
1265                 case MATPLOT_UInt :
1266                 {
1267                     const unsigned int * ui = (const unsigned int *)data;
1268                     unsigned short * usdata = (unsigned short *) * dest;
1269
1270                     for (int i = 0; i < numElements; i++)
1271                     {
1272                         usdata[i] = (unsigned short)(((ui[i] & 0xF8000000) >> 21) | ((ui[i] & 0xF80000) >> 13) | ((ui[i] & 0xF800) >> 10) | ((ui[i] & 0xFF) >> 7));
1273                     }
1274                     *gltype = MATPLOT_GL_RGBA_5551;
1275                     break;
1276                 }
1277                 case MATPLOT_UShort :
1278                 case MATPLOT_Short :
1279                 {
1280                     memcpy(*dest, data, size);
1281                     *gltype = MATPLOT_GL_RGBA_5551;
1282                     break;
1283                 }
1284                 case MATPLOT_HM1_Double :
1285                 case MATPLOT_Double :
1286                 {
1287                     const double * d = (const double *)data;
1288                     unsigned short * usdata = (unsigned short *) * dest;
1289
1290                     for (int i = 0; i < numElements; i++)
1291                     {
1292                         const unsigned int ui = (unsigned int)d[i];
1293                         usdata[i] = (unsigned short)(((ui & 0xF8000000) >> 21) | ((ui & 0xF80000) >> 13) | ((ui & 0xF800) >> 10) | ((ui & 0xFF) >> 7));
1294                     }
1295                     *gltype = MATPLOT_GL_RGBA_4444;
1296                     break;
1297                 }
1298             }
1299             break;
1300         }
1301     }
1302
1303     return ret;
1304 }
1305
1306
1307 bool Texture::initGrayTables()
1308 {
1309     for (int c = 0; c < 256; c++)
1310     {
1311         GrayR[c] = 0.299f * (float)c;
1312         GrayG[c] = 0.587f * (float)c;
1313         GrayB[c] = 0.114f * (float)c;
1314     }
1315
1316     return true;
1317 }
1318
1319 bool Texture::initRGB8Tables()
1320 {
1321     for (int c = 0; c < 256; c++)
1322     {
1323         RGB8R[c] = (c / 36) << 5;
1324         RGB8G[c] = (c / 36) << 2;
1325         RGB8B[c] = c / 81;
1326     }
1327
1328     return true;
1329 }
1330
1331 bool Texture::initR12Table()
1332 {
1333     for (int c = 0; c < 256; c++)
1334     {
1335         R12[c] = c / 17;
1336     }
1337
1338     return true;
1339 }