Can now partially blit surfaces onto the destination.

itzpr3d4t0r · itzpr3d4t0r · commit 24c8d30d063d · 2024-05-08T16:12:07.000+02:00
diff --git a/src_c/alphablit.c b/src_c/alphablit.c
@@ -64,11 +64,11 @@ SoftBlitPyGame(SDL_Surface *src, SDL_Rect *srcrect, SDL_Surface *dst,
 
 int
 SoftCachedBlitPyGame(SDL_Surface *src, SDL_Surface *dst, int blend_flags,
-                     Uint32 ***destinations, Py_ssize_t destinations_size);
+                     BlitSequence *destinations);
 
 void
-pg_cached_blitcopy(SDL_Surface *src, SDL_Surface *dst, Uint32 **destinations,
-                   Py_ssize_t destinations_size);
+pg_cached_blitcopy(SDL_Surface *src, SDL_Surface *dst,
+                   BlitSequence *destinations);
 
 extern int
 SDL_RLESurface(SDL_Surface *surface);
@@ -590,25 +590,31 @@ SoftBlitPyGame(SDL_Surface *src, SDL_Rect *srcrect, SDL_Surface *dst,
 }
 
 void
-pg_cached_blitcopy(SDL_Surface *src, SDL_Surface *dst, Uint32 **destinations,
-                   Py_ssize_t destinations_size)
+pg_cached_blitcopy(SDL_Surface *src, SDL_Surface *dst,
+                   BlitSequence *destinations)
 {
-    Py_ssize_t i, y;
-    for (i = 0; i < destinations_size; i++) {
-        Uint32 *dstp32 = destinations[i];
-        Uint32 *srcp32 = (Uint32 *)src->pixels;
-        y = src->h;
-        while (y--) {
-            memcpy(dstp32, srcp32, src->pitch);
-            srcp32 += src->w;
-            dstp32 += dst->w;
+    Py_ssize_t i;
+    for (i = 0; i < destinations->size; i++) {
+        CachedBlitDest *item = &destinations->sequence[i];
+
+        const Py_ssize_t src_pitch = item->w * sizeof(Uint32);
+        const Py_ssize_t src_skip = src->pitch / 4;
+        const Py_ssize_t dst_skip = dst->pitch / 4;
+
+        Uint32 *srcp32 = (Uint32 *)src->pixels + item->x + item->y * src_skip;
+        Uint32 *dstp32 = item->pixels;
+
+        while (item->h--) {
+            memcpy(dstp32, srcp32, src_pitch);
+            srcp32 += src_skip;
+            dstp32 += dst_skip;
         }
     }
 }
 
 int
 SoftCachedBlitPyGame(SDL_Surface *src, SDL_Surface *dst, int blend_flags,
-                     Uint32 ***destinations, Py_ssize_t destinations_size)
+                     BlitSequence *destinations)
 {
     int okay;
     int src_locked;
@@ -648,7 +654,7 @@ SoftCachedBlitPyGame(SDL_Surface *src, SDL_Surface *dst, int blend_flags,
                 }
 
                 /* blitcopy */
-                pg_cached_blitcopy(src, dst, *destinations, destinations_size);
+                pg_cached_blitcopy(src, dst, destinations);
                 break;
             default:
                 okay = 0;
diff --git a/src_c/surface.c b/src_c/surface.c
@@ -2210,8 +2210,7 @@ _surf_fblits_item_check_and_blit(pgSurfaceObject *self, PyObject *item,
 int
 _surf_fblits_cached_item_check_and_blit(pgSurfaceObject *self, PyObject *item,
                                         int blend_flags,
-                                        Uint32 ***destinations,
-                                        Py_ssize_t *allocated_size)
+                                        BlitSequence *destinations)
 {
     PyObject *src_surf, *pos_list;
     SDL_Surface *src, *dst = pgSurface_AsSurface(self);
@@ -2258,26 +2257,34 @@ _surf_fblits_cached_item_check_and_blit(pgSurfaceObject *self, PyObject *item,
 
     /* manage destinations memory allocation or reallocation */
     Py_ssize_t new_size = PyList_GET_SIZE(pos_list);
-    if (!*destinations) {
-        *destinations = (Uint32 **)malloc(new_size * sizeof(Uint32 *));
-        if (!*destinations) {
+    if (destinations->sequence == NULL) {
+        destinations->sequence =
+            (CachedBlitDest *)malloc(new_size * sizeof(CachedBlitDest));
+        destinations->size = destinations->alloc_size = new_size;
+        if (!destinations->sequence) {
             return FBLITS_ERR_NO_MEMORY;
         }
     }
-    else {
-        if (new_size > *allocated_size) {
-            *destinations =
-                (Uint32 **)realloc(*destinations, new_size * sizeof(Uint32 *));
+    else if (new_size > 0 && new_size <= destinations->alloc_size) {
+        destinations->size = new_size;
+    }
+    else if (new_size > destinations->alloc_size) {
+        destinations->sequence = (CachedBlitDest *)realloc(
+            destinations->sequence, new_size * sizeof(CachedBlitDest));
 
-            if (!*destinations)
-                return FBLITS_ERR_NO_MEMORY;
-        }
+        if (!destinations->sequence)
+            return FBLITS_ERR_NO_MEMORY;
+
+        destinations->size = destinations->alloc_size = new_size;
+    }
+    else {
+        return FBLITS_ERR_INCORRECT_ARGS_NUM;
     }
-    *allocated_size = new_size;
 
     /* load destinations */
     PyObject **list_items = PySequence_Fast_ITEMS(pos_list);
-    for (i = 0; i < *allocated_size; i++) {
+    Py_ssize_t current_size = 0;
+    for (i = 0; i < destinations->size; i++) {
         int x, y;
         PyObject *tup = list_items[i];
 
@@ -2290,13 +2297,36 @@ _surf_fblits_cached_item_check_and_blit(pgSurfaceObject *self, PyObject *item,
             return FBLITS_ERR_INCORRECT_ARGS_NUM;
         }
 
-        if (x < 0 || x > dst->w - src->w || y < 0 || y > dst->h - src->h) {
-            return BLITS_ERR_INVALID_DESTINATION;
+        if (x < -src->w || x > dst->w || y < -src->h || y > dst->h)
+            continue; /* Skip out of bounds destinations */
+
+        CachedBlitDest *blit_struct = &destinations->sequence[current_size++];
+        blit_struct->pixels = (Uint32 *)dst->pixels;
+
+        if (x < 0) {
+            blit_struct->w = src->w + x;
+            blit_struct->x = -x;
+        }
+        else {
+            blit_struct->pixels += x;
+            blit_struct->w = x > dst->w - src->w ? dst->w - x : src->w;
+            blit_struct->x = 0;
         }
 
-        (*destinations)[i] = (Uint32 *)dst->pixels + y * dst->pitch / 4 + x;
+        if (y < 0) {
+            blit_struct->h = src->h + y;
+            blit_struct->y = -y;
+        }
+        else {
+            blit_struct->pixels += y * dst->pitch / 4;
+            blit_struct->h = y > dst->h - src->h ? dst->h - y : src->h;
+            blit_struct->y = 0;
+        }
     }
 
+    if (!(destinations->size = current_size))
+        return 0;
+
     if (self->subsurface) {
         PyObject *owner;
         struct pgSubSurface_Data *subdata;
@@ -2326,10 +2356,10 @@ _surf_fblits_cached_item_check_and_blit(pgSurfaceObject *self, PyObject *item,
         pgSurface_Prep(self);
         subsurface = NULL;
     }
+
     pgSurface_Prep((pgSurfaceObject *)src_surf);
 
-    error = SoftCachedBlitPyGame(src, dst, blend_flags, destinations,
-                                 *allocated_size);
+    error = SoftCachedBlitPyGame(src, dst, blend_flags, destinations);
 
     if (subsurface)
         SDL_SetClipRect(subsurface, &orig_clip);
@@ -2351,8 +2381,7 @@ surf_fblits(pgSurfaceObject *self, PyObject *const *args, Py_ssize_t nargs)
     int error = 0;
     int is_generator = 0;
     int cache = 0;
-    Uint32 **destinations = NULL;
-    Py_ssize_t destinations_size = 0;
+    BlitSequence destinations = {NULL, 0, 0};
 
     if (nargs == 0 || nargs > 3) {
         error = FBLITS_ERR_INCORRECT_ARGS_NUM;
@@ -2391,8 +2420,7 @@ surf_fblits(pgSurfaceObject *self, PyObject *const *args, Py_ssize_t nargs)
             item = sequence_items[i];
             if (cache) {
                 error = _surf_fblits_cached_item_check_and_blit(
-                    self, item, blend_flags, &destinations,
-                    &destinations_size);
+                    self, item, blend_flags, &destinations);
             }
             else {
                 error =
@@ -2408,8 +2436,7 @@ surf_fblits(pgSurfaceObject *self, PyObject *const *args, Py_ssize_t nargs)
         while ((item = PyIter_Next(blit_sequence))) {
             if (cache) {
                 error = _surf_fblits_cached_item_check_and_blit(
-                    self, item, blend_flags, &destinations,
-                    &destinations_size);
+                    self, item, blend_flags, &destinations);
             }
             else {
                 error =
@@ -2431,15 +2458,15 @@ surf_fblits(pgSurfaceObject *self, PyObject *const *args, Py_ssize_t nargs)
         goto on_error;
     }
 
-    free(destinations);
+    free(destinations.sequence);
 
     Py_RETURN_NONE;
 
 on_error:
     if (is_generator) {
         Py_XDECREF(item);
     }
-    free(destinations);
+    free(destinations.sequence);
     switch (error) {
         case BLITS_ERR_SEQUENCE_REQUIRED:
             return RAISE(
diff --git a/src_c/surface.h b/src_c/surface.h
@@ -337,6 +337,17 @@
     } while (0)
 #endif
 
+typedef struct {
+    Uint32 *pixels;
+    int w, h, x, y;
+} CachedBlitDest;
+
+typedef struct {
+    CachedBlitDest *sequence;
+    Py_ssize_t alloc_size;
+    Py_ssize_t size;
+} BlitSequence;
+
 int
 surface_fill_blend(SDL_Surface *surface, SDL_Rect *rect, Uint32 color,
                    int blendargs);
@@ -354,11 +365,11 @@ pygame_Blit(SDL_Surface *src, SDL_Rect *srcrect, SDL_Surface *dst,
 
 int
 SoftCachedBlitPyGame(SDL_Surface *src, SDL_Surface *dst, int blend_flags,
-                     Uint32 ***destinations, Py_ssize_t destinations_size);
+                     BlitSequence *destinations);
 
 void
-pg_cached_blitcopy(SDL_Surface *src, SDL_Surface *dst, Uint32 **destinations,
-                   Py_ssize_t destinations_size);
+pg_cached_blitcopy(SDL_Surface *src, SDL_Surface *dst,
+                   BlitSequence *destinations);
 
 int
 premul_surf_color_by_alpha(SDL_Surface *src, SDL_Surface *dst);
