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