32bpp_base.cpp

00001 /* $Id: 32bpp_base.cpp 11684 2007-12-23 10:56:02Z rubidium $ */
00002 
00003 #include "../stdafx.h"
00004 #include "../gfx_func.h"
00005 #include "32bpp_base.hpp"
00006 
00007 void *Blitter_32bppBase::MoveTo(const void *video, int x, int y)
00008 {
00009   return (uint32 *)video + x + y * _screen.pitch;
00010 }
00011 
00012 void Blitter_32bppBase::SetPixel(void *video, int x, int y, uint8 color)
00013 {
00014   *((uint32 *)video + x + y * _screen.pitch) = LookupColourInPalette(color);
00015 }
00016 
00017 void Blitter_32bppBase::SetPixelIfEmpty(void *video, int x, int y, uint8 color)
00018 {
00019   uint32 *dst = (uint32 *)video + x + y * _screen.pitch;
00020   if (*dst == 0) *dst = LookupColourInPalette(color);
00021 }
00022 
00023 void Blitter_32bppBase::DrawRect(void *video, int width, int height, uint8 color)
00024 {
00025   uint32 color32 = LookupColourInPalette(color);
00026 
00027   do {
00028     uint32 *dst = (uint32 *)video;
00029     for (int i = width; i > 0; i--) {
00030       *dst = color32;
00031       dst++;
00032     }
00033     video = (uint32 *)video + _screen.pitch;
00034   } while (--height);
00035 }
00036 
00037 void Blitter_32bppBase::DrawLine(void *video, int x, int y, int x2, int y2, int screen_width, int screen_height, uint8 color)
00038 {
00039   int dy;
00040   int dx;
00041   int stepx;
00042   int stepy;
00043   int frac;
00044 
00045   dy = (y2 - y) * 2;
00046   if (dy < 0) {
00047     dy = -dy;
00048     stepy = -1;
00049   } else {
00050     stepy = 1;
00051   }
00052 
00053   dx = (x2 - x) * 2;
00054   if (dx < 0) {
00055     dx = -dx;
00056     stepx = -1;
00057   } else {
00058     stepx = 1;
00059   }
00060 
00061   if (x >= 0 && y >= 0 && x < screen_width && y < screen_height) this->SetPixel(video, x, y, color);
00062   if (dx > dy) {
00063     frac = dy - (dx / 2);
00064     while (x != x2) {
00065       if (frac >= 0) {
00066         y += stepy;
00067         frac -= dx;
00068       }
00069       x += stepx;
00070       frac += dy;
00071       if (x >= 0 && y >= 0 && x < screen_width && y < screen_height) this->SetPixel(video, x, y, color);
00072     }
00073   } else {
00074     frac = dx - (dy / 2);
00075     while (y != y2) {
00076       if (frac >= 0) {
00077         x += stepx;
00078         frac -= dy;
00079       }
00080       y += stepy;
00081       frac += dx;
00082       if (x >= 0 && y >= 0 && x < screen_width && y < screen_height) this->SetPixel(video, x, y, color);
00083     }
00084   }
00085 }
00086 
00087 void Blitter_32bppBase::CopyFromBuffer(void *video, const void *src, int width, int height)
00088 {
00089   uint32 *dst = (uint32 *)video;
00090   uint32 *usrc = (uint32 *)src;
00091 
00092   for (; height > 0; height--) {
00093     memcpy(dst, usrc, width * sizeof(uint32));
00094     usrc += width;
00095     dst += _screen.pitch;
00096   }
00097 }
00098 
00099 void Blitter_32bppBase::CopyToBuffer(const void *video, void *dst, int width, int height)
00100 {
00101   uint32 *udst = (uint32 *)dst;
00102   uint32 *src = (uint32 *)video;
00103 
00104   for (; height > 0; height--) {
00105     memcpy(udst, src, width * sizeof(uint32));
00106     src += _screen.pitch;
00107     udst += width;
00108   }
00109 }
00110 
00111 void Blitter_32bppBase::CopyImageToBuffer(const void *video, void *dst, int width, int height, int dst_pitch)
00112 {
00113   uint32 *udst = (uint32 *)dst;
00114   uint32 *src = (uint32 *)video;
00115 
00116   for (; height > 0; height--) {
00117     memcpy(udst, src, width * sizeof(uint32));
00118     src += _screen.pitch;
00119     udst += dst_pitch;
00120   }
00121 }
00122 
00123 void Blitter_32bppBase::ScrollBuffer(void *video, int &left, int &top, int &width, int &height, int scroll_x, int scroll_y)
00124 {
00125   const uint32 *src;
00126   uint32 *dst;
00127 
00128   if (scroll_y > 0) {
00129     /*Calculate pointers */
00130     dst = (uint32 *)video + left + (top + height - 1) * _screen.pitch;
00131     src = dst - scroll_y * _screen.pitch;
00132 
00133     /* Decrease height and increase top */
00134     top += scroll_y;
00135     height -= scroll_y;
00136     assert(height > 0);
00137 
00138     /* Adjust left & width */
00139     if (scroll_x >= 0) {
00140       dst += scroll_x;
00141       left += scroll_x;
00142       width -= scroll_x;
00143     } else {
00144       src -= scroll_x;
00145       width += scroll_x;
00146     }
00147 
00148     for (int h = height; h > 0; h--) {
00149       memcpy(dst, src, width * sizeof(uint32));
00150       src -= _screen.pitch;
00151       dst -= _screen.pitch;
00152     }
00153   } else {
00154     /* Calculate pointers */
00155     dst = (uint32 *)video + left + top * _screen.pitch;
00156     src = dst - scroll_y * _screen.pitch;
00157 
00158     /* Decrese height. (scroll_y is <=0). */
00159     height += scroll_y;
00160     assert(height > 0);
00161 
00162     /* Adjust left & width */
00163     if (scroll_x >= 0) {
00164       dst += scroll_x;
00165       left += scroll_x;
00166       width -= scroll_x;
00167     } else {
00168       src -= scroll_x;
00169       width += scroll_x;
00170     }
00171 
00172     /* the y-displacement may be 0 therefore we have to use memmove,
00173      * because source and destination may overlap */
00174     for (int h = height; h > 0; h--) {
00175       memmove(dst, src, width * sizeof(uint32));
00176       src += _screen.pitch;
00177       dst += _screen.pitch;
00178     }
00179   }
00180 }
00181 
00182 int Blitter_32bppBase::BufferSize(int width, int height)
00183 {
00184   return width * height * sizeof(uint32);
00185 }
00186 
00187 void Blitter_32bppBase::PaletteAnimate(uint start, uint count)
00188 {
00189   /* By default, 32bpp doesn't have palette animation */
00190 }
00191 
00192 Blitter::PaletteAnimation Blitter_32bppBase::UsePaletteAnimation()
00193 {
00194   return Blitter::PALETTE_ANIMATION_NONE;
00195 }

Generated on Wed Oct 1 17:03:20 2008 for openttd by  doxygen 1.5.6