demos/bogoman/bogoman_render.c

   1 /*****************************************************************************
   2  * This file is part of gfxprim library.                                     *
   3  *                                                                           *
   4  * Gfxprim is free software; you can redistribute it and/or                  *
   5  * modify it under the terms of the GNU Lesser General Public                *
   6  * License as published by the Free Software Foundation; either              *
   7  * version 2.1 of the License, or (at your option) any later version.        *
   8  *                                                                           *
   9  * Gfxprim is distributed in the hope that it will be useful,                *
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of            *
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU         *
  12  * Lesser General Public License for more details.                           *
  13  *                                                                           *
  14  * You should have received a copy of the GNU Lesser General Public          *
  15  * License along with gfxprim; if not, write to the Free Software            *
  16  * Foundation, Inc., 51 Franklin Street, Fifth Floor,                        *
  17  * Boston, MA  02110-1301  USA                                               *
  18  *                                                                           *
  19  * Copyright (C) 2009-2015 Cyril Hrubis <metan@ucw.cz>                       *
  20  *                                                                           *
  21  *****************************************************************************/
  22
  23 #include <GP.h>
  24
  25 #include "bogoman_map.h"
  26 #include "bogoman_debug.h"
  27
  28 #include "bogoman_render.h"
  29
  30 struct render_colors {
  31         /* global background */
  32         GP_Pixel bg;
  33
  34         /* player color */
  35         GP_Pixel player;
  36
  37         /* frames around things */
  38         GP_Pixel frames;
  39
  40         /* diamod color */
  41         GP_Pixel diamond;
  42
  43         /* wall color */
  44         GP_Pixel wall;
  45
  46         /* moveable color */
  47         GP_Pixel moveable;
  48
  49         /* edible color */
  50         GP_Pixel edible;
  51
  52         /* particle colors */
  53         GP_Pixel particle;
  54         GP_Pixel particle_dir;
  55 };
  56
  57 static struct render_colors colors;
  58
  59 static void init_colors(GP_Pixmap *pixmap, struct render_colors *colors)
  60 {
  61         colors->bg           = GP_RGBToPixmapPixel(0xee, 0xee, 0xee, pixmap);
  62         colors->player       = GP_RGBToPixmapPixel(0x00, 0xee, 0x00, pixmap);
  63         colors->frames       = GP_RGBToPixmapPixel(0x00, 0x00, 0x00, pixmap);
  64         colors->diamond      = GP_RGBToPixmapPixel(0x00, 0x00, 0xee, pixmap);
  65         colors->wall         = GP_RGBToPixmapPixel(0x66, 0x66, 0x66, pixmap);
  66         colors->moveable     = GP_RGBToPixmapPixel(0xff, 0xff, 0x60, pixmap);
  67         colors->edible       = GP_RGBToPixmapPixel(0xff, 0x7f, 0x50, pixmap);
  68         colors->particle     = GP_RGBToPixmapPixel(0xff, 0xff, 0x00, pixmap);
  69         colors->particle_dir = GP_RGBToPixmapPixel(0xff, 0x44, 0x00, pixmap);
  70 }
  71
  72 static void render_none(struct bogoman_render *render,
  73                         unsigned int x, unsigned int y,
  74                         struct bogoman_map_elem *elem)
  75 {
  76         unsigned int w = render->map_elem_size;
  77
  78         (void) elem;
  79
  80         GP_FillRectXYWH(render->pixmap, x, y, w, w, colors.bg);
  81 }
  82
  83 static void render_player(struct bogoman_render *render,
  84                           unsigned int x, unsigned int y,
  85                           struct bogoman_map_elem *elem)
  86 {
  87         unsigned int w = render->map_elem_size;
  88
  89         (void) elem;
  90
  91         GP_FillRectXYWH(render->pixmap, x, y, w, w, colors.bg);
  92
  93         GP_FillCircle(render->pixmap, x + w/2, y + w/2, w/2 - 1, colors.player);
  94         GP_FillRing(render->pixmap, x + w/2, y + w/2, w/2 - 1, w/2 - 2, colors.frames);
  95 }
  96
  97 static void render_wall(struct bogoman_render *render,
  98                         unsigned int x, unsigned int y,
  99                         struct bogoman_map_elem *elem)
 100 {
 101         unsigned int w = render->map_elem_size;
 102
 103         GP_FillRectXYWH(render->pixmap, x, y, w, w, colors.wall);
 104
 105         if (!(elem->flags & BOGOMAN_LEFT)) {
 106                 GP_VLineXYH(render->pixmap, x, y, w, colors.frames);
 107                 GP_VLineXYH(render->pixmap, x+1, y, w, colors.frames);
 108         }
 109
 110         if (!(elem->flags & BOGOMAN_RIGHT)) {
 111                 GP_VLineXYH(render->pixmap, x + w - 1, y, w, colors.frames);
 112                 GP_VLineXYH(render->pixmap, x + w - 2, y, w, colors.frames);
 113         }
 114
 115         if (!(elem->flags & BOGOMAN_UP)) {
 116                 GP_HLineXYW(render->pixmap, x, y, w, colors.frames);
 117                 GP_HLineXYW(render->pixmap, x, y+1, w, colors.frames);
 118         }
 119
 120         if (!(elem->flags & BOGOMAN_DOWN)) {
 121                 GP_HLineXYW(render->pixmap, x, y + w - 1, w, colors.frames);
 122                 GP_HLineXYW(render->pixmap, x, y + w - 2, w, colors.frames);
 123         }
 124 }
 125
 126 static void render_diamond(struct bogoman_render *render,
 127                            unsigned int x, unsigned int y,
 128                            struct bogoman_map_elem *elem)
 129 {
 130         unsigned int w = render->map_elem_size;
 131
 132         GP_FillRectXYWH(render->pixmap, x, y, w, w, colors.bg);
 133
 134         (void) elem;
 135
 136         GP_FillTetragon(render->pixmap, x + w/2, y, x + w - 1, y + w/2,
 137                         x + w/2, y + w - 1, x, y + w/2, colors.diamond);
 138
 139         GP_Tetragon(render->pixmap, x + w/2, y, x + w - 1, y + w/2,
 140                     x + w/2, y + w - 1, x, y + w/2, colors.frames);
 141         GP_Tetragon(render->pixmap, x + w/2, y+1, x + w - 2, y + w/2,
 142                     x + w/2, y + w - 2, x+1, y + w/2, colors.frames);
 143 }
 144
 145 static void render_moveable(struct bogoman_render *render,
 146                             unsigned int x, unsigned int y,
 147                             struct bogoman_map_elem *elem)
 148 {
 149         unsigned int w = render->map_elem_size;
 150
 151         (void) elem;
 152
 153         GP_FillRectXYWH(render->pixmap, x, y, w, w, colors.bg);
 154
 155         GP_FillRectXYWH(render->pixmap, x + 1, y + 1, w - 2, w - 2, colors.moveable);
 156         GP_RectXYWH(render->pixmap, x + 1, y + 1, w - 2, w - 2, colors.frames);
 157         GP_RectXYWH(render->pixmap, x + 2, y + 2, w - 4, w - 4, colors.frames);
 158 }
 159
 160 static void render_edible(struct bogoman_render *render,
 161                           unsigned int x, unsigned int y,
 162                           struct bogoman_map_elem *elem)
 163 {
 164         unsigned int w = render->map_elem_size;
 165
 166         (void) elem;
 167
 168         GP_FillRectXYWH(render->pixmap, x, y, w, w, colors.bg);
 169
 170         GP_FillRectXYWH(render->pixmap, x + 1, y + 1, w - 2, w - 2, colors.edible);
 171 }
 172
 173 static void render_particle(struct bogoman_render *render,
 174                             unsigned int x, unsigned int y,
 175                             struct bogoman_map_elem *elem)
 176 {
 177         unsigned int w = render->map_elem_size;
 178         int dir = elem->flags & BOGOMAN_DIRECTION_MASK;
 179
 180         GP_FillRectXYWH(render->pixmap, x, y, w, w, colors.bg);
 181
 182         switch (elem->flags & ~BOGOMAN_DIRECTION_MASK) {
 183         case BOGOMAN_PARTICLE_ROUND:
 184                 GP_FillCircle(render->pixmap, x + w/2, y + w/2, w/2-1, colors.particle);
 185                 GP_FillRing(render->pixmap, x + w/2, y + w/2, w/2 - 1, w/2 - 2, colors.frames);
 186         break;
 187         case BOGOMAN_PARTICLE_SQUARE:
 188                 GP_FillRectXYWH(render->pixmap, x+1, y+1, w-2, w-2, colors.particle);
 189                 GP_RectXYWH(render->pixmap, x+1, y+1, w-2, w-2, colors.frames);
 190                 GP_RectXYWH(render->pixmap, x+2, y+2, w-4, w-4, colors.frames);
 191         break;
 192         }
 193
 194         switch (dir) {
 195         case BOGOMAN_LEFT:
 196                 GP_FillTriangle(render->pixmap, x + w/4, y + w/2,
 197                                 x + 5*w/8, y + w/4, x + 5*w/8, y + 3*w/4, colors.particle_dir);
 198                 GP_Triangle(render->pixmap, x + w/4, y + w/2,
 199                             x + 5*w/8, y + w/4, x + 5*w/8, y + 3*w/4, colors.frames);
 200         break;
 201         case BOGOMAN_RIGHT:
 202                 GP_FillTriangle(render->pixmap, x + 3*w/4, y + w/2,
 203                                 x + 3*w/8, y + w/4, x + 3*w/8, y + 3*w/4, colors.particle_dir);
 204                 GP_Triangle(render->pixmap, x + 3*w/4, y + w/2,
 205                             x + 3*w/8, y + w/4, x + 3*w/8, y + 3*w/4, colors.frames);
 206         break;
 207         case BOGOMAN_UP:
 208                 GP_FillTriangle(render->pixmap, x + w/2, y + w/4,
 209                                 x + w/4, y + 5*w/8, x + 3*w/4, y + 5*w/8, colors.particle_dir);
 210                 GP_Triangle(render->pixmap, x + w/2, y + w/4,
 211                             x + w/4, y + 5*w/8, x + 3*w/4, y + 5*w/8, colors.frames);
 212         break;
 213         case BOGOMAN_DOWN:
 214                 GP_FillTriangle(render->pixmap, x + w/2, y + 3*w/4,
 215                                 x + w/4, y + 3*w/8, x + 3*w/4, y + 3*w/8, colors.particle_dir);
 216                 GP_Triangle(render->pixmap, x + w/2, y + 3*w/4,
 217                             x + w/4, y + 3*w/8, x + 3*w/4, y + 3*w/8, colors.frames);
 218         break;
 219         }
 220 }
 221
 222 static void (*renders[])(struct bogoman_render *render,
 223                        unsigned int x, unsigned int y,
 224                        struct bogoman_map_elem *elem) =
 225 {
 226         render_none,
 227         render_player,
 228         render_wall,
 229         render_diamond,
 230         render_moveable,
 231         render_edible,
 232         render_particle,
 233 };
 234
 235 static void render_elem(struct bogoman_render *render,
 236                         unsigned int x, unsigned int y,
 237                         int flags)
 238 {
 239         struct bogoman_map_elem *elem;
 240         unsigned int cx, cy;
 241
 242         elem = bogoman_get_map_elem(render->map, x, y);
 243
 244         if (elem->dirty) {
 245                 elem->dirty = 0;
 246         } else {
 247                 if (flags & BOGOMAN_RENDER_DIRTY)
 248                         return;
 249         }
 250
 251         cx = (x - render->map_x_offset) * render->map_elem_size;
 252         cy = (y - render->map_y_offset) * render->map_elem_size;
 253
 254         if (elem->id > BOGOMAN_MAX)
 255                 WARN("Invalid elem ID %u at %ux%u\n", elem->id, x, y);
 256         else
 257                 renders[elem->id](render, cx, cy, elem);
 258
 259         if (flags & BOGOMAN_RENDER_DIRTY && render->backend) {
 260                 GP_BackendUpdateRect(render->backend, cx, cy,
 261                                      cx + render->map_elem_size,
 262                                      cy + render->map_elem_size);
 263         }
 264 }
 265
 266 void bogoman_render(struct bogoman_render *render, int flags)
 267 {
 268         unsigned int x, y;
 269
 270         //TODO: Hack
 271         init_colors(render->pixmap, &colors);
 272
 273         if (flags & BOGOMAN_RENDER_ALL)
 274                 GP_Fill(render->pixmap, colors.bg);
 275
 276         for (y = render->map_x_offset; y < render->map->h; y++) {
 277                 for (x = render->map_x_offset; x < render->map->w; x++)
 278                         render_elem(render, x, y, flags);
 279         }
 280
 281         if (flags & BOGOMAN_RENDER_ALL && render->backend)
 282                 GP_BackendFlip(render->backend);
 283 }