Mercurial Mercurial > SDL / file revision
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | comparison | raw | help
src/video/qnxgf/SDL_gf_render.c
author Sam Lantinga <slouken@libsdl.org>
Sun, 12 Dec 2010 15:19:05 -0800
changeset 4929 aa8888658021
parent 3697 f7b03b6838cb
child 5138 da10636e5eca
permissions -rw-r--r--
Use the enumerated type for blend and scale mode instead of int
Renamed SDL_TextureScaleMode to SDL_ScaleMode 
     1 /*

     2     SDL - Simple DirectMedia Layer

     3     Copyright (C) 1997-2010 Sam Lantinga

     4 

     5     This library is free software; you can redistribute it and/or

     6     modify it under the terms of the GNU Lesser General Public

     7     License as published by the Free Software Foundation; either

     8     version 2.1 of the License, or (at your option) any later version.

     9 

    10     This library is distributed in the hope that it will be useful,

    11     but WITHOUT ANY WARRANTY; without even the implied warranty of

    12     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

    13     Lesser General Public License for more details.

    14 

    15     You should have received a copy of the GNU Lesser General Public

    16     License along with this library; if not, write to the Free Software

    17     Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

    18 

    19     Sam Lantinga

    20     slouken@libsdl.org

    21 

    22     QNX Graphics Framework SDL driver

    23     Copyright (C) 2009 Mike Gorchak

    24     (mike@malva.ua, lestat@i.com.ua)

    25 */

    26 

    27 #include "SDL_config.h"

    28 

    29 #include "../SDL_pixels_c.h"

    30 #include "../SDL_yuv_sw_c.h"

    31 

    32 #include "SDL_video.h"

    33 

    34 #include "SDL_gf_render.h"

    35 #include "SDL_qnxgf.h"

    36 

    37 static SDL_Renderer *gf_createrenderer(SDL_Window * window, Uint32 flags);

    38 static int gf_displaymodechanged(SDL_Renderer * renderer);

    39 static int gf_activaterenderer(SDL_Renderer * renderer);

    40 static int gf_createtexture(SDL_Renderer * renderer, SDL_Texture * texture);

    41 static int gf_querytexturepixels(SDL_Renderer * renderer,

    42                                  SDL_Texture * texture, void **pixels,

    43                                  int *pitch);

    44 static int gf_settexturepalette(SDL_Renderer * renderer,

    45                                 SDL_Texture * texture,

    46                                 const SDL_Color * colors, int firstcolor,

    47                                 int ncolors);

    48 static int gf_gettexturepalette(SDL_Renderer * renderer,

    49                                 SDL_Texture * texture, SDL_Color * colors,

    50                                 int firstcolor, int ncolors);

    51 static int gf_settexturecolormod(SDL_Renderer * renderer,

    52                                  SDL_Texture * texture);

    53 static int gf_settexturealphamod(SDL_Renderer * renderer,

    54                                  SDL_Texture * texture);

    55 static int gf_settextureblendmode(SDL_Renderer * renderer,

    56                                   SDL_Texture * texture);

    57 static int gf_settexturescalemode(SDL_Renderer * renderer,

    58                                   SDL_Texture * texture);

    59 static int gf_updatetexture(SDL_Renderer * renderer, SDL_Texture * texture,

    60                             const SDL_Rect * rect, const void *pixels,

    61                             int pitch);

    62 static int gf_locktexture(SDL_Renderer * renderer, SDL_Texture * texture,

    63                           const SDL_Rect * rect, int markDirty, void **pixels,

    64                           int *pitch);

    65 static void gf_unlocktexture(SDL_Renderer * renderer, SDL_Texture * texture);

    66 static void gf_dirtytexture(SDL_Renderer * renderer, SDL_Texture * texture,

    67                             int numrects, const SDL_Rect * rects);

    68 static int gf_renderpoint(SDL_Renderer * renderer, int x, int y);

    69 static int gf_renderline(SDL_Renderer * renderer, int x1, int y1, int x2,

    70                          int y2);

    71 static int gf_renderfill(SDL_Renderer * renderer, const SDL_Rect * rect);

    72 static int gf_rendercopy(SDL_Renderer * renderer, SDL_Texture * texture,

    73                          const SDL_Rect * srcrect, const SDL_Rect * dstrect);

    74 static void gf_renderpresent(SDL_Renderer * renderer);

    75 static void gf_destroytexture(SDL_Renderer * renderer, SDL_Texture * texture);

    76 static void gf_destroyrenderer(SDL_Renderer * renderer);

    77 

    78 SDL_RenderDriver gf_renderdriver = {

    79     gf_createrenderer,

    80     {

    81      "qnxgf",

    82      (SDL_RENDERER_SINGLEBUFFER | SDL_RENDERER_PRESENTCOPY |

    83       SDL_RENDERER_PRESENTFLIP2 | SDL_RENDERER_PRESENTFLIP3 |

    84       SDL_RENDERER_PRESENTVSYNC | SDL_RENDERER_PRESENTDISCARD |

    85       SDL_RENDERER_ACCELERATED),

    86      (SDL_TEXTUREMODULATE_NONE | SDL_TEXTUREMODULATE_COLOR |

    87       SDL_TEXTUREMODULATE_ALPHA),

    88      (SDL_BLENDMODE_NONE | SDL_BLENDMODE_MASK |

    89       SDL_BLENDMODE_BLEND | SDL_BLENDMODE_ADD | SDL_BLENDMODE_MOD),

    90      (SDL_SCALEMODE_NONE | SDL_SCALEMODE_SLOW),

    91      13,

    92      {

    93       SDL_PIXELFORMAT_INDEX8,

    94       SDL_PIXELFORMAT_RGB555,

    95       SDL_PIXELFORMAT_RGB565,

    96       SDL_PIXELFORMAT_RGB888,

    97       SDL_PIXELFORMAT_BGR888,

    98       SDL_PIXELFORMAT_ARGB8888,

    99       SDL_PIXELFORMAT_RGBA8888,

   100       SDL_PIXELFORMAT_ABGR8888,

   101       SDL_PIXELFORMAT_BGRA8888,

   102       SDL_PIXELFORMAT_YV12,

   103       SDL_PIXELFORMAT_YUY2,

   104       SDL_PIXELFORMAT_UYVY,

   105       SDL_PIXELFORMAT_YVYU},

   106      0,

   107      0}

   108 };

   109 

   110 static SDL_Renderer *

   111 gf_createrenderer(SDL_Window * window, Uint32 flags)

   112 {

   113     SDL_VideoDisplay *display = window->display;

   114     SDL_DisplayData *didata = (SDL_DisplayData *) display->driverdata;

   115     SDL_WindowData *wdata = (SDL_WindowData *) window->driverdata;

   116     SDL_Renderer *renderer = NULL;

   117     SDL_RenderData *rdata = NULL;

   118     uint32_t it;

   119     int32_t jt;

   120     int32_t status;

   121 

   122     /* Check if it is OpenGL ES window */

   123     if ((window->flags & SDL_WINDOW_OPENGL) == SDL_WINDOW_OPENGL) {

   124         /* No error, just no need to create 2D renderer for OpenGL ES window */

   125         return NULL;

   126     }

   127 

   128     /* Allocate new renderer structure */

   129     renderer = (SDL_Renderer *) SDL_calloc(1, sizeof(SDL_Renderer));

   130     if (renderer == NULL) {

   131         SDL_OutOfMemory();

   132         return NULL;

   133     }

   134 

   135     /* Allocate renderer data */

   136     rdata = (SDL_RenderData *) SDL_calloc(1, sizeof(SDL_RenderData));

   137     if (rdata == NULL) {

   138         SDL_free(renderer);

   139         SDL_OutOfMemory();

   140         return NULL;

   141     }

   142 

   143     renderer->DisplayModeChanged = gf_displaymodechanged;

   144     renderer->ActivateRenderer = gf_activaterenderer;

   145     renderer->CreateTexture = gf_createtexture;

   146     renderer->QueryTexturePixels = gf_querytexturepixels;

   147     renderer->SetTexturePalette = gf_settexturepalette;

   148     renderer->GetTexturePalette = gf_gettexturepalette;

   149     renderer->SetTextureAlphaMod = gf_settexturealphamod;

   150     renderer->SetTextureColorMod = gf_settexturecolormod;

   151     renderer->SetTextureBlendMode = gf_settextureblendmode;

   152     renderer->SetTextureScaleMode = gf_settexturescalemode;

   153     renderer->UpdateTexture = gf_updatetexture;

   154     renderer->LockTexture = gf_locktexture;

   155     renderer->UnlockTexture = gf_unlocktexture;

   156     renderer->DirtyTexture = gf_dirtytexture;

   157     renderer->RenderPoint = gf_renderpoint;

   158     renderer->RenderLine = gf_renderline;

   159     renderer->RenderFill = gf_renderfill;

   160     renderer->RenderCopy = gf_rendercopy;

   161     renderer->RenderPresent = gf_renderpresent;

   162     renderer->DestroyTexture = gf_destroytexture;

   163     renderer->DestroyRenderer = gf_destroyrenderer;

   164     renderer->info = gf_renderdriver.info;

   165     renderer->window = window;

   166     renderer->driverdata = rdata;

   167 

   168     /* Set render acceleration flag in case it is accelerated */

   169     if ((didata->caps & SDL_GF_ACCELERATED) == SDL_GF_ACCELERATED) {

   170         renderer->info.flags = SDL_RENDERER_ACCELERATED;

   171     } else {

   172         renderer->info.flags &= ~(SDL_RENDERER_ACCELERATED);

   173     }

   174 

   175     rdata->window = window;

   176 

   177     /* Check if upper level requested synchronization on vsync signal */

   178     if ((flags & SDL_RENDERER_PRESENTVSYNC) == SDL_RENDERER_PRESENTVSYNC) {

   179         rdata->enable_vsync = SDL_TRUE;

   180     } else {

   181         rdata->enable_vsync = SDL_FALSE;

   182     }

   183 

   184     /* Check what buffer copy/flip scheme is requested */

   185     rdata->surfaces_count = 0;

   186     if ((flags & SDL_RENDERER_SINGLEBUFFER) == SDL_RENDERER_SINGLEBUFFER) {

   187         if ((flags & SDL_RENDERER_PRESENTDISCARD) ==

   188             SDL_RENDERER_PRESENTDISCARD) {

   189             renderer->info.flags |=

   190                 SDL_RENDERER_SINGLEBUFFER | SDL_RENDERER_PRESENTDISCARD;

   191         } else {

   192             renderer->info.flags |=

   193                 SDL_RENDERER_SINGLEBUFFER | SDL_RENDERER_PRESENTCOPY;

   194         }

   195         rdata->surfaces_count = 1;

   196         rdata->surface_visible_idx = 0;

   197         rdata->surface_render_idx = 0;

   198     } else {

   199         if ((flags & SDL_RENDERER_PRESENTFLIP2) == SDL_RENDERER_PRESENTFLIP2) {

   200             renderer->info.flags |= SDL_RENDERER_PRESENTFLIP2;

   201             rdata->surfaces_count = 2;

   202             rdata->surface_visible_idx = 0;

   203             rdata->surface_render_idx = 1;

   204         } else {

   205             if ((flags & SDL_RENDERER_PRESENTFLIP3) ==

   206                 SDL_RENDERER_PRESENTFLIP3) {

   207                 renderer->info.flags |= SDL_RENDERER_PRESENTFLIP3;

   208                 rdata->surfaces_count = 3;

   209                 rdata->surface_visible_idx = 0;

   210                 rdata->surface_render_idx = 1;

   211             } else {

   212                 renderer->info.flags |=

   213                     SDL_RENDERER_SINGLEBUFFER | SDL_RENDERER_PRESENTCOPY;

   214                 rdata->surfaces_count = 1;

   215                 rdata->surface_visible_idx = 0;

   216                 rdata->surface_render_idx = 0;

   217             }

   218         }

   219     }

   220 

   221     /* Create layer surfaces, which could be visible */

   222     for (it = 0; it < rdata->surfaces_count; it++) {

   223         /* TODO: add palette creation */

   224 

   225         /* Create displayable surfaces */

   226         status =

   227             gf_surface_create_layer(&rdata->surface[it], &didata->layer, 1, 0,

   228                                     didata->current_mode.w,

   229                                     didata->current_mode.h,

   230                                     qnxgf_sdl_to_gf_pixelformat(didata->

   231                                                                 current_mode.

   232                                                                 format), NULL,

   233                                     GF_SURFACE_CREATE_2D_ACCESSIBLE);

   234 

   235         if (status != GF_ERR_OK) {

   236             /* Free already allocated surfaces */

   237             for (jt = it - 1; jt > 0; jt--) {

   238                 gf_surface_free(rdata->surface[jt]);

   239                 rdata->surface[jt] = NULL;

   240             }

   241             SDL_free(rdata);

   242             SDL_free(renderer);

   243             if (status == GF_ERR_MEM) {

   244                 SDL_SetError("unsufficient free video memory");

   245             } else {

   246                 SDL_SetError("error during displayable surface creation");

   247             }

   248             return NULL;

   249         }

   250 

   251         /* Get detailed information about allocated surface */

   252         gf_surface_get_info(rdata->surface[it], &rdata->surface_info[it]);

   253     }

   254 

   255     return renderer;

   256 }

   257 

   258 void

   259 gf_addrenderdriver(_THIS)

   260 {

   261     uint32_t it;

   262 

   263     for (it = 0; it < _this->num_displays; it++) {

   264         SDL_AddRenderDriver(&_this->displays[it], &gf_renderdriver);

   265     }

   266 }

   267 

   268 /****************************************************************************/

   269 /* SDL render interface                                                     */

   270 /****************************************************************************/

   271 static int

   272 gf_displaymodechanged(SDL_Renderer * renderer)

   273 {

   274     SDL_RenderData *rdata = (SDL_RenderData *) renderer->driverdata;

   275 

   276     /* Remove all allocated surfaces, they are no more valid */

   277 

   278     /* TODO: Add video mode change detection and new parameters detection */

   279 

   280     return 0;

   281 }

   282 

   283 static int

   284 gf_activaterenderer(SDL_Renderer * renderer)

   285 {

   286     SDL_RenderData *rdata = (SDL_RenderData *) renderer->driverdata;

   287     SDL_VideoDisplay *display = rdata->window->display;

   288     SDL_DisplayData *didata = (SDL_DisplayData *) display->driverdata;

   289 

   290     /* Setup current surface as visible */

   291 //   gf_layer_set_surfaces(didata->layer, &rdata->surface[rdata->surface_visible_idx], 1);

   292 

   293     /* Set visible surface when hardware in idle state */

   294 //   gf_layer_update(didata->layer, GF_LAYER_UPDATE_NO_WAIT_IDLE);

   295 

   296     return 0;

   297 }

   298 

   299 static int

   300 gf_createtexture(SDL_Renderer * renderer, SDL_Texture * texture)

   301 {

   302     SDL_RenderData *renderdata = (SDL_RenderData *) renderer->driverdata;

   303     SDL_Window *window = SDL_GetWindowFromID(renderer->window);

   304     SDL_VideoDisplay *display = window->display;

   305     SDL_TextureData *tdata = NULL;

   306 

   307     /* Allocate texture driver data */

   308     tdata = (SDL_TextureData *) SDL_calloc(1, sizeof(SDL_TextureData));

   309     if (tdata == NULL) {

   310         SDL_OutOfMemory();

   311         return -1;

   312     }

   313 

   314     /* Set texture driver data */

   315     texture->driverdata = tdata;

   316 

   317 }

   318 

   319 static int

   320 gf_querytexturepixels(SDL_Renderer * renderer, SDL_Texture * texture,

   321                       void **pixels, int *pitch)

   322 {

   323 }

   324 

   325 static int

   326 gf_settexturepalette(SDL_Renderer * renderer, SDL_Texture * texture,

   327                      const SDL_Color * colors, int firstcolor, int ncolors)

   328 {

   329 }

   330 

   331 static int

   332 gf_gettexturepalette(SDL_Renderer * renderer, SDL_Texture * texture,

   333                      SDL_Color * colors, int firstcolor, int ncolors)

   334 {

   335 }

   336 

   337 static int

   338 gf_settexturecolormod(SDL_Renderer * renderer, SDL_Texture * texture)

   339 {

   340 }

   341 

   342 static int

   343 gf_settexturealphamod(SDL_Renderer * renderer, SDL_Texture * texture)

   344 {

   345 }

   346 

   347 static int

   348 gf_settextureblendmode(SDL_Renderer * renderer, SDL_Texture * texture)

   349 {

   350 }

   351 

   352 static int

   353 gf_settexturescalemode(SDL_Renderer * renderer, SDL_Texture * texture)

   354 {

   355 }

   356 

   357 static int

   358 gf_updatetexture(SDL_Renderer * renderer, SDL_Texture * texture,

   359                  const SDL_Rect * rect, const void *pixels, int pitch)

   360 {

   361 }

   362 

   363 static int

   364 gf_locktexture(SDL_Renderer * renderer, SDL_Texture * texture,

   365                const SDL_Rect * rect, int markDirty, void **pixels,

   366                int *pitch)

   367 {

   368 }

   369 

   370 static void

   371 gf_unlocktexture(SDL_Renderer * renderer, SDL_Texture * texture)

   372 {

   373 }

   374 

   375 static void

   376 gf_dirtytexture(SDL_Renderer * renderer, SDL_Texture * texture, int numrects,

   377                 const SDL_Rect * rects)

   378 {

   379 }

   380 

   381 static int

   382 gf_renderpoint(SDL_Renderer * renderer, int x, int y)

   383 {

   384 }

   385 

   386 static int

   387 gf_renderline(SDL_Renderer * renderer, int x1, int y1, int x2, int y2)

   388 {

   389 }

   390 

   391 static int

   392 gf_renderfill(SDL_Renderer * renderer, const SDL_Rect * rect)

   393 {

   394 }

   395 

   396 static int

   397 gf_rendercopy(SDL_Renderer * renderer, SDL_Texture * texture,

   398               const SDL_Rect * srcrect, const SDL_Rect * dstrect)

   399 {

   400 }

   401 

   402 static void

   403 gf_renderpresent(SDL_Renderer * renderer)

   404 {

   405 }

   406 

   407 static void

   408 gf_destroytexture(SDL_Renderer * renderer, SDL_Texture * texture)

   409 {

   410 }

   411 

   412 static void

   413 gf_destroyrenderer(SDL_Renderer * renderer)

   414 {

   415     SDL_RenderData *rdata = (SDL_RenderData *) renderer->driverdata;

   416     uint32_t it;

   417 

   418     for (it = 0; it < rdata->surfaces_count; it++) {

   419         if (rdata->surface[it] != NULL) {

   420             gf_surface_free(rdata->surface[it]);

   421         }

   422     }

   423 }

   424 

   425 /* vi: set ts=4 sw=4 expandtab: */
SDL