bitmapUtils.cpp

Public Functions

bitmapConvertA8_to_RGBA_c(U8 ** src, U32 pixels)

bitmapConvertRGB_to_1555_c(U8 * src, U32 pixels)

bitmapConvertRGB_to_5551_c(U8 * src, U32 pixels)

bitmapConvertRGB_to_RGBX_c(U8 ** src, U32 pixels)

bitmapConvertRGBX_to_RGB_c(U8 ** src, U32 pixels)

bitmapExtrude5551_c(const void * srcMip, void * mip, U32 srcHeight, U32 srcWidth)

bitmapExtrudeFPRGBA_c(const void * srcMip, void * mip, U32 srcHeight, U32 srcWidth)

bitmapExtrudeRGB_c(const void * srcMip, void * mip, U32 srcHeight, U32 srcWidth)

bitmapExtrudeRGBA_c(const void * srcMip, void * mip, U32 srcHeight, U32 srcWidth)

  1
  2//-----------------------------------------------------------------------------
  3// Copyright (c) 2012 GarageGames, LLC
  4//
  5// Permission is hereby granted, free of charge, to any person obtaining a copy
  6// of this software and associated documentation files (the "Software"), to
  7// deal in the Software without restriction, including without limitation the
  8// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
  9// sell copies of the Software, and to permit persons to whom the Software is
 10// furnished to do so, subject to the following conditions:
 11//
 12// The above copyright notice and this permission notice shall be included in
 13// all copies or substantial portions of the Software.
 14//
 15// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 16// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 17// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 18// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 19// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 20// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
 21// IN THE SOFTWARE.
 22//-----------------------------------------------------------------------------
 23
 24#include "gfx/bitmap/bitmapUtils.h"
 25
 26#include "platform/platform.h"
 27
 28
 29void bitmapExtrude5551_c(const void *srcMip, void *mip, U32 srcHeight, U32 srcWidth)
 30{
 31   const U16 *src = (const U16 *) srcMip;
 32   U16 *dst = (U16 *) mip;
 33   U32 stride = srcHeight != 1 ? srcWidth : 0;
 34
 35   U32 width  = srcWidth  >> 1;
 36   U32 height = srcHeight >> 1;
 37   if (width  == 0) width  = 1;
 38   if (height == 0) height = 1;
 39
 40   if (srcWidth != 1)
 41   {
 42      for(U32 y = 0; y < height; y++)
 43      {
 44         for(U32 x = 0; x < width; x++)
 45         {
 46            U32 a = src[0];
 47            U32 b = src[1];
 48            U32 c = src[stride];
 49            U32 d = src[stride+1];
 50#if defined(TORQUE_BIG_ENDIAN)
 51            dst[x] = (((  (a >> 10) + (b >> 10) + (c >> 10) + (d >> 10)) >> 2) << 10) |
 52                     ((( ((a >> 5) & 0x1F) + ((b >> 5) & 0x1F) + ((c >> 5) & 0x1F) + ((d >> 5) & 0x1F)) >> 2) << 5) |
 53                     ((( ((a >> 0) & 0x1F) + ((b >> 0) & 0x1F) + ((c >> 0) & 0x1F) + ((d >> 0) & 0x1F)) >> 2) << 0);
 54#else
 55            dst[x] = (((  (a >> 11) + (b >> 11) + (c >> 11) + (d >> 11)) >> 2) << 11) |
 56                     ((( ((a >> 6) & 0x1F) + ((b >> 6) & 0x1F) + ((c >> 6) & 0x1F) + ((d >> 6) & 0x1F)) >> 2) << 6) |
 57                     ((( ((a >> 1) & 0x1F) + ((b >> 1) & 0x1F) + ((c >> 1) & 0x1F) + ((d >> 1) & 0x1F)) >> 2) << 1);
 58#endif
 59            src += 2;
 60         }
 61         src += stride;
 62         dst += width;
 63      }
 64   }
 65   else
 66   {
 67      for(U32 y = 0; y < height; y++)
 68      {
 69         U32 a = src[0];
 70         U32 c = src[stride];
 71#if defined(TORQUE_OS_MAC)
 72            dst[y] = ((( (a >> 10) + (c >> 10)) >> 1) << 10) |
 73                     ((( ((a >> 5) & 0x1F) + ((c >> 5) & 0x1f)) >> 1) << 5) |
 74                     ((( ((a >> 0) & 0x1F) + ((c >> 0) & 0x1f)) >> 1) << 0);
 75#else
 76            dst[y] = ((( (a >> 11) + (c >> 11)) >> 1) << 11) |
 77                     ((( ((a >> 6) & 0x1f) + ((c >> 6) & 0x1f)) >> 1) << 6) |
 78                     ((( ((a >> 1) & 0x1F) + ((c >> 1) & 0x1f)) >> 1) << 1);
 79#endif
 80         src += 1 + stride;
 81      }
 82   }
 83}
 84
 85
 86//--------------------------------------------------------------------------
 87void bitmapExtrudeRGB_c(const void *srcMip, void *mip, U32 srcHeight, U32 srcWidth)
 88{
 89   const U8 *src = (const U8 *) srcMip;
 90   U8 *dst = (U8 *) mip;
 91   U32 stride = srcHeight != 1 ? (srcWidth) * 3 : 0;
 92
 93   U32 width  = srcWidth  >> 1;
 94   U32 height = srcHeight >> 1;
 95   if (width  == 0) width  = 1;
 96   if (height == 0) height = 1;
 97
 98   if (srcWidth != 1)
 99   {
100      for(U32 y = 0; y < height; y++)
101      {
102         for(U32 x = 0; x < width; x++)
103         {
104            *dst++ = (U32(*src) + U32(src[3]) + U32(src[stride]) + U32(src[stride+3]) + 2) >> 2;
105            src++;
106            *dst++ = (U32(*src) + U32(src[3]) + U32(src[stride]) + U32(src[stride+3]) + 2) >> 2;
107            src++;
108            *dst++ = (U32(*src) + U32(src[3]) + U32(src[stride]) + U32(src[stride+3]) + 2) >> 2;
109            src += 4;
110         }
111         src += stride;   // skip
112      }
113   }
114   else
115   {
116      for(U32 y = 0; y < height; y++)
117      {
118         *dst++ = (U32(*src) + U32(src[stride]) + 1) >> 1;
119         src++;
120         *dst++ = (U32(*src) + U32(src[stride]) + 1) >> 1;
121         src++;
122         *dst++ = (U32(*src) + U32(src[stride]) + 1) >> 1;
123         src += 4;
124
125         src += stride;   // skip
126      }
127   }
128}
129
130//--------------------------------------------------------------------------
131void bitmapExtrudeRGBA_c(const void *srcMip, void *mip, U32 srcHeight, U32 srcWidth)
132{
133   const U8 *src = (const U8 *) srcMip;
134   U8 *dst = (U8 *) mip;
135   U32 stride = srcHeight != 1 ? (srcWidth) * 4 : 0;
136
137   U32 width  = srcWidth  >> 1;
138   U32 height = srcHeight >> 1;
139   if (width  == 0) width  = 1;
140   if (height == 0) height = 1;
141
142   if (srcWidth != 1)
143   {
144      for(U32 y = 0; y < height; y++)
145      {
146         for(U32 x = 0; x < width; x++)
147         {
148            *dst++ = (U32(*src) + U32(src[4]) + U32(src[stride]) + U32(src[stride+4]) + 2) >> 2;
149            src++;
150            *dst++ = (U32(*src) + U32(src[4]) + U32(src[stride]) + U32(src[stride+4]) + 2) >> 2;
151            src++;
152            *dst++ = (U32(*src) + U32(src[4]) + U32(src[stride]) + U32(src[stride+4]) + 2) >> 2;
153            src++;
154            *dst++ = (U32(*src) + U32(src[4]) + U32(src[stride]) + U32(src[stride+4]) + 2) >> 2;
155            src += 5;
156         }
157         src += stride;   // skip
158      }
159   }
160   else
161   {
162      for(U32 y = 0; y < height; y++)
163      {
164         *dst++ = (U32(*src) + U32(src[stride]) + 1) >> 1;
165         src++;
166         *dst++ = (U32(*src) + U32(src[stride]) + 1) >> 1;
167         src++;
168         *dst++ = (U32(*src) + U32(src[stride]) + 1) >> 1;
169         src++;
170         *dst++ = (U32(*src) + U32(src[stride]) + 1) >> 1;
171         src += 5;
172
173         src += stride;   // skip
174      }
175   }
176}
177
178void bitmapExtrudeFPRGBA_c(const void *srcMip, void *mip, U32 srcHeight, U32 srcWidth)
179{
180   const U16 *src = (const U16 *)srcMip;
181   U16 *dst = (U16 *)mip;
182   U32 stride = srcHeight != 1 ? (srcWidth) * 8 : 0;
183
184   U32 width = srcWidth >> 1;
185   U32 height = srcHeight >> 1;
186   if (width == 0) width = 1;
187   if (height == 0) height = 1;
188
189   if (srcWidth != 1)
190   {
191      for (U32 y = 0; y < height; y++)
192      {
193         for (U32 x = 0; x < width; x++)
194         {
195            *dst++ = (U32(*src) + U32(src[4]) + U32(src[stride]) + U32(src[stride + 4]) + 2) >> 2;
196            src++;
197            *dst++ = (U32(*src) + U32(src[4]) + U32(src[stride]) + U32(src[stride + 4]) + 2) >> 2;
198            src++;
199            *dst++ = (U32(*src) + U32(src[4]) + U32(src[stride]) + U32(src[stride + 4]) + 2) >> 2;
200            src++;
201            *dst++ = (U32(*src) + U32(src[4]) + U32(src[stride]) + U32(src[stride + 4]) + 2) >> 2;
202            src += 5;
203         }
204         src += stride;   // skip
205      }
206   }
207   else
208   {
209      for (U32 y = 0; y < height; y++)
210      {
211         *dst++ = (U32(*src) + U32(src[stride]) + 1) >> 1;
212         src++;
213         *dst++ = (U32(*src) + U32(src[stride]) + 1) >> 1;
214         src++;
215         *dst++ = (U32(*src) + U32(src[stride]) + 1) >> 1;
216         src++;
217         *dst++ = (U32(*src) + U32(src[stride]) + 1) >> 1;
218         src += 5;
219
220         src += stride;   // skip
221      }
222   }
223}
224
225void (*bitmapExtrude5551)(const void *srcMip, void *mip, U32 height, U32 width) = bitmapExtrude5551_c;
226void (*bitmapExtrudeRGB)(const void *srcMip, void *mip, U32 srcHeight, U32 srcWidth) = bitmapExtrudeRGB_c;
227void (*bitmapExtrudeRGBA)(const void *srcMip, void *mip, U32 srcHeight, U32 srcWidth) = bitmapExtrudeRGBA_c;
228void (*bitmapExtrudeFPRGBA)(const void *srcMip, void *mip, U32 srcHeight, U32 srcWidth) = bitmapExtrudeFPRGBA_c;
229
230
231//--------------------------------------------------------------------------
232
233void bitmapConvertRGB_to_1555_c(U8 *src, U32 pixels)
234{
235   U16 *dst = (U16 *)src;
236   for(U32 j = 0; j < pixels; j++)
237   {
238      U32 r = src[0] >> 3;
239      U32 g = src[1] >> 3;
240      U32 b = src[2] >> 3;
241
242#if defined(TORQUE_OS_MAC)
243      *dst++ = 0x8000 | (b << 10) | (g << 5) | (r << 0);
244#else
245      *dst++ = b | (g << 5) | (r << 10) | 0x8000;
246#endif
247      src += 3;
248   }
249}
250
251void (*bitmapConvertRGB_to_1555)(U8 *src, U32 pixels) = bitmapConvertRGB_to_1555_c;
252
253//------------------------------------------------------------------------------
254
255void bitmapConvertRGB_to_5551_c(U8 *src, U32 pixels)
256{
257   U16 *dst = (U16 *)src;
258   for(U32 j = 0; j < pixels; j++)
259   {
260      U32 r = src[0] >> 3;
261      U32 g = src[1] >> 3;
262      U32 b = src[2] >> 3;
263
264#if defined(TORQUE_OS_MAC)
265      *dst++ = (1 << 15) | (b << 10) | (g << 5) | (r << 0);
266#else
267      *dst++ = (b << 1) | (g << 6) | (r << 11) | 1;
268#endif
269      src += 3;
270   }
271}
272
273
274
275void (*bitmapConvertRGB_to_5551)(U8 *src, U32 pixels) = bitmapConvertRGB_to_5551_c;
276
277//------------------------------------------------------------------------------
278
279void bitmapConvertRGB_to_RGBX_c( U8 **src, U32 pixels )
280{
281   const U8 *oldBits = *src;
282   U8 *newBits = new U8[pixels * 4];
283   dMemset( newBits, 0xFF, pixels * 4 ); // This is done to set alpha values -patw
284
285   // Copy the bits over to the new memory
286   for( U32 i = 0; i < pixels; i++ )
287      dMemcpy( &newBits[i * 4], &oldBits[i * 3], sizeof(U8) * 3 );
288
289   // Now hose the old bits
290   delete [] *src;
291   *src = newBits;
292}
293
294void (*bitmapConvertRGB_to_RGBX)( U8 **src, U32 pixels ) = bitmapConvertRGB_to_RGBX_c;
295
296//------------------------------------------------------------------------------
297
298void bitmapConvertRGBX_to_RGB_c( U8 **src, U32 pixels )
299{
300   const U8 *oldBits = *src;
301   U8 *newBits = new U8[pixels * 3];
302
303   // Copy the bits over to the new memory
304   for( U32 i = 0; i < pixels; i++ )
305      dMemcpy( &newBits[i * 3], &oldBits[i * 4], sizeof(U8) * 3 );
306
307   // Now hose the old bits
308   delete [] *src;
309   *src = newBits;
310}
311
312void (*bitmapConvertRGBX_to_RGB)( U8 **src, U32 pixels ) = bitmapConvertRGBX_to_RGB_c;
313
314//------------------------------------------------------------------------------
315
316void bitmapConvertA8_to_RGBA_c( U8 **src, U32 pixels )
317{
318   const U8 *oldBits = *src;
319   U8 *newBits = new U8[pixels * 4];
320
321   // Zero new bits
322   dMemset( newBits, 0, pixels * 4 );
323
324   // Copy Alpha values
325   for( U32 i = 0; i < pixels; i++ )      
326      newBits[i * 4 + 3] = oldBits[i];
327
328   // Now hose the old bits
329   delete [] *src;
330   *src = newBits;
331}
332
333void (*bitmapConvertA8_to_RGBA)( U8 **src, U32 pixels ) = bitmapConvertA8_to_RGBA_c;
334