5260a5e9af18c92814a33ac6db7a4dbc9126a922
[scilab.git] / 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 }