DLL——SDL_PingGe
这篇随笔专门做SDL的DLL开发。
下面这个版本暂且称为Beta版本吧。
/* typedef void (*FUNCTION)(void); HMODULE HDll; HDll = LoadLibrary("SDL_PingGe.dll"); if(HDll == NULL) { printf("Load library failed!\n"); FreeLibrary(HDll); return 0; } FUNCTION fun = FUNCTION(GetProcAddress(HDll,MAKEINTRESOURCE(1))); */ #ifndef __SDL_PINGGE_H__ #define __SDL_PINGGE_H__ //To use this exported function of dll, include this header in your project. #include <windows.h> //The SDL header #include "SDL/SDL.h" #include "SDL/SDL_image.h" #include "SDL/SDL_ttf.h" #include "SDL/SDL_mixer.h" #include "SDL/SDL_net.h" #include <string> #include <sstream> #include <queue> #include <cmath> #ifdef BUILD_DLL #define DLL_EXPORT __declspec(dllexport) #else #define DLL_EXPORT __declspec(dllimport) #endif #ifdef __cplusplus extern "C" { #endif namespace PingGe { /* Load the picture and optimize it! If you want to set the colorkey,make the falg on true! Return the surface! */ DLL_EXPORT SDL_Surface* Load_Image(std::string filename, Uint8 R = 0x00, Uint8 G = 0x00, Uint8 B = 0x00, bool flag = false); /* Set the color key */ DLL_EXPORT void Color_Key(SDL_Surface* surface, Uint8 R, Uint8 G, Uint8 B); /* Return true if lock success! */ DLL_EXPORT bool Lock(SDL_Surface* surface); /* Ulock the surface, if the surface is Locked! */ DLL_EXPORT void ULock(SDL_Surface* surface); /* Apply the source_surface on the destination_surface! Return true if success! */ DLL_EXPORT bool Apply_Surface(SDL_Surface* destination, Sint32 x, Sint32 y, SDL_Surface* source, SDL_Rect* clip = NULL); /* Return the pixel value at (x, y)! NOTE: The surface must be locked before calling this! */ DLL_EXPORT Uint32 SDL_GetPixel(SDL_Surface* surface, Sint32 x, Sint32 y); /* Set the pixel at (x, y) to the given value! NOTE: The surface must be locked before calling this! */ DLL_EXPORT void SDL_PutPixel(SDL_Surface* surface, Sint32 x, Sint32 y, Uint32 pixel); /* Seedfill the surface if the pixel isn't Fillcolor and Boundarycolor! NOTE: The surface must be locked before calling this! */ DLL_EXPORT void Seed_Fill(SDL_Surface *surface, Sint32 x, Sint32 y, Uint32 Fill_Color, Uint32 Boundary_Color); /* Draw a line from (x1,y1) to (x2,y2)! NOTE: The surface must be locked before calling this! */ DLL_EXPORT void Draw_Line(SDL_Surface* surface, Sint32 x1, Sint32 y1, Sint32 x2, Sint32 y2, Uint32 pixel); /* Draw a circle which the C is (xc,yc), R is radius! NOTE: The surface must be locked before calling this! */ DLL_EXPORT void Draw_Circle(SDL_Surface* surface, Sint32 xc, Sint32 yc, Sint32 radius, Uint32 pixel); /* Draw a rect! NOTE: The surface must be locked before calling this! */ DLL_EXPORT void Draw_Rect(SDL_Surface* surface, Sint32 x1, Sint32 y1, Sint32 x2, Sint32 y2, Uint32 pixel); /* Draw a Fillrect with pixel! NOTE: The surface must be locked before calling this! */ DLL_EXPORT void Draw_FillRect(SDL_Surface* surface, Sint32 x1, Sint32 y1, Sint32 x2, Sint32 y2, Uint32 pixel); /* Fill color with color_fill in the boundary! NOTE: The surface must be locked before calling this! */ DLL_EXPORT void Color_Fill(SDL_Surface *surface, Sint32 x, Sint32 y, Uint32 fill_color, Uint32 boundary_color); /* Zoom the surface as W:width and H:height! If you don't use the old surface, better to free it! NOTE: The surface must be locked before calling this! */ DLL_EXPORT SDL_Surface* SDL_ScaleSurface(SDL_Surface *surface, Sint32 width, Sint32 height); //The timer class DLL_EXPORT Timer { public: //Initializes variables Timer(void); //The various clock actions void Start(void); void Stop(void); void Pause(void); void Unpause(void); //Gets the timer's time int Get_Ticks(void); //Checks the status of the timer bool Is_Started(void); bool Is_Paused(void); private: //The clock time when the timer started int startTicks; //The ticks stored when the timer was paused int pausedTicks; //The timer status bool paused; bool started; }; //The logo shower class DLL_EXPORT Logo { public: //Initializes variables Logo(SDL_Surface* _Logo, SDL_Surface* _Destination, Sint32 _Center_x, Sint32 _Center_y); //Reduce the logo 'Time' times, Fps void Act1(Sint32 Time, Sint32 _Fps); //Fly in from left void Act2(Sint32 _Fps); //Up to down show void Act3(Sint32 _Fps); private: SDL_Surface *logo, *destination; //The center-coordinate of the logo in the destination surface Sint32 Center_x, Center_y; }; //Hide the old_cursor and show the new_cursor class DLL_EXPORT Cursor { public: //Load the screen and the cursor_surface Cursor(SDL_Surface *_background, SDL_Surface *_cursor, Sint32 _click_x = 0, Sint32 _click_y = 0); void Get_Background(void); void Cursor_Blit(void); void Blit_Background(void); void Update_Background(void); //You only need to use this function void Show_Cursor(Sint32 _x, Sint32 _y); private: SDL_Surface *cursor; SDL_Surface *cursor_s; SDL_Surface *background; Sint32 x, y; Sint32 click_x, click_y; SDL_Rect old_rect; }; //The button class DLL_EXPORT Button { public: //Initialize the variables Button(SDL_Surface *surface, Sint32 x, Sint32 y, Sint32 w, Sint32 h); //Set the button nature void Set_Button_Pic (SDL_Surface* surface); void Set_MOUSEOVER_Clip (Sint32 x, Sint32 y, Sint32 w, Sint32 h); void Set_MOUSEOUT_Clip (Sint32 x, Sint32 y, Sint32 w, Sint32 h); void Set_MOUSEDOWN_Clip (Sint32 x, Sint32 y, Sint32 w, Sint32 h); void Set_MOUSEUP_Clip (Sint32 x, Sint32 y, Sint32 w, Sint32 h); /* Handles events and set the button's sprite region Return Button::CLIP_MOUSEOVER, if cursor is over the button etc.. */ Sint32 Handle_Events(SDL_Event event); //Shows the button on the screen void Show(void); private: //The attributes of the button SDL_Rect box; //The part of the button sprite sheet that will be shown SDL_Rect* clip; //The button surface SDL_Surface* button; //The background surface SDL_Surface* background; //The clip cut a surface in four pieces SDL_Rect clips[4]; public: //The button states in the sprite sheet Sint32 CLIP_MOUSEOVER, CLIP_MOUSEOUT, CLIP_MOUSEDOWN, CLIP_MOUSEUP; }; } #ifdef __cplusplus } #endif //#undef VS_DLL #endif // __SDL_PINGGE_H__
#include "SDL_PingGe.h" using namespace std; namespace PingGe { DLL_EXPORT SDL_Surface* Load_Image(std::string filename, Uint8 R, Uint8 G, Uint8 B, bool flag) { //The image that's loaded SDL_Surface* loadedImage = NULL; //The optimized image that will be used SDL_Surface* optimizedImage = NULL; //Load the image loadedImage = IMG_Load(filename.c_str()); //If the image loaded if(loadedImage != NULL) { //Create an optimized image optimizedImage = SDL_DisplayFormatAlpha(loadedImage); //Free the old image SDL_FreeSurface(loadedImage); //If the image was optimized just fine if(optimizedImage != NULL && flag == true) { //Map the color key Uint32 colorkey = SDL_MapRGB(optimizedImage->format, R, G, B); //Set all pixels of color R, G, B to be transparent SDL_SetColorKey(optimizedImage, SDL_RLEACCEL | SDL_SRCCOLORKEY, colorkey); } } //Return the optimized image return optimizedImage; } DLL_EXPORT void Color_Key(SDL_Surface* surface, Uint8 R, Uint8 G, Uint8 B) { //Map the color key Uint32 colorkey = SDL_MapRGB(surface->format, R, G, B); //Set all pixels of color R, G, B to be transparent SDL_SetColorKey(surface, SDL_RLEACCEL | SDL_SRCCOLORKEY, colorkey); } DLL_EXPORT bool Lock(SDL_Surface* surface) { if(SDL_MUSTLOCK(surface)) { if(SDL_LockSurface(surface)<0) { return false; } } return true; } DLL_EXPORT void ULock(SDL_Surface* surface) { if(SDL_MUSTLOCK(surface)) { SDL_UnlockSurface(surface); } } DLL_EXPORT bool Apply_Surface(SDL_Surface* destination, Sint32 x, Sint32 y, SDL_Surface* source, SDL_Rect* clip) { //Holds offsets SDL_Rect offset; //Get offsets offset.x = x; offset.y = y; //Blit if(SDL_BlitSurface(source, clip, destination, &offset) == -1) { return false; } return true; } DLL_EXPORT Uint32 SDL_GetPixel(SDL_Surface* surface, Sint32 x, Sint32 y) { Sint32 bpp = surface->format->BytesPerPixel; /* Here p is the address to the pixel we want to retrieve */ Uint8 *p=(Uint8*)surface->pixels + y*surface->pitch + x*bpp;//? switch(bpp) { case 1: { return *p; } case 2: { return *(Uint16*)p; } case 3: { if(SDL_BYTEORDER==SDL_BIG_ENDIAN) { return p[0]<<16|p[1]<<8|p[2]; } else { return p[0]|p[1]<<8|p[2]<<16; } } case 4: { return *(Uint32*)p; } default: { return 0; /* shouldn't happen, but avoids warnings */ } } } DLL_EXPORT void SDL_PutPixel(SDL_Surface* surface, Sint32 x, Sint32 y, Uint32 pixel) { Sint32 bpp = surface->format->BytesPerPixel; /* Here p is the address to the pixel we want to set */ Uint8 *p = (Uint8*)surface->pixels + y * surface->pitch + x * bpp; switch(bpp) { case 1: { *p = pixel; } break; case 2: { *(Uint16*)p = pixel; } break; case 3: { if(SDL_BYTEORDER == SDL_BIG_ENDIAN) { p[0] = (pixel>>16) & 0xff; p[1] = (pixel>>8) & 0xff; p[2] = (pixel) & 0xff; } else { p[0] = (pixel) & 0xff; p[1] = (pixel>>8) & 0xff; p[2] = (pixel>>16) & 0xff; } } break; case 4: { *(Uint32*)p = pixel; } break; } } DLL_EXPORT void Seed_Fill(SDL_Surface *surface, Sint32 x, Sint32 y, Uint32 Fill_Color, Uint32 Boundary_Color) { Uint32 color = PingGe::SDL_GetPixel(surface, x, y); if((color != Boundary_Color) && (color != Fill_Color)) { PingGe::SDL_PutPixel(surface, x, y, Fill_Color); } } DLL_EXPORT void Draw_Line(SDL_Surface* surface, Sint32 x1, Sint32 y1, Sint32 x2, Sint32 y2, Uint32 pixel) { double delta_x, delta_y, x, y; Sint32 dx, dy, steps, k; dx = x2 - x1; dy = y2 - y1; if(abs(dx) > abs(dy)) { steps = abs(dx); } else { steps = abs(dy); } delta_x = (double)dx / (double)steps; delta_y = (double)dy / (double)steps; x = x1; y = y1; PingGe::SDL_PutPixel(surface, x, y, pixel); for(k = 0; k < steps; k++) { x += delta_x; y += delta_y; PingGe::SDL_PutPixel(surface, x, y, pixel); } } DLL_EXPORT void Draw_Circle(SDL_Surface* surface, Sint32 xc, Sint32 yc, Sint32 radius, Uint32 pixel) { Sint32 x, y, p; x = 0; y = radius; p = 3 - 2 * radius; while(x < y) { PingGe::SDL_PutPixel(surface, xc + x, yc + y, pixel); PingGe::SDL_PutPixel(surface, xc - x, yc + y, pixel); PingGe::SDL_PutPixel(surface, xc + x, yc - y, pixel); PingGe::SDL_PutPixel(surface, xc - x, yc - y, pixel); PingGe::SDL_PutPixel(surface, xc + y, yc + x, pixel); PingGe::SDL_PutPixel(surface, xc - y, yc + x, pixel); PingGe::SDL_PutPixel(surface, xc + y, yc - x, pixel); PingGe::SDL_PutPixel(surface, xc - y, yc - x, pixel); if(p < 0) { p = p + 4 * x + 6; } else { p = p + 4 * (x - y) + 10; y -= 1; } x += 1; } if(x == y) { PingGe::SDL_PutPixel(surface, xc + x, yc + y, pixel); PingGe::SDL_PutPixel(surface, xc - x, yc + y, pixel); PingGe::SDL_PutPixel(surface, xc + x, yc - y, pixel); PingGe::SDL_PutPixel(surface, xc - x, yc - y, pixel); PingGe::SDL_PutPixel(surface, xc + y, yc + x, pixel); PingGe::SDL_PutPixel(surface, xc - y, yc + x, pixel); PingGe::SDL_PutPixel(surface, xc + y, yc - x, pixel); PingGe::SDL_PutPixel(surface, xc - y, yc - x, pixel); } } DLL_EXPORT void Draw_Rect(SDL_Surface* surface, Sint32 x1, Sint32 y1, Sint32 x2, Sint32 y2, Uint32 pixel) { PingGe::Draw_Line(surface, x1, y1, x2, y1, pixel); PingGe::Draw_Line(surface, x2, y1, x2, y2, pixel); PingGe::Draw_Line(surface, x2, y2, x1, y2, pixel); PingGe::Draw_Line(surface, x1, y2, x1, y1, pixel); } DLL_EXPORT void Draw_FillRect(SDL_Surface* surface, Sint32 x1, Sint32 y1, Sint32 x2, Sint32 y2, Uint32 pixel) { for(int x = x1; x <= x2; x++) { PingGe::Draw_Line(surface, x, y1, x, y2, pixel); } } struct node { int x, y; }temp, next; DLL_EXPORT void Color_Fill(SDL_Surface *surface, Sint32 x, Sint32 y, Uint32 fill_color, Uint32 boundary_color) { const int dir[4][2] = {{0,1},{0,-1},{1,0},{-1,0}}; temp.x=x;temp.y=y; queue<node>que; que.push(temp); while(!que.empty()) { temp = que.front(); que.pop(); Uint32 color = PingGe::SDL_GetPixel(surface, temp.x, temp.y); if((color == fill_color) || (color == boundary_color)) { continue; } PingGe::SDL_PutPixel(surface, temp.x, temp.y, fill_color); for(int i = 0; i < 4; i++) { next.x = temp.x + dir[i][0]; next.y = temp.y + dir[i][1]; que.push(next); } } } DLL_EXPORT SDL_Surface* SDL_ScaleSurface(SDL_Surface *surface, Sint32 width, Sint32 height) { SDL_Surface *_ret = SDL_CreateRGBSurface(surface->flags, width, height, surface->format->BitsPerPixel, surface->format->Rmask, surface->format->Gmask, surface->format->Bmask, surface->format->Amask); double _stretch_factor_x = (static_cast <double> (width) / static_cast <double> (surface->w)), _stretch_factor_y = (static_cast <double> (height) / static_cast <double> (surface->h)); PingGe::Lock(_ret); for(Sint32 y = 0; y < surface->h; y++) //Run across all Y pixels. { for(Sint32 x = 0; x < surface->w; x++) //Run across all X pixels. { for(Sint32 o_y = 0; o_y < _stretch_factor_y; ++o_y) //Draw _stretch_factor_y pixels for each Y pixel. { for(Sint32 o_x = 0; o_x < _stretch_factor_x; ++o_x) //Draw _stretch_factor_x pixels for each X pixel. { PingGe::SDL_PutPixel(_ret, static_cast<Sint32>(_stretch_factor_x * x) + o_x, static_cast<Sint32>(_stretch_factor_y * y) + o_y, PingGe::SDL_GetPixel(surface, x, y)); } } } } PingGe::ULock(_ret); return _ret; } /*****************Timer*****************/ Timer::Timer(void) { //Initialize the variables startTicks = 0; pausedTicks = 0; paused = false; started = false; } void Timer::Start(void) { //Start the timer started = true; //Unpause the timer paused = false; //Get the current clock time startTicks = SDL_GetTicks(); } void Timer::Stop(void) { //Stop the timer started = false; //Unpause the timer paused = false; } void Timer::Pause(void) { //If the timer is running and isn't already paused if( ( started == true ) && ( paused == false ) ) { //Pause the timer paused = true; //Calculate the paused ticks pausedTicks = SDL_GetTicks() - startTicks; } } void Timer::Unpause(void) { //If the timer is paused if( paused == true ) { //Unpause the timer paused = false; //Reset the starting ticks startTicks = SDL_GetTicks() - pausedTicks; //Reset the paused ticks pausedTicks = 0; } } int Timer::Get_Ticks(void) { //If the timer is running if( started == true ) { //If the timer is paused if( paused == true ) { //Return the number of ticks when the timer was paused return pausedTicks; } else { //Return the current time minus the start time return SDL_GetTicks() - startTicks; } } //If the timer isn't running return 0; } bool Timer::Is_Started(void) { return started; } bool Timer::Is_Paused(void) { return paused; } /*****************Timer*****************/ /***************Logo_Show***************/ Logo::Logo(SDL_Surface* _Logo, SDL_Surface* _Destination, Sint32 _Center_x, Sint32 _Center_y) { logo = _Logo; destination = _Destination; Center_x = _Center_x; Center_y = _Center_y; } void Logo::Act1(Sint32 Time, Sint32 _Fps) { Timer Fps; for(Sint32 i = 0; i <= Time; i++) { Fps.Start(); SDL_Surface* img = PingGe::SDL_ScaleSurface(logo, (logo->w) - 2*i, (logo->h) - i); SDL_Rect Dest_rect; Dest_rect.x = (Center_x - (img->w)/2); Dest_rect.y = (Center_y - (img->h)/2); SDL_FillRect(destination, 0, SDL_MapRGB(destination->format, 0xff, 0xff, 0xff)); SDL_BlitSurface(img, 0, destination, &Dest_rect); SDL_FreeSurface(img); SDL_Flip(destination); if(Fps.Get_Ticks() < 1000 / _Fps) { SDL_Delay((1000 / _Fps) - Fps.Get_Ticks()); } } } void Logo::Act2(Sint32 _Fps) { Timer Fps; SDL_Rect Dest_rect, clip[3], Update_rect[3]; Dest_rect.x = (destination->w - logo->w) / 2; Dest_rect.y = (destination->h - logo->h) / 2; clip[0].x = 10; Update_rect[2].x = 0; clip[0].y = 20; Update_rect[2].y = Dest_rect.y; clip[0].w = 110; Update_rect[2].w = Dest_rect.x + 335; clip[0].h = 145; Update_rect[2].h = logo->h; clip[1].x = 120; Update_rect[1].x = 0; clip[1].y = 20; Update_rect[1].y = Dest_rect.y; clip[1].w = 125; Update_rect[1].w = Dest_rect.x + 245; clip[1].h = 145; Update_rect[1].h = logo->h; clip[2].x = 245; Update_rect[0].x = 0; clip[2].y = 20; Update_rect[0].y = Dest_rect.y; clip[2].w = 90; Update_rect[0].w = Dest_rect.x + 120; clip[2].h = 145; Update_rect[0].h = logo->h; SDL_FillRect(destination, 0, SDL_MapRGB(destination->format, 0xff, 0xff, 0xff)); SDL_Flip(destination); for(int i = -clip[2].w; i <= Dest_rect.x + clip[2].x; i++) { Fps.Start(); SDL_FillRect(destination, 0, SDL_MapRGB(destination->format, 0xff, 0xff, 0xff)); PingGe::Apply_Surface(destination, i, Dest_rect.y + clip[0].y, logo, &clip[2]); SDL_UpdateRects(destination, 1, &Update_rect[2]); if(Fps.Get_Ticks() < 1000 / _Fps) { SDL_Delay((1000 / _Fps) - Fps.Get_Ticks()); } } for(int i = -clip[1].w; i <= Dest_rect.x + clip[1].x; i++) { Fps.Start(); SDL_FillRect(destination, 0, SDL_MapRGB(destination->format, 0xff, 0xff, 0xff)); PingGe::Apply_Surface(destination, i, Dest_rect.y + clip[0].y, logo, &clip[1]); SDL_UpdateRects(destination, 1, &Update_rect[1]); if(Fps.Get_Ticks() < 1000 / _Fps) { SDL_Delay((1000 / _Fps) - Fps.Get_Ticks()); } } for(int i = -clip[0].w; i <= Dest_rect.x + clip[0].x; i++) { Fps.Start(); SDL_FillRect(destination, 0, SDL_MapRGB(destination->format, 0xff, 0xff, 0xff)); PingGe::Apply_Surface(destination, i, Dest_rect.y + clip[0].y, logo, &clip[0]); SDL_UpdateRects(destination, 1, &Update_rect[0]); if(Fps.Get_Ticks() < 1000 / _Fps) { SDL_Delay((1000 / _Fps) - Fps.Get_Ticks()); } } Act3(_Fps); } void Logo::Act3(Sint32 _Fps) { Timer Fps; SDL_Rect Dest_rect, up_down_clip, right_left_clip, small_rect_clip; Dest_rect.x = (destination->w - logo->w) / 2; Dest_rect.y = (destination->h - logo->h) / 2; up_down_clip.x = Dest_rect.x; up_down_clip.y = Dest_rect.y; up_down_clip.w = logo->w; up_down_clip.h = 1; right_left_clip.x = Dest_rect.x + 425; right_left_clip.y = Dest_rect.y + 165; right_left_clip.w = 1; right_left_clip.h = logo->h; small_rect_clip.x = Dest_rect.x + 425; small_rect_clip.y = Dest_rect.y + 165; small_rect_clip.w = 15; small_rect_clip.h = 15; PingGe::Apply_Surface(destination, Dest_rect.x, Dest_rect.y, logo); for(int i = up_down_clip.y; i <= right_left_clip.y; i++) { Fps.Start(); up_down_clip.y++; SDL_UpdateRects(destination, 1, &up_down_clip); if(Fps.Get_Ticks() < 1000 / _Fps) { SDL_Delay((1000 / _Fps) - Fps.Get_Ticks()); } } SDL_UpdateRects(destination, 1, &small_rect_clip); for(int i = right_left_clip.x; i >= up_down_clip.x; i--) { Fps.Start(); right_left_clip.x--; SDL_UpdateRects(destination, 1, &right_left_clip); if(Fps.Get_Ticks() < 1000 / _Fps) { SDL_Delay((1000 / _Fps) - Fps.Get_Ticks()); } } } /***************Logo_Show***************/ /****************Cursor****************/ Cursor::Cursor(SDL_Surface *_background, SDL_Surface *_cursor, Sint32 _click_x, Sint32 _click_y) { background = _background; cursor = _cursor; cursor_s = SDL_CreateRGBSurface(_cursor->flags, _cursor->w, _cursor->h, _cursor->format->BitsPerPixel, _cursor->format->Rmask, _cursor->format->Gmask, _cursor->format->Bmask, _cursor->format->Amask); click_x = _click_x; click_y = _click_y; //Close the old cursor SDL_ShowCursor(0); old_rect.x = 0; old_rect.y = 0; old_rect.w = 0; old_rect.h = 0; } void Cursor::Get_Background(void) { /* Blits a surface sized chunk of background to that surface */ SDL_Rect src; SDL_Rect dst; src.x = x; src.y = y; src.w = cursor_s->w; src.h = cursor_s->h; dst.x = 0; dst.y = 0; dst.w = cursor_s->w; dst.h = cursor_s->h; SDL_BlitSurface(background, &src, cursor_s, &dst); } void Cursor::Cursor_Blit(void) { SDL_Rect dest; dest.x = x; dest.y = y; dest.w = cursor->w; dest.h = cursor->h; SDL_BlitSurface(cursor, NULL, background, &dest); } void Cursor::Blit_Background(void) { SDL_Rect dest; dest.x = x; dest.y = y; dest.w = cursor_s->w; dest.h = cursor_s->h; SDL_BlitSurface(cursor_s, NULL, background, &dest); old_rect = dest; } void Cursor::Update_Background(void) { SDL_Rect clip[2]; clip[0].x = x-50; clip[0].y = y-50; clip[0].w = cursor->w+100; clip[0].h = cursor->h+100; clip[1] = old_rect; clip[1].x = clip[1].x-50; clip[1].y = clip[1].y-50; clip[1].w = clip[1].w+100; clip[1].h = clip[1].h+100; SDL_UpdateRects(background, 2, clip); } void Cursor::Show_Cursor(Sint32 _x, Sint32 _y) { x = _x - click_x; y = _y - click_y; Get_Background(); Cursor_Blit(); Update_Background(); Blit_Background(); } /****************Cursor****************/ /****************Button****************/ Button::Button(SDL_Surface *surface, Sint32 x, Sint32 y, Sint32 w, Sint32 h) { //Init CLIP_MOUSEOVER = 0; CLIP_MOUSEOUT = 1; CLIP_MOUSEDOWN = 2; CLIP_MOUSEUP = 3; //Set the background surface background = surface; //Set the button's attributes box.x = x; box.y = y; box.w = w; box.h = h; //Set the default sprite clip = &clips[ CLIP_MOUSEOUT ]; } void Button::Set_Button_Pic(SDL_Surface* surface) { button = surface; } void Button::Set_MOUSEOVER_Clip (Sint32 x, Sint32 y, Sint32 w, Sint32 h) { clips[ CLIP_MOUSEOVER ].x = x; clips[ CLIP_MOUSEOVER ].y = y; clips[ CLIP_MOUSEOVER ].w = w; clips[ CLIP_MOUSEOVER ].h = h; } void Button::Set_MOUSEOUT_Clip (Sint32 x, Sint32 y, Sint32 w, Sint32 h) { clips[ CLIP_MOUSEOUT ].x = x; clips[ CLIP_MOUSEOUT ].y = y; clips[ CLIP_MOUSEOUT ].w = w; clips[ CLIP_MOUSEOUT ].h = h; } void Button::Set_MOUSEDOWN_Clip (Sint32 x, Sint32 y, Sint32 w, Sint32 h) { clips[ CLIP_MOUSEDOWN ].x = x; clips[ CLIP_MOUSEDOWN ].y = y; clips[ CLIP_MOUSEDOWN ].w = w; clips[ CLIP_MOUSEDOWN ].h = h; } void Button::Set_MOUSEUP_Clip (Sint32 x, Sint32 y, Sint32 w, Sint32 h) { clips[ CLIP_MOUSEUP ].x = x; clips[ CLIP_MOUSEUP ].y = y; clips[ CLIP_MOUSEUP ].w = w; clips[ CLIP_MOUSEUP ].h = h; } Sint32 Button::Handle_Events(SDL_Event event) { //The mouse offsets Sint32 x = 0, y = 0; //If the mouse moved if( event.type == SDL_MOUSEMOTION ) { //Get the mouse offsets x = event.motion.x; y = event.motion.y; //If the mouse is over the button if( ( x > box.x ) && ( x < box.x + box.w ) && ( y > box.y ) && ( y < box.y + box.h ) ) { //Set the button sprite clip = &clips[ CLIP_MOUSEOVER ]; return CLIP_MOUSEOVER; } //If not else { //Set the button sprite clip = &clips[ CLIP_MOUSEOUT ]; return CLIP_MOUSEOUT; } } //If a mouse button was pressed if( event.type == SDL_MOUSEBUTTONDOWN ) { //If the left mouse button was pressed if( event.button.button == SDL_BUTTON_LEFT ) { //Get the mouse offsets x = event.button.x; y = event.button.y; //If the mouse is over the button if( ( x > box.x ) && ( x < box.x + box.w ) && ( y > box.y ) && ( y < box.y + box.h ) ) { //Set the button sprite clip = &clips[ CLIP_MOUSEDOWN ]; return CLIP_MOUSEDOWN; } } } //If a mouse button was released if( event.type == SDL_MOUSEBUTTONUP ) { //If the left mouse button was released if( event.button.button == SDL_BUTTON_LEFT ) { //Get the mouse offsets x = event.button.x; y = event.button.y; //If the mouse is over the button if( ( x > box.x ) && ( x < box.x + box.w ) && ( y > box.y ) && ( y < box.y + box.h ) ) { //Set the button sprite clip = &clips[ CLIP_MOUSEUP ]; return CLIP_MOUSEUP; } } } return -1; } void Button::Show(void) { //Show the button PingGe::Apply_Surface(background, box.x, box.y, button, clip); } /****************Button****************/ }