SDL: use texture to improve performance

Author: chrisws

src/common/var.c

@@ -366,12 +366,13 @@ void v_add(var_t *result, var_t *a, var_t *b) {
   char tmpsb[64];
 
   if (a->type == V_STR && b->type == V_STR) {
+    int length = strlen(a->v.p.ptr) + strlen(b->v.p.ptr);
     result->type = V_STR;
-    result->v.p.ptr = malloc(strlen(a->v.p.ptr) +
-                                        strlen(b->v.p.ptr) + 1);
+    result->v.p.ptr = malloc(length + 1);
     strcpy(result->v.p.ptr, a->v.p.ptr);
     strcat(result->v.p.ptr, b->v.p.ptr);
-    result->v.p.size = strlen(result->v.p.ptr) + 1;
+    result->v.p.ptr[length] = '\0';
+    result->v.p.size = length + 1;
     return;
   } else if (a->type == V_INT && b->type == V_INT) {
     result->type = V_INT;

src/platform/android/jni/display.cpp

@@ -47,15 +47,14 @@ bool Canvas::create(int w, int h) {
   return result;
 }
 
-void Canvas::copy(Canvas *src, const MAPoint2d *dstPoint, const MARect *srcRect) {
-  int destY = dstPoint->y;
+void Canvas::copy(Canvas *src, const MARect *srcRect, int destX, int destY) {
   int srcH = srcRect->height;
   if (srcRect->top + srcRect->height > src->_h) {
     srcH = src->_h - srcRect->top;
   }
   for (int y = 0; y < srcH && destY < _h; y++, destY++) {
     pixel_t *line = src->getLine(y + srcRect->top) + srcRect->left;
-    pixel_t *dstLine = getLine(destY) + dstPoint->x;
+    pixel_t *dstLine = getLine(destY) + destX;
     memcpy(dstLine, line, srcRect->width * sizeof(pixel_t));
   }
 }

src/platform/sdl/display.cpp

@@ -13,20 +13,26 @@
 
 extern common::Graphics *graphics;
 
+#if defined(PIXELFORMAT_RGB565)
+#define PIXEL_FORMAT SDL_PIXELFORMAT_RGB565
+#else
+#define PIXEL_FORMAT SDL_PIXELFORMAT_RGB888
+#endif
+
 //
 // Canvas implementation
 //
 Canvas::Canvas() :
-  _canvas(NULL),
+  _surface(NULL),
   _clip(NULL) {
 }
 
 Canvas::~Canvas() {
-  if (_canvas != NULL) {
-    SDL_FreeSurface(_canvas);
+  if (_surface != NULL) {
+    SDL_FreeSurface(_surface);
   }
   delete _clip;
-  _canvas = NULL;
+  _surface = NULL;
   _clip = NULL;
 }
 
@@ -36,43 +42,30 @@ bool Canvas::create(int w, int h) {
   _h = h;
   int bpp;
   Uint32 rmask, gmask, bmask, amask;
-#if defined(PIXELFORMAT_RGB565)
-  Uint32 format = SDL_PIXELFORMAT_RGB565;
-#else
-  Uint32 format = SDL_PIXELFORMAT_RGB888;
-#endif
-  SDL_PixelFormatEnumToMasks(format, &bpp, &rmask, &gmask, &bmask, &amask);
-  _canvas = SDL_CreateRGBSurface(0, w, h, bpp, rmask, gmask, bmask, amask);
-  return _canvas != NULL;
-}
-
-bool Canvas::create(int w, int h, SDL_Window *window) {
-  logEntered();
-  _w = w;
-  _h = h;
-  _canvas = SDL_GetWindowSurface(window);
-  return _canvas != NULL;
+  SDL_PixelFormatEnumToMasks(PIXEL_FORMAT, &bpp, &rmask, &gmask, &bmask, &amask);
+  _surface = SDL_CreateRGBSurface(0, w, h, bpp, rmask, gmask, bmask, amask);
+  return _surface != NULL;
 }
 
-void Canvas::copy(Canvas *src, const MARect *srcRect, int dstx, int dsty) {
+void Canvas::copy(Canvas *src, const MARect *srcRect, int destX, int destY) {
   SDL_Rect srcrect;
   srcrect.x = srcRect->left;
   srcrect.y = srcRect->top;
   srcrect.w = srcRect->width;
   srcrect.h = srcRect->height;
 
   SDL_Rect dstrect;
-  dstrect.x = dstx;
-  dstrect.y = dsty;
+  dstrect.x = destX;
+  dstrect.y = destY;
   dstrect.w = _w;
   dstrect.h = _h;
 
-  SDL_BlitSurface(src->_canvas, &srcrect, _canvas, &dstrect);
+  SDL_BlitSurface(src->_surface, &srcrect, _surface, &dstrect);
 }
 
-pixel_t *Canvas::getLine(int y) { 
-  pixel_t *pixels = (pixel_t *)_canvas->pixels;
-  return pixels + (y * _w); 
+pixel_t *Canvas::getLine(int y) {
+  pixel_t *pixels = (pixel_t *)_surface->pixels;
+  return pixels + (y * _w);
 }
 
 void Canvas::setClip(int x, int y, int w, int h) {
@@ -92,21 +85,30 @@ void Canvas::setClip(int x, int y, int w, int h) {
 // Graphics implementation
 //
 Graphics::Graphics(SDL_Window *window) : common::Graphics(),
+  _renderer(NULL),
+  _texture(NULL),
   _window(window) {
 }
 
 Graphics::~Graphics() {
   logEntered();
+  SDL_DestroyTexture(_texture);
+  SDL_DestroyRenderer(_renderer);
 }
 
 bool Graphics::construct(const char *font, const char *boldFont) {
   logEntered();
 
-  SDL_GetWindowSize(_window, &_w, &_h);
   bool result = false;
-  if (loadFonts(font, boldFont)) {
+  SDL_GetWindowSize(_window, &_w, &_h);
+  _renderer = SDL_CreateRenderer(_window, -1, 0);
+  if (_renderer != NULL) {
+    _texture = SDL_CreateTexture(_renderer, PIXEL_FORMAT,
+                                 SDL_TEXTUREACCESS_STREAMING, _w, _h);
+  }
+  if (_texture != NULL && loadFonts(font, boldFont)) {
     _screen = new Canvas();
-    if (_screen && _screen->create(getWidth(), getHeight(), _window)) {
+    if (_screen && _screen->create(getWidth(), getHeight())) {
       _drawTarget = _screen;
       maSetColor(DEFAULT_BACKGROUND);
       result = true;
@@ -116,16 +118,23 @@ bool Graphics::construct(const char *font, const char *boldFont) {
 }
 
 void Graphics::redraw() {
-  SDL_UpdateWindowSurface(_window);
+  SDL_UpdateTexture(_texture, NULL, _screen->_surface->pixels, _w * sizeof (pixel_t));
+  SDL_RenderClear(_renderer);
+  SDL_RenderCopy(_renderer, _texture, NULL, NULL);
+  SDL_RenderPresent(_renderer);
 }
 
 void Graphics::resize() {
   logEntered();
   bool drawScreen = (_drawTarget == _screen);
   delete _screen;
   _screen = new ::Canvas();
-  _screen->create(getWidth(), getHeight(), _window);
+  _screen->create(getWidth(), getHeight());
   _drawTarget = drawScreen ? _screen : NULL;
+
+  SDL_DestroyTexture(_texture);
+  _texture = SDL_CreateTexture(_renderer, PIXEL_FORMAT,
+                               SDL_TEXTUREACCESS_STREAMING, _w, _h);
 }
 
 bool Graphics::loadFonts(const char *font, const char *boldFont) {

src/platform/sdl/display.h

@@ -27,6 +27,8 @@ struct Graphics : common::Graphics {
   bool loadFonts(const char *font, const char *boldFont);
   bool loadFont(const char *filename, FT_Face &face);
 
+  SDL_Renderer *_renderer;
+  SDL_Texture *_texture;
   SDL_Window *_window;
 };
 

src/ui/canvas.h

@@ -24,7 +24,6 @@ struct Canvas {
   virtual ~Canvas();
 
   bool create(int w, int h);
-  bool create(int w, int h, SDL_Window *window);
   void copy(Canvas *src, const MARect *srcRect, int dstx, int dsty);
   void setClip(int x, int y, int w, int h);
   pixel_t *getLine(int y);
@@ -35,7 +34,7 @@ struct Canvas {
 
   int _w;
   int _h;
-  SDL_Surface *_canvas;
+  SDL_Surface *_surface;
   SDL_Rect *_clip;
 };