rnd-20100204-1-src
[rocksndiamonds.git] / src / game_sp / BitMapObject.c
1 // ----------------------------------------------------------------------------
2 // BitMapObject.c
3 // ----------------------------------------------------------------------------
4
5 #include "BitMapObject.h"
6
7 // static void ConvertToVBPalette();
8 static long Get_ByteWidth();
9 static long Get_LineLength();
10 static void ReDimArrays();
11
12 // --- VERSION 1.0 CLASS
13 // --- BEGIN
14 // ---   MultiUse = -1  'True  // True
15 // ---   Persistable = 0  'NotPersistable  // NotPersistable
16 // ---   DataBindingBehavior = 0  'vbNone  // vbNone
17 // ---   DataSourceBehavior  = 0  'vbNone  // vbNone
18 // ---   MTSTransactionMode  = 0  'NotAnMTSObject  // NotAnMTSObject
19 // --- END
20
21 // static char *VB_Name = "BitMapObject";
22 // static boolean VB_GlobalNameSpace = False;
23 // static boolean VB_Creatable = True;
24 // static boolean VB_PredeclaredId = False;
25 // static boolean VB_Exposed = False;
26
27 // --- Option Explicit
28
29 // info von http://web.usxchange.net/elmo/bmp.htm
30
31 // A BMP file consists of the four following parts:
32 //
33 //   1.BITMAPFILEHEADER
34 //   2.BITMAPINFOHEADER
35 //   3.A color table of RGBQUAD structures (1, 4 & 8 bit only)
36 //   4.An array of bytes for the actual image data
37
38 // 1.BITMAPFILEHEADER
39 //        1.bfType
40 //               Declared an unsigned integer. But, this is just to reserve space for 2 bytes.
41 //               The 2 bytes must be the 2 characters BM to indicate a BitMap file.
42 //        2.bfSize
43 //               Total size of file in bytes.
44 //        3.bfReserved1
45 //               Always zero (ignore).
46 //        4.bfReserved2
47 //               Always zero (ignore).
48 //        5.bfOffBits
49 //               Specifies the byte offset from the BITMAPFILEHEADER structure to the actual bitmap data in the file.
50 // ::: #ifndef HAS_BitmapFileHeaderType
51 // ::: typedef struct // {    /* bmfh */
52 // ::: {
53 // :::   byte bfTypeB;
54 // :::   byte bfTypeM;
55 // :::   long bfSize;
56 // :::   int bfReserved1;
57 // :::   int bfReserved2;
58 // :::   long bfOffBits;
59 // ::: } BitmapFileHeaderType;
60 // ::: #define HAS_BitmapFileHeaderType
61 // ::: #endif
62
63 //   2.BITMAPINFOHEADER
64 //        1.biSize
65 //               Size of BITMAPINFOHEADER structure (should always be 40).
66 //        2.biWidth
67 //               Width of image in pixels.
68 //        3.biHeight
69 //               Height of image in pixels.
70 //        4.biPlanes
71 //               Always one (ignore).
72 //        5.biBitCount
73 //               Specifies the number of bits per pixel. This value must be 1, 4, 8, or 24.
74 //        6.biCompression
75 //               Specifies the type of compression.
76 //                  1.BI_RGB No compression.
77 //                  2.BI_RLE8 8 bit RLE
78 //                  3.BI_RLE4 4 bit RLE
79 //        7.biSizeImage
80 //               Specifies the size, in bytes, of the image data. May be zero if the bitmap is in the BI_RGB format.
81 //        8.biXPelsPerMeter
82 //               Ignore.
83 //        9.biYPelsPerMeter
84 //               Ignore.
85 //       10.biClrUsed
86 //               Specifies the number of color indices in the color table. Zero indicaes the bitmap uses the maximum number of colors corresponding to the value of the
87 //               biBitCount member e.g. 8 bit -> 256 colors.
88 //
89 //               The maximum number of colors = 2N. Where N = biBitCount. 2N is the same as 1 << N. The same as you can get powers of 10 by shifting the decimal point
90 //               in a decimal number, only it is binary.
91 //       11.biClrImportant
92 //               Ignore.
93 // ::: #ifndef HAS_BitmapInfoHeaderType
94 // ::: typedef struct // {    /* bmih */
95 // ::: {
96 // :::   long biSize;
97 // :::   long biWidth;
98 // :::   long biHeight;
99 // :::   int biPlanes;
100 // :::   int biBitCount;
101 // :::   long biCompression;
102 // :::   long biSizeImage;
103 // :::   long biXPelsPerMeter;
104 // :::   long biYPelsPerMeter;
105 // :::   long biClrUsed;
106 // :::   long biClrImportant;
107 // ::: } BitmapInfoHeaderType;
108 // ::: #define HAS_BitmapInfoHeaderType
109 // ::: #endif
110
111 //   3.A color table of RGBQUAD structures (1, 4 & 8 bit only)
112 //          RGBQUAD structure is self explanatory.
113 // ::: #ifndef HAS_RGBQUADType
114 // ::: typedef struct // {     /* rgbq */
115 // ::: {
116 // :::   byte rgbBlue;
117 // :::   byte rgbGreen;
118 // :::   byte rgbRed;
119 // :::   byte rgbReserved;
120 // ::: } RGBQUADType;
121 // ::: #define HAS_RGBQUADType
122 // ::: #endif
123
124 RGBQUADType *ColorTable;
125 long *VBPalette;
126
127 //   4.An array of bytes for the actual image data
128 //          Bits per pixel & compression determined by biBitCount & biCompression.
129
130 byte *ImageDataBytes;
131
132 // ######################################################################################################
133
134 BitmapFileHeaderType BMFH;
135 BitmapInfoHeaderType BMIH;
136
137 static long Get_LineLength()
138 {
139   static long LineLength;
140
141   LineLength = 4 * (((Get_ByteWidth() - 1) / 4) + 1);
142
143   return LineLength;
144 }
145
146 static long Get_ByteWidth()
147 {
148   static long ByteWidth;
149
150   ByteWidth = BMIH.biWidth * BMIH.biBitCount / 8;
151
152   return ByteWidth;
153 }
154
155 void BitMapObject_CreateAtSize(long XPixels, long YPixels, long BitsPerPixel)
156 {
157   {
158     BMIH.biWidth = XPixels;
159     BMIH.biHeight = YPixels;
160     BMIH.biSize = 40;
161     BMIH.biBitCount = BitsPerPixel;
162     BMIH.biClrUsed = (1 << BMIH.biBitCount);
163     BMIH.biPlanes = 1;
164     BMIH.biClrImportant = BMIH.biClrUsed;
165     BMIH.biCompression = 0;
166   }
167   {
168     BMFH.bfTypeB = 0x42; // B'
169     BMFH.bfTypeM = 0x4D; // M'
170   }
171   ReDimArrays();
172 }
173
174 #if 0
175
176 void BitMapObject_CreateFromFile(char *Path)
177 {
178   long FNum;
179
180   FNum = FreeFile();
181   if (! FileExists(Path))
182     return;
183
184   if (FileLen(Path) < (Len(BMFH) + Len(BMIH)))
185     return;
186
187   FNum = fopen(Path, "rb");
188   FILE_GET(FNum, -1, &BMFH, sizeof(BMFH));
189   FILE_GET(FNum, -1, &BMIH, sizeof(BMIH));
190   ReDimArrays();
191   {
192     if (BMIH.biCompression != 0)
193     {
194       Err.Raise(600, "BitMapObject", "Cannot read compressed BMP files");
195       fclose(FNum);
196       return;
197     }
198
199     if (BMIH.biBitCount < 9)
200     {
201       FILE_GET(FNum, -1, &ColorTable, sizeof(ColorTable));
202     }
203
204   }
205   FILE_GET(FNum, 1 + BMFH.bfOffBits, &ImageDataBytes, sizeof(ImageDataBytes));
206   fclose(FNum);
207   if (BMIH.biBitCount < 9)
208     ConvertToVBPalette();
209 }
210
211 void BitMapObject_SaveToFile(char *Path)
212 {
213   FILE *FNum;
214
215   BMFH.bfOffBits = Len(BMFH) + Len(BMIH);
216   if (BMIH.biBitCount < 9)
217     BMFH.bfOffBits = BMFH.bfOffBits + ((1 << BMIH.biBitCount)) * Len(ColorTable[0]);
218
219   BMIH.biSizeImage = Get_LineLength() * BMIH.biHeight;
220   BMFH.bfSize = BMFH.bfOffBits + BMIH.biSizeImage;
221   // FNum = FreeFile();
222   FNum = fopen(Path, "wb");
223   FILE_PUT(FNum, -1, &BMFH, sizeof(BMFH));
224   FILE_PUT(FNum, -1, &BMIH, sizeof(BMIH));
225   if (BMIH.biBitCount < 9)
226   {
227     FILE_PUT(FNum, -1, &ColorTable, sizeof(ColorTable));
228   }
229
230   FILE_PUT(FNum, -1, &ImageDataBytes, sizeof(ImageDataBytes));
231   fclose(FNum);
232 }
233
234 static void ConvertToVBPalette()
235 {
236   long ColMax, i;
237
238   ColMax = UBound(ColorTable);
239   for (i = 0; i <= ColMax; i++)
240   {
241     {
242       VBPalette[i] = RGB(ColorTable[i].rgbRed, ColorTable[i].rgbGreen, ColorTable[i].rgbBlue);
243     }
244   }
245 }
246
247 #endif
248
249 static void ReDimArrays()
250 {
251   {
252     if (BMIH.biBitCount < 9)
253     {
254       BMIH.biClrUsed = (1 << BMIH.biBitCount);
255       ColorTable = REDIM_1D(sizeof(RGBQUADType), 0, BMIH.biClrUsed - 1);
256       VBPalette = REDIM_1D(sizeof(long), 0, BMIH.biClrUsed - 1);
257     }
258
259     if (0 < Get_LineLength() && 0 < BMIH.biHeight)
260     {
261       ImageDataBytes = REDIM_2D(sizeof(byte), 0, Get_LineLength() - 1, 0, BMIH.biHeight - 1);
262     }
263
264   }
265 }
266
267 long BitMapObject_Get_Palette(long Index)
268 {
269   long Palette;
270
271   Palette = VBPalette[Index];
272
273   return Palette;
274 }
275
276 void BitMapObject_Let_Palette(long Index, long NewVal)
277 {
278   VBPalette[Index] = NewVal & 0xFFFFFF;
279   {
280     ColorTable[Index].rgbRed = (NewVal & 0xFF) / 0x1;
281     ColorTable[Index].rgbGreen = (NewVal & 0xFF00) / 0x100;
282     ColorTable[Index].rgbBlue = (NewVal & 0xFF0000) / 0x10000;
283   }
284 }
285
286 long BitMapObject_Get_ColorsUsed()
287 {
288   long ColorsUsed;
289
290   if (BMIH.biBitCount < 9)
291   {
292     ColorsUsed = (1 << BMIH.biBitCount);
293   }
294   else
295   {
296     ColorsUsed = 0;
297   }
298
299   return ColorsUsed;
300 }
301
302 #if 0
303
304 long BitMapObject_Get_ColorIndex(long X, long Y)
305 {
306   long ColorIndex;
307
308   long ColIndex, NewX, BitPos, nY;
309
310   if (8 < BMIH.biBitCount)
311   {
312     Err.Raise(600, "BitmapObject", "I have ! Palette in this ColorDepthMode");
313     ColorIndex = -1;
314     return ColorIndex;
315   }
316
317   nY = BMIH.biHeight - 1 - Y;
318   switch (BMIH.biBitCount)
319   {
320     case 1:
321       ColIndex = ImageDataBytes[X / 8, nY];
322       BitPos = 7 - (X % 8);
323       NewX = (1 << BitPos);
324       if ((NewX && ColIndex) == 0)
325       {
326         ColorIndex = 0;
327       }
328       else
329       {
330         ColorIndex = 1;
331       }
332
333       break;
334
335     case 4:
336       ColIndex = ImageDataBytes[X / 2, nY];
337       if ((X % 2) == 0)
338       {
339         ColorIndex = (ColIndex & 0xF0) / 0x10;
340       }
341       else
342       {
343         ColorIndex = (ColIndex & 0xF);
344       }
345
346       break;
347
348     case 8:
349       ColorIndex = ImageDataBytes[X, nY];
350       break;
351
352     default:
353       Err.Raise(600, "BitmapObject", "Invalid bpx value");
354       break;
355   }
356
357   return ColorIndex;
358 }
359
360 void BitMapObject_Let_ColorIndex(long X, long Y, long ColorIndex)
361 {
362   long ColIndex, ByteVal, NewX, BitPos, nY;
363
364   if (8 < BMIH.biBitCount)
365   {
366     Err.Raise(600, "BitmapObject", "I have ! Palette in this ColorDepthMode");
367     return;
368   }
369
370   nY = BMIH.biHeight - 1 - Y;
371   switch (BMIH.biBitCount)
372   {
373     case 1:
374       ByteVal = ImageDataBytes[X / 8, nY];
375       BitPos = 7 - (X % 8);
376       NewX = (1 << BitPos);
377       ColIndex = ColorIndex * NewX;
378       if (ColIndex == 0)
379       {
380         ByteVal = (ByteVal & (! NewX));
381       }
382       else
383       {
384         ByteVal = (ByteVal | NewX);
385       }
386
387       ImageDataBytes[X / 8, nY] = ByteVal;
388       break;
389
390     case 4:
391       ByteVal = ImageDataBytes[X / 2, nY];
392       if ((X % 2) == 0)
393       {
394         ByteVal = (ByteVal & 0xF) + ColorIndex * 0x10;
395       }
396       else
397       {
398         ByteVal = (ByteVal & 0xF0) + ColorIndex;
399       }
400
401       ImageDataBytes[X / 2, nY] = ByteVal;
402       break;
403
404     case 8:
405       ImageDataBytes[X, nY] = ColorIndex;
406       break;
407
408     case 24:
409       Err.Raise(600, "BitmapObject", "Invalid bpx value");
410       break;
411   }
412 }
413
414 long BitMapObject_Get_Point(long X, long Y)
415 {
416   long Point;
417
418   long ColIndex, NewX, BitPos, nY;
419
420   nY = BMIH.biHeight - 1 - Y;
421   switch (BMIH.biBitCount)
422   {
423     case 1:
424       ColIndex = ImageDataBytes[X / 8, nY];
425       BitPos = 7 - (X % 8);
426       NewX = (1 << BitPos);
427       if ((NewX && ColIndex) == 0)
428       {
429         ColIndex = 0;
430       }
431       else
432       {
433         ColIndex = 1;
434       }
435
436       Point = VBPalette[ColIndex];
437       break;
438
439     case 4:
440       ColIndex = ImageDataBytes[X / 2, nY];
441       if ((X % 2) == 0)
442       {
443         ColIndex = (ColIndex & 0xF0) / 0x10;
444       }
445       else
446       {
447         ColIndex = (ColIndex & 0xF);
448       }
449
450       Point = VBPalette[ColIndex];
451       break;
452
453     case 8:
454       ColIndex = ImageDataBytes[X, nY];
455       Point = VBPalette[ColIndex];
456       break;
457
458     case 24:
459       NewX = 3 * X;
460       Point = ImageDataBytes[NewX, nY] * 0x10000;
461       Point = Point + ImageDataBytes[NewX + 1, nY] * 0x100;
462       Point = Point + ImageDataBytes[NewX + 2, nY];
463       break;
464
465     default:
466       Err.Raise(600, "BitmapObject", "Invalid bpx value");
467       break;
468   }
469
470   return Point;
471 }
472
473 void BitMapObject_Let_Point(long X, long Y, long NewColor)
474 {
475   long ColIndex, ByteVal, NewX, BitPos, nY;
476
477   nY = BMIH.biHeight - 1 - Y;
478   switch (BMIH.biBitCount)
479   {
480     case 1:
481       ColIndex = GetPaletteIndex(NewColor);
482       ByteVal = ImageDataBytes[X / 8][nY];
483       BitPos = 7 - (X % 8);
484       NewX = (1 << BitPos);
485       ColIndex = ColIndex * NewX;
486       if (ColIndex == 0)
487       {
488         ByteVal = (ByteVal & (! NewX));
489       }
490       else
491       {
492         ByteVal = (ByteVal | NewX);
493       }
494
495       ImageDataBytes[X / 8][nY] = ByteVal;
496       break;
497
498     case 4:
499       ColIndex = GetPaletteIndex(NewColor);
500       ByteVal = ImageDataBytes[X / 2][nY];
501       if ((X % 2) == 0)
502       {
503         ByteVal = (ByteVal & 0xF) + ColIndex * 0x10;
504       }
505       else
506       {
507         ByteVal = (ByteVal & 0xF0) + ColIndex;
508       }
509
510       ImageDataBytes[X / 2][nY] = ByteVal;
511       break;
512
513     case 8:
514       ImageDataBytes[X][nY] = GetPaletteIndex(NewColor);
515       break;
516
517     case 24:
518       NewX = 3 * X;
519       ImageDataBytes[NewX][nY] = (NewColor & 0xFF0000) / 0x10000;  // B
520       ImageDataBytes[NewX + 1][nY] = (NewColor & 0xFF00) / 0x100;  // G
521       ImageDataBytes[NewX + 2][nY] = (NewColor & 0xFF);  // R
522       break;
523
524     default:
525       Err.Raise(600, "BitmapObject", "Invalid bpx value");
526       break;
527   }
528 }
529
530 int BitMapObject_GetPaletteIndex(long Color)
531 {
532   int GetPaletteIndex;
533
534   long i, ColMax;
535
536   ColMax = UBound(VBPalette);
537   for (i = 0; i <= ColMax; i++)
538   {
539     if (VBPalette[i] == Color)
540       break;
541   }
542
543   if (ColMax < i) // Error - Color not in Palette!
544     i = -1;
545
546   GetPaletteIndex = i;
547
548   return GetPaletteIndex;
549 }
550
551 #endif
552
553 long BitMapObject_Get_Width()
554 {
555   long Width;
556
557   Width = BMIH.biWidth;
558
559   return Width;
560 }
561
562 long BitMapObject_Get_Height()
563 {
564   long Height;
565
566   Height = BMIH.biHeight;
567
568   return Height;
569 }
570
571 #if 0
572
573 BitMapObject BitMapObject_GetStretchCopy(float StretchVal)
574 {
575   BitMapObject GetStretchCopy;
576
577   long nWidth, nHeight, iX, iY;
578
579   // GetStretchCopy = New BitMapObject; // (handle this later, if needed)
580   nWidth = StretchVal * BMIH.biWidth;
581   nHeight = StretchVal * BMIH.biHeight;
582   GetStretchCopy.CreateAtSize(nWidth, nHeight, CLng(BMIH.biBitCount));
583   nWidth = nWidth - 1;
584   nHeight = nHeight - 1;
585   for (iX = 0; iX <= BMIH.biClrUsed - 1; iX++)
586   {
587     GetStretchCopy.Let_Palette(iX, Palette(iX));
588   }
589
590   for (iY = 0; iY <= nHeight; iY++)
591   {
592     for (iX = 0; iX <= nWidth; iX++)
593     {
594       GetStretchCopy.Let_ColorIndex(iX, iY, ColorIndex((int)(iX / StretchVal), (int)(iY / StretchVal)));
595     }
596   }
597
598   return GetStretchCopy;
599 }
600
601 #endif