SDLUtility Namespace Reference

These are SDL-specific utilities that don't fit into a single class very well. More...

Functions
SDL_Color	PColorToSDLColor (PColor pcolor)
	This converts between a PColor and an SDL color.
PColor	SDLColorToPColor (SDL_Color scolor)
	This converts between an SDL Color and a PColor
void	DrawPixel (SDL_Renderer *renderer, PlatformWidget *pwidget, int x, int y, PColor color)
	This sets a pixel to be a certain color.
void	DrawLine (SDL_Renderer *renderer, PlatformWidget *pwidget, int x1, int y1, int x2, int y2, PColor color)
	This sets a pixel to be a certain color.
Uint32	GetPixel (SDL_Surface *surface, int x, int y)
PColor	GetPixelColor (SDL_Surface *surface, int x, int y)
	This extracts the color of a pixel.
Uint32	GetPixel (SDL_Renderer *renderer, SDL_Texture *texture, int x, int y)
PColor	GetPixelColor (SDL_Renderer *renderer, SDL_Texture *texture, int x, int y)
	This extracts the color of a pixel.
int	WritePNG (SDL_Renderer *renderer, SDL_Rect *rect, const std::string fname)
Variant	GetCurrentScreenResolution ()
void	CopyToClipboard (std::string text)
Variant	CopyFromClipboard ()
int	PopupErrorBox (PlatformWindow *pwindow, const char *message)
long double	GetTimeHP ()
Variant	GetDriverList (bool printout=true)

Detailed Description

These are SDL-specific utilities that don't fit into a single class very well.

Function Documentation

CopyFromClipboard()

Variant SDLUtility::CopyFromClipboard

(

)

Definition at line 389 of file SDLUtility.cpp.

{
    Variant out="";
    if(SDL_HasClipboardText())
        {
            char * text =   SDL_GetClipboardText();
            out = Variant(text);
            SDL_free(text);            
        }
 
    return out;
}

Referenced by PEBLEnvironment::CopyFromClipboard().

CopyToClipboard()

void SDLUtility::CopyToClipboard

(

std::string

text

)

Definition at line 379 of file SDLUtility.cpp.

{
 
   int out = SDL_SetClipboardText(text.c_str());
   if(out<0)
       {
           PError::SignalWarning("Failed to copy text to clipboard\n");
       }
}

References PError::SignalWarning().

Referenced by PEBLEnvironment::CopyToClipboard().

DrawLine()

void SDLUtility::DrawLine	(	SDL_Renderer *	renderer,
		PlatformWidget *	pwidget,
		int	x1,
		int	y1,
		int	x2,
		int	y2,
		PColor	color
	)

This sets a pixel to be a certain color.

Definition at line 106 of file SDLUtility.cpp.

{
  //  SDL_Color sdlcolor = PColorToSDLColor(pcolor);
    //to draw to a widget, we need to set render target:
    int out = SDL_SetRenderTarget(renderer, widget->GetSDL_Texture());
    
    if(out<0)
        {
            cerr << "setrendertarget result in drawline: "<< out <<endl;
            cerr << SDL_GetError() <<endl;
        }
    
    SDL_SetRenderDrawColor(renderer,
                           pcolor.GetRed(), pcolor.GetGreen(),
                           pcolor.GetBlue(), pcolor.GetAlpha());
    
 
    //x and y position are absolute to window, so we need to adjust to
    //widget location
    
    int newX1 = x1;
    int newY1 = y1;
    int newX2 = x2;
    int newY2 = y2;
 
 
    SDL_RenderDrawLine(renderer,newX1,newY1,newX2,newY2);
    SDL_SetRenderTarget(renderer,NULL);
 
}

References PColor::GetAlpha(), PColor::GetBlue(), PColor::GetGreen(), PColor::GetRed(), PlatformWidget::GetSDL_Texture(), and NULL.

DrawPixel()

void SDLUtility::DrawPixel	(	SDL_Renderer *	renderer,
		PlatformWidget *	pwidget,
		int	x,
		int	y,
		PColor	color
	)

This sets a pixel to be a certain color.

Definition at line 72 of file SDLUtility.cpp.

{
    
    cerr << "drawing " << x << ","<< y << endl;
#if 0
    if(renderer)
        cerr << "Line renderer: " << renderer << endl;
    else
        cerr << "renderer is null\n";
 
#endif
 
    cerr <<" texture " << widget->GetSDL_Texture() << endl;
 
    SDL_SetRenderTarget(renderer, widget->GetSDL_Texture());
    //    SDL_Color sdlcolor = PColorToSDLColor(pcolor);
    cerr << pcolor.GetRed() <<
        "," << pcolor.GetGreen() << "," <<
        pcolor.GetBlue() << "," <<  pcolor.GetAlpha() << endl;
    
                                                         
                                                         
    SDL_SetRenderDrawColor(renderer, pcolor.GetRed(), pcolor.GetGreen(), pcolor.GetBlue(), pcolor.GetAlpha());
    //this offset may be  needed because renderer references coordinates to the window,
    //not the widget.  It may screw up drawing on center-coordinated widgets
    SDL_RenderPresent(renderer);
    
    //like images and labels.
    SDL_RenderDrawPoint(renderer,(int)(widget->GetX()+x),(int)(widget->GetY()+y));
    
    //    SDL_SetRenderTarget(renderer,NULL);
}

References PColor::GetAlpha(), PColor::GetBlue(), PColor::GetGreen(), PColor::GetRed(), PlatformWidget::GetSDL_Texture(), PWidget::GetX(), and PWidget::GetY().

Referenced by PlatformWidget::SetPoint().

GetCurrentScreenResolution()

Variant SDLUtility::GetCurrentScreenResolution

(

)

Definition at line 320 of file SDLUtility.cpp.

{
 
 
 
  int i;
 
  // Declare display mode structure to be filled in.
  SDL_DisplayMode current;
 
  // Get current display mode of all displays.
  for(i = 0; i < SDL_GetNumVideoDisplays(); ++i){
 
    int should_be_zero = SDL_GetCurrentDisplayMode(i, &current);
 
    if(should_be_zero != 0)
      // In case of error...
      SDL_Log("Could not get display mode for video display #%d: %s", i, SDL_GetError());
 
    else
      // On success, print the current display mode.
      SDL_Log("Display #%d: current display mode is %dx%dpx @ %dhz. \n", i, current.w, current.h, current.refresh_rate);
 
  }
 
 
    //THere is a new function for this, which depends
    // on the actual screen
 
    SDL_DisplayMode  info;// = SDL_GetVideoInfo();
    int success = SDL_GetCurrentDisplayMode(0,&info);
    //might also use SDL_GetDesktopDisplayMode()
    cerr << "SUCCESS at getting display mode?:" <<success << endl;
 
    int w,h,rate;
    if(success==0)
        {
            cerr << info.w << "," << info.h <<"," << info.refresh_rate << endl;
            w = info.w;
            h = info.h;
            rate =info.refresh_rate;
 
        } else {
        cerr << "SDL_Init failed: " << SDL_GetError() << endl;
        PError::SignalFatalError(SDL_GetError());
    }
 
 
    PList * newlist = new PList();
    newlist->PushBack(Variant(w));
    newlist->PushBack(Variant(h));
 
    counted_ptr<PEBLObjectBase> newlist2 = counted_ptr<PEBLObjectBase>(newlist);
    PComplexData * pcd=new PComplexData(newlist2);
    return Variant(pcd);
 
}

References PList::PushBack(), and PError::SignalFatalError().

Referenced by PEBLEnvironment::GetCurrentScreenResolution(), and PEBLInterpret().

GetDriverList()

Variant SDLUtility::GetDriverList

(

bool

printout = true

)

Definition at line 422 of file SDLUtility.cpp.

{
 
    PList * plist = new PList();
    PComplexData*pcd=NULL;
 
    if(printout)
        {
            std::cerr << "=================================================\n";
            std::cerr << "    Available drivers\n";
            std::cerr << "=================================================\n";
        }
    
    int numdrivers = SDL_GetNumRenderDrivers ();
    if(printout)   std::cerr << "Render driver count: " << numdrivers << endl;
    for (int i=0; i<numdrivers;   i++)
        {
            SDL_RendererInfo drinfo;
            SDL_GetRenderDriverInfo (i, &drinfo);
            if(printout)
                {
                    cerr << "Driver name ("<<i<<"): " << drinfo.name << endl;
                    if (drinfo.flags & SDL_RENDERER_SOFTWARE) std::cerr << " the renderer is a software fallback" << endl;
                    if (drinfo.flags & SDL_RENDERER_ACCELERATED) std::cerr << " the renderer uses hardware acceleration" << endl;
                    if (drinfo.flags & SDL_RENDERER_PRESENTVSYNC) std::cerr << " present is synchronized with the refresh rate" << endl;
                    if (drinfo.flags & SDL_RENDERER_TARGETTEXTURE) std::cerr << " the renderer supports rendering to texture" << endl;
                }
            plist->PushBack(Variant(drinfo.name));
        }
 
    if(printout)      std::cerr << "=================================================\n";
 
    counted_ptr<PEBLObjectBase> tmplist = counted_ptr<PEBLObjectBase>(plist);
    pcd = new PComplexData(tmplist);
    Variant tmp = Variant(pcd);
    delete pcd;
   
    return tmp;
}

References NULL, and PList::PushBack().

Referenced by PEBLEnvironment::GetDrivers(), and PlatformWindow::Initialize().

GetPixel() [1/2]

Uint32 SDLUtility::GetPixel	(	SDL_Renderer *	renderer,
		SDL_Texture *	texture,
		int	x,
		int	y
	)

Definition at line 197 of file SDLUtility.cpp.

    {
 
        int pitch,w,h;
        void* pixels;
        Uint32 format;
        SDL_SetTextureBlendMode(texture,SDL_BLENDMODE_BLEND);
        SDL_QueryTexture(texture,&format,&w,&h,&pitch);
        SDL_LockTexture(texture,NULL,&pixels,&pitch);
        Uint32 * upixels = (Uint32*) pixels;
 
        //        int pixel[3];
        //        SDL_Rect rect = {x,y,1,1};
        //        SDL_RenderReadPixels(renderer,&rect,1,(void *)pixel,1*4);
 
        int i = pitch*(w*x+y);
 
       //upixels[i] should be the right pixel
        Uint32 pixel = upixels[i];
        SDL_UnlockTexture(texture);
        return pixel;
 
 
#ifdef SDL2_DELETE
        int 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 */
     } // switch
#endif
 
 
 }

References NULL.

GetPixel() [2/2]

Uint32 SDLUtility::GetPixel	(	SDL_Surface *	surface,
		int	x,
		int	y
	)

Definition at line 145 of file SDLUtility.cpp.

    {
        int 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 */
     } // switch
 }

Referenced by GetPixelColor().

GetPixelColor() [1/2]

PColor SDLUtility::GetPixelColor	(	SDL_Renderer *	renderer,
		SDL_Texture *	texture,
		int	x,
		int	y
	)

This extracts the color of a pixel.

Definition at line 254 of file SDLUtility.cpp.

{
 
 
 
        int pitch,w,h;
        void* pixels;
        Uint32  format;
 
 
        SDL_SetTextureBlendMode(texture,SDL_BLENDMODE_BLEND);
        SDL_QueryTexture(texture,&format,&w,&h,&pitch);
        int success = SDL_LockTexture(texture,NULL,&pixels,&pitch);
        if(success<0)
            {
                cerr << SDL_GetError() << endl;
            }
        Uint32 * upixels = (Uint32*) pixels;
        SDL_PixelFormat* fmt= SDL_AllocFormat(format);
        //        int pixel[3];
        //        SDL_Rect rect = {x,y,1,1};
        //        SDL_RenderReadPixels(renderer,&rect,1,(void *)pixel,1*4);
 
        int i = pitch*(w*y+x);
 
       //upixels[i] should be the right pixel
        Uint32 pixel = upixels[i];
        SDL_UnlockTexture(texture);
 
 
 
 
    Uint8 r=0;
    Uint8 g=0;
    Uint8 b=0;
    Uint8 a = 0;
 
    SDL_GetRGBA(pixel,fmt, &r,&g,&b,&a);
 
    //    cerr <<"Uint pxl:" << pxl << endl;
    //#endif
 
    PColor col = PColor(r,g,b,a);
    return col;
}

References NULL.

GetPixelColor() [2/2]

PColor SDLUtility::GetPixelColor	(	SDL_Surface *	surface,
		int	x,
		int	y
	)

This extracts the color of a pixel.

Definition at line 174 of file SDLUtility.cpp.

{
    Uint32 pxl =GetPixel(surface,x,y);
    Uint8 r;
    Uint8 g;
    Uint8 b;
 
    SDL_GetRGB(pxl, surface->format, &r,&g,&b);
 
    //    cerr <<"Uint pxl:" << pxl << endl;
    PColor col = PColor(r,g,b,0);
    return col;
}

References GetPixel().

Referenced by PlatformWidget::GetPixel().

GetTimeHP()

long double SDLUtility::GetTimeHP

(

)

Definition at line 414 of file SDLUtility.cpp.

{
    //    std::cerr << SDL_GetPerformanceFrequency() <<std::endl;
    std::cerr << SDL_GetPerformanceCounter() <<"/"<< SDL_GetPerformanceFrequency() <<std::endl;
    return  ((long double)SDL_GetPerformanceCounter())/(long double)SDL_GetPerformanceFrequency()*1000.0;
}

Referenced by PEBLEnvironment::GetTimeHP().

PColorToSDLColor()

SDL_Color SDLUtility::PColorToSDLColor

(

PColor

pcolor

)

This converts between a PColor and an SDL color.

These are SDL-specific utilities that don't fit into a single class very well.

Definition at line 51 of file SDLUtility.cpp.

{
  SDL_Color scolor;
  scolor.r = pcolor.GetRed();
  scolor.g = pcolor.GetGreen();
  scolor.b = pcolor.GetBlue();
  scolor.a = pcolor.GetAlpha();
 
  return scolor;
}

References PColor::GetAlpha(), PColor::GetBlue(), PColor::GetGreen(), and PColor::GetRed().

Referenced by PlatformFont::PlatformFont(), PlatformFont::PlatformFont(), PlatformFont::SetBackgroundColor(), PlatformFont::SetFontColor(), and PlatformFont::UpdateSDLColors().

PopupErrorBox()

int SDLUtility::PopupErrorBox	(	PlatformWindow *	pwindow,
		const char *	message
	)

Definition at line 403 of file SDLUtility.cpp.

{
 
    SDL_Window * window = pwindow->GetSDLWindow();
    return SDL_ShowSimpleMessageBox(SDL_MESSAGEBOX_ERROR,
                                    "An error occurred\n",
                                    message,window);
}

References PlatformWindow::GetSDLWindow().

SDLColorToPColor()

PColor SDLUtility::SDLColorToPColor

(

SDL_Color

scolor

)

This converts between an SDL Color and a PColor

Definition at line 62 of file SDLUtility.cpp.

{
 
  return PColor(scolor.r, scolor.g, scolor.b, scolor.a);
}

WritePNG()

int SDLUtility::WritePNG	(	SDL_Renderer *	renderer,
		SDL_Rect *	rect,
		const std::string	fname
	)

Definition at line 302 of file SDLUtility.cpp.

{
 
 
    
    //SDL_GetRendererOutputSize(renderer,rect->w,rect->h);
    SDL_Surface *sshot = SDL_CreateRGBSurface(0, rect->w,rect->h, 32, 0x00ff0000, 0x0000ff00, 0x000000ff, 0xff000000);
    SDL_RenderReadPixels(renderer, rect, SDL_PIXELFORMAT_ARGB8888, sshot->pixels, sshot->pitch);
    //SDL_SaveBMP(sshot, fname.c_str());
    //This is a secrit undocumented function in sdl_image
    int result =IMG_SavePNG(sshot, fname.c_str());
    SDL_FreeSurface(sshot);
    
    //returns 0 on success!
    return result;
 
}

Referenced by PlatformWindow::SaveScreenShot().