Changeset e0545de in mainline

Timestamp:

2019-10-19T10:07:32Z (5 years ago)

Author:

Jiri Svoboda <jiri@…>

Branches:

lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export

Children:

d18f3b7

Parents:

dcc4cb31

Message:

Implement bitmaps in canvas GC, demo in gfxdemo

Location:

uspace

Files:

• app/gfxdemo/gfxdemo.c (modified) (7 diffs)
• lib/guigfx/private/canvas.h (modified) (2 diffs)
• lib/guigfx/src/canvas.c (modified) (4 diffs)

uspace/app/gfxdemo/gfxdemo.c

@@ -39 +39 @@
 #include <fibril.h>
 #include <guigfx/canvas.h>
+#include <gfx/bitmap.h>
 #include <gfx/color.h>
 #include <gfx/render.h>
 #include <io/console.h>
+#include <io/pixelmap.h>
 #include <stdlib.h>
 #include <str.h>
@@ -49 +51 @@
  *
  * @param gc Graphic context
+ * @param w Width
+ * @param h Height
  */
 static errno_t demo_rects(gfx_context_t *gc, int w, int h)
@@ -54 +58 @@
         gfx_color_t *color = NULL;
         gfx_rect_t rect;
-        int i;
-        errno_t rc;
-
-        while (true) {
+        int i, j;
+        errno_t rc;
+
+        for (j = 0; j < 10; j++) {
                 rc = gfx_color_new_rgb_i16(rand() % 0x10000, rand() % 0x10000,
                     rand() % 0x10000, &color);
@@ -82 +86 @@
                 fibril_usleep(500 * 1000);
         }
+
+        return EOK;
+}
+
+/** Run bitmap demo on a graphic context.
+ *
+ * @param gc Graphic context
+ * @param w Width
+ * @param h Height
+ */
+static errno_t demo_bitmap(gfx_context_t *gc, int w, int h)
+{
+        gfx_bitmap_t *bitmap;
+        gfx_bitmap_params_t params;
+        gfx_bitmap_alloc_t alloc;
+        int i, j;
+        gfx_coord2_t offs;
+        gfx_rect_t srect;
+        errno_t rc;
+        pixelmap_t pixelmap;
+
+        params.rect.p0.x = 0;
+        params.rect.p0.y = 0;
+        params.rect.p1.x = w;
+        params.rect.p1.y = h;
+
+        rc = gfx_bitmap_create(gc, &params, NULL, &bitmap);
+        if (rc != EOK)
+                return rc;
+
+        rc = gfx_bitmap_get_alloc(bitmap, &alloc);
+        if (rc != EOK)
+                return rc;
+
+        /* Fill bitmap with something. In absence of anything else, use pixelmap */
+        pixelmap.width = w;
+        pixelmap.height = h;
+        pixelmap.data = alloc.pixels;
+
+        for (i = 0; i < w; i++) {
+                for (j = 0; j < h; j++) {
+                        pixelmap_put_pixel(&pixelmap, i, j,
+                            PIXEL(255, (i % 30) < 3 ? 255 : 0,
+                            (j % 30) < 3 ? 255 : 0, i / 2));
+                }
+        }
+
+        for (j = 0; j < 10; j++) {
+                for (i = 0; i < 5; i++) {
+                        srect.p0.x = rand() % (w - 40);
+                        srect.p0.y = rand() % (h - 40);
+                        srect.p1.x = srect.p0.x + rand() % (w - srect.p0.x);
+                        srect.p1.y = srect.p0.y + rand() % (h - srect.p0.y);
+                        offs.x = rand() % (w - srect.p1.x);
+                        offs.y = rand() % (h - srect.p1.y);
+                        offs.x = 0;
+                        offs.y = 0;
+
+                        gfx_bitmap_render(bitmap, &srect, &offs);
+                        fibril_usleep(500 * 1000);
+                }
+        }
+
+        gfx_bitmap_destroy(bitmap);
+
+        return EOK;
+}
+
+/** Run demo loop on a graphic context.
+ *
+ * @param gc Graphic context
+ * @param w Width
+ * @param h Height
+ */
+static errno_t demo_loop(gfx_context_t *gc, int w, int h)
+{
+        errno_t rc;
+
+        while (true) {
+                rc = demo_rects(gc, w, h);
+                if (rc != EOK)
+                        return rc;
+
+                rc = demo_bitmap(gc, w, h);
+                if (rc != EOK)
+                        return rc;
+        }
 }
 
@@ -104 +195 @@
         gc = console_gc_get_ctx(cgc);
 
-        rc = demo_rects(gc, 80, 25);
+        rc = demo_loop(gc, 80, 25);
         if (rc != EOK)
                 return rc;
@@ -168 +259 @@
         gc = canvas_gc_get_ctx(cgc);
 
-        rc = demo_rects(gc, 400, 300);
+        rc = demo_loop(gc, 400, 300);
         if (rc != EOK)
                 return rc;
@@ -206 +297 @@
         }
 
-        rc = demo_rects(gc, 400, 300);
+        rc = demo_loop(gc, 400, 300);
         if (rc != EOK)
                 return rc;

uspace/lib/guigfx/private/canvas.h

@@ -40 +40 @@
 #include <canvas.h>
 #include <draw/surface.h>
+#include <gfx/bitmap.h>
 #include <gfx/context.h>
+#include <gfx/coord.h>
 #include <io/pixel.h>
 
@@ -58 +60 @@
 };
 
+/** Bitmap in canvas GC */
+typedef struct {
+        /** Containing canvas GC */
+        struct canvas_gc *cgc;
+        /** Allocation info */
+        gfx_bitmap_alloc_t alloc;
+        /** @c true if we allocated the bitmap, @c false if allocated by caller */
+        bool myalloc;
+        /** Surface */
+        surface_t *surface;
+        /** Rectangle covered by bitmap */
+        gfx_rect_t rect;
+} canvas_gc_bitmap_t;
+
 #endif
 

uspace/lib/guigfx/src/canvas.c

@@ -37 +37 @@
  */
 
+#include <draw/drawctx.h>
+#include <draw/source.h>
 #include <gfx/color.h>
 #include <gfx/context.h>
@@ -43 +45 @@
 #include <io/pixel.h>
 #include <stdlib.h>
+#include <transform.h>
 #include "../private/canvas.h"
 //#include "../../private/color.h"
@@ -48 +51 @@
 static errno_t canvas_gc_set_color(void *, gfx_color_t *);
 static errno_t canvas_gc_fill_rect(void *, gfx_rect_t *);
+static errno_t canvas_gc_bitmap_create(void *, gfx_bitmap_params_t *,
+    gfx_bitmap_alloc_t *, void **);
+static errno_t canvas_gc_bitmap_destroy(void *);
+static errno_t canvas_gc_bitmap_render(void *, gfx_rect_t *, gfx_coord2_t *);
+static errno_t canvas_gc_bitmap_get_alloc(void *, gfx_bitmap_alloc_t *);
 
 gfx_context_ops_t canvas_gc_ops = {
         .set_color = canvas_gc_set_color,
-        .fill_rect = canvas_gc_fill_rect
+        .fill_rect = canvas_gc_fill_rect,
+        .bitmap_create = canvas_gc_bitmap_create,
+        .bitmap_destroy = canvas_gc_bitmap_destroy,
+        .bitmap_render = canvas_gc_bitmap_render,
+        .bitmap_get_alloc = canvas_gc_bitmap_get_alloc
 };
 
@@ -163 +175 @@
 }
 
+/** Create bitmap in canvas GC.
+ *
+ * @param arg Canvas GC
+ * @param params Bitmap params
+ * @param alloc Bitmap allocation info or @c NULL
+ * @param rbm Place to store pointer to new bitmap
+ * @return EOK on success or an error code
+ */
+errno_t canvas_gc_bitmap_create(void *arg, gfx_bitmap_params_t *params,
+    gfx_bitmap_alloc_t *alloc, void **rbm)
+{
+        canvas_gc_t *cgc = (canvas_gc_t *) arg;
+        canvas_gc_bitmap_t *cbm = NULL;
+        int w, h;
+        errno_t rc;
+
+        cbm = calloc(1, sizeof(canvas_gc_bitmap_t));
+        if (cbm == NULL)
+                return ENOMEM;
+
+        w = params->rect.p1.x - params->rect.p0.x;
+        h = params->rect.p1.y - params->rect.p0.y;
+        cbm->rect = params->rect;
+
+        if (alloc == NULL) {
+                cbm->surface = surface_create(w, h, NULL, 0);
+                if (cbm->surface == NULL) {
+                        rc = ENOMEM;
+                        goto error;
+                }
+
+                cbm->alloc.pitch = w * sizeof(uint32_t);
+                cbm->alloc.off0 = 0;
+                cbm->alloc.pixels = surface_direct_access(cbm->surface);
+                cbm->myalloc = true;
+        } else {
+                cbm->surface = surface_create(w, h, alloc->pixels, 0);
+                if (cbm->surface == NULL) {
+                        rc = ENOMEM;
+                        goto error;
+                }
+
+                cbm->alloc = *alloc;
+        }
+
+        cbm->cgc = cgc;
+        *rbm = (void *)cbm;
+        return EOK;
+error:
+        if (cbm != NULL)
+                free(cbm);
+        return rc;
+}
+
+/** Destroy bitmap in canvas GC.
+ *
+ * @param bm Bitmap
+ * @return EOK on success or an error code
+ */
+static errno_t canvas_gc_bitmap_destroy(void *bm)
+{
+        canvas_gc_bitmap_t *cbm = (canvas_gc_bitmap_t *)bm;
+        if (cbm->myalloc)
+                surface_destroy(cbm->surface);
+        // XXX if !cbm->myalloc, surface is leaked - no way to destroy it
+        // without destroying the pixel buffer
+        free(cbm);
+        return EOK;
+}
+
+/** Render bitmap in canvas GC.
+ *
+ * @param bm Bitmap
+ * @param srect0 Source rectangle or @c NULL
+ * @param offs0 Offset or @c NULL
+ * @return EOK on success or an error code
+ */
+static errno_t canvas_gc_bitmap_render(void *bm, gfx_rect_t *srect0,
+    gfx_coord2_t *offs0)
+{
+        canvas_gc_bitmap_t *cbm = (canvas_gc_bitmap_t *)bm;
+        gfx_rect_t srect;
+        gfx_rect_t drect;
+        gfx_coord2_t offs;
+
+        if (srect0 != NULL)
+                srect = *srect0;
+        else
+                srect = cbm->rect;
+
+        if (offs0 != NULL) {
+                offs = *offs0;
+        } else {
+                offs.x = 0;
+                offs.y = 0;
+        }
+
+        // XXX Add function to translate rectangle
+        drect.p0.x = srect.p0.x + offs.x;
+        drect.p0.y = srect.p0.y + offs.y;
+        drect.p1.x = srect.p1.x + offs.x;
+        drect.p1.y = srect.p1.y + offs.y;
+
+        transform_t transform;
+        transform_identity(&transform);
+        transform_translate(&transform, offs.x - cbm->rect.p0.x,
+            offs.y - cbm->rect.p0.y);
+
+        source_t source;
+        source_init(&source);
+        source_set_transform(&source, transform);
+        source_set_texture(&source, cbm->surface,
+            PIXELMAP_EXTEND_TRANSPARENT_BLACK);
+
+        drawctx_t drawctx;
+        drawctx_init(&drawctx, cbm->cgc->surface);
+
+        drawctx_set_source(&drawctx, &source);
+        drawctx_transfer(&drawctx, drect.p0.x, drect.p0.y,
+            drect.p1.x - drect.p0.x, drect.p1.y - drect.p0.y);
+
+        update_canvas(cbm->cgc->canvas, cbm->cgc->surface);
+        return EOK;
+}
+
+/** Get allocation info for bitmap in canvas GC.
+ *
+ * @param bm Bitmap
+ * @param alloc Place to store allocation info
+ * @return EOK on success or an error code
+ */
+static errno_t canvas_gc_bitmap_get_alloc(void *bm, gfx_bitmap_alloc_t *alloc)
+{
+        canvas_gc_bitmap_t *cbm = (canvas_gc_bitmap_t *)bm;
+        *alloc = cbm->alloc;
+        return EOK;
+}
+
 /** @}
  */