src/lib/16_sprit.c

   1 /* Project 16 Source Code~\r
   2  * Copyright (C) 2012-2016 sparky4 & pngwen & andrius4669 & joncampbell123 & yakui-lover\r
   3  *\r
   4  * This file is part of Project 16.\r
   5  *\r
   6  * Project 16 is free software; you can redistribute it and/or modify\r
   7  * it under the terms of the GNU General Public License as published by\r
   8  * the Free Software Foundation; either version 3 of the License, or\r
   9  * (at your option) any later version.\r
  10  *\r
  11  * Project 16 is distributed in the hope that it will be useful,\r
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of\r
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\r
  14  * GNU General Public License for more details.\r
  15  *\r
  16  * You should have received a copy of the GNU General Public License\r
  17  * along with this program.  If not, see <http://www.gnu.org/licenses/>, or\r
  18  * write to the Free Software Foundation, Inc., 51 Franklin Street,\r
  19  * Fifth Floor, Boston, MA 02110-1301 USA.\r
  20  *\r
  21  */\r
  22 \r
  23 #include "src/lib/16_sprit.h"\r
  24 \r
  25 char* get_curr_anim_name(struct sprite *spri)\r
  26 {\r
  27         // Retrive animation name list\r
  28         struct vrs_header far *vrs = spri->spritesheet->vrs_hdr;\r
  29         uint32_t far *anim_names_offsets =      (uint32_t far *)\r
  30                                                 ((byte far *)vrs +\r
  31                                                  vrs->offset_table[VRS_HEADER_OFFSET_ANIMATION_NAME_LIST]);\r
  32 \r
  33         return (char *)(vrs + anim_names_offsets[spri->curr_anim]);\r
  34 }\r
  35 \r
  36 void init_anim(struct sprite *spri, int anim_index)\r
  37 {\r
  38         struct vrs_header far *vrs = spri->spritesheet->vrs_hdr;\r
  39         uint32_t far *anim_lists_offsets =      (uint32_t far *)\r
  40                                                 ((byte far *)vrs +\r
  41                                                  vrs->offset_table[VRS_HEADER_OFFSET_ANIMATION_LIST]);\r
  42         struct vrs_animation_list_entry_t far *anim_list =      (struct vrs_animation_list_entry_t far *)\r
  43                                                                 ((byte far *)vrs +\r
  44                                                                  anim_lists_offsets[anim_index]);\r
  45 \r
  46         // Upon new animation, start from the first sprite in it\r
  47         spri->curr_anim = anim_index;\r
  48         spri->curr_anim_spri = 0;\r
  49         spri->curr_spri_id = anim_list[0].sprite_id;\r
  50         spri->delay = anim_list[0].delay;\r
  51 \r
  52         spri->curr_anim_list = anim_list;\r
  53 }\r
  54 \r
  55 int set_anim_by_id(struct sprite *spri, int anim_id)\r
  56 {\r
  57         int new_anim_index = 0;\r
  58         int iter_id;\r
  59         struct vrs_header far *vrs = spri->spritesheet->vrs_hdr;\r
  60         // Retruve animation ids list\r
  61         uint16_t far *anim_ids =        (uint16_t far *)\r
  62                                         ((byte far *)vrs +\r
  63                                          vrs->offset_table[VRS_HEADER_OFFSET_ANIMATION_ID_LIST]);\r
  64 \r
  65         // Loop through animation id untill match or end of list\r
  66         while(iter_id = anim_ids[new_anim_index])\r
  67         {\r
  68                 // Return on successful match\r
  69                 if (iter_id == anim_id)\r
  70                 {\r
  71                         init_anim(spri, new_anim_index);\r
  72                         return 0;\r
  73                 }\r
  74                 new_anim_index++;\r
  75         }\r
  76         return -1;\r
  77 }\r
  78 \r
  79 void print_anim_ids(struct sprite *spri)\r
  80 {\r
  81         int new_anim_index = 0;\r
  82         int iter_id;\r
  83         struct vrs_header far *vrs = spri->spritesheet->vrs_hdr;\r
  84         // Retruve animation ids list\r
  85         uint16_t far *anim_ids =        (uint16_t far *)\r
  86                                         ((byte far *)vrs +\r
  87                                          vrs->offset_table[VRS_HEADER_OFFSET_ANIMATION_ID_LIST]);\r
  88 \r
  89         if(!anim_ids[new_anim_index])\r
  90                 return;\r
  91         // Loop through animation id untill match or end of list\r
  92         while(iter_id = anim_ids[new_anim_index])\r
  93         {\r
  94                 printf("s%d ", iter_id);\r
  95                 new_anim_index++;\r
  96         }\r
  97 }\r
  98 \r
  99 void oldanimate_spri(struct sprite *spri, video_t *video)\r
 100 {\r
 101         int i;\r
 102         // Events go here\r
 103 \r
 104 \r
 105         vga_state.vga_graphics_ram = (VGA_RAM_PTR)video->page[0].data;//vga_state.vga_graphics_ram; // save original mem ptr\r
 106 \r
 107 \r
 108         // Draw sprite\r
 109         i = get_vrl_by_id(spri->spritesheet, spri->curr_spri_id, spri->sprite_vrl_cont);\r
 110         if(i < 0)\r
 111         {\r
 112                 //Quit (gv, "Error retriving required sprite");\r
 113                 return;\r
 114         }\r
 115 \r
 116         // replace VGA stride with our own and mem ptr. then sprite rendering at this stage is just (0,0)\r
 117         vga_state.vga_draw_stride_limit = (video->page[0].width + 3 - spri->x) >> 2;\r
 118 \r
 119 #ifndef SPRITE\r
 120         modexClearRegion(&video->page[0], spri->x, spri->y, 16, 32, 1);\r
 121 #else\r
 122         draw_vrl1_vgax_modex(\r
 123                 spri->x,//-video->page[0].dx,\r
 124                 spri->y,//-video->page[0].dy,\r
 125                 spri->sprite_vrl_cont->vrl_header,\r
 126                 spri->sprite_vrl_cont->line_offsets,\r
 127                 spri->sprite_vrl_cont->buffer + sizeof(struct vrl1_vgax_header),\r
 128                 spri->sprite_vrl_cont->data_size\r
 129         );\r
 130 #endif\r
 131 \r
 132         // restore stride\r
 133         vga_state.vga_draw_stride_limit = vga_state.vga_draw_stride = video->page[0].stridew;\r
 134 \r
 135         // Depending on delay, update indices\r
 136         switch(spri->delay){\r
 137                 // Delay = 0 means that sprite should loop. Nothing to change here\r
 138                 case 0:\r
 139                         break;\r
 140 \r
 141                 // Delay = 1 means that on next time unit sprite should be changed\r
 142                 case 1:\r
 143                         spri->curr_anim_spri++;\r
 144 \r
 145                         // If we hit the end of an animation sequence, restart it\r
 146                         if(!(spri->curr_spri_id = spri->curr_anim_list[spri->curr_anim_spri].sprite_id)){\r
 147                                 spri->curr_anim_spri = 0;\r
 148                                 spri->curr_spri_id = spri->curr_anim_list[spri->curr_anim_spri].sprite_id;\r
 149                         }\r
 150                         spri->delay = spri->curr_anim_list[spri->curr_anim_spri].delay;\r
 151 \r
 152                 // Delay > 1 means that we should not change sprite yet. Decrease delay\r
 153                 default:\r
 154                         spri->delay--;\r
 155                         break;\r
 156         }\r
 157         vga_state.vga_graphics_ram = video->omemptr;\r
 158 }\r
 159 \r
 160 \r
 161 void animate_spri(struct sprite *spri, video_t *video)\r
 162 {\r
 163 #define GVARVIDEO video\r
 164 #define VMEMPAGESIZE2   GVARVIDEO->page[0].pagesize+GVARVIDEO->page[1].pagesize\r
 165 #define VMEMPAGEDATA2   GVARVIDEO->page[2].data\r
 166         unsigned int i,o,o2; int j;\r
 167         int x,y,rx,ry,w,h;\r
 168         int overdraw = 0;//16;  // how many pixels to "overdraw" so that moving sprites with edge pixels don't leave streaks.\r
 169                                                 // if the sprite's edge pixels are clear anyway, you can set this to 0.\r
 170         VGA_RAM_PTR omemptr;\r
 171 \r
 172         // Events go here\r
 173 \r
 174 \r
 175         omemptr = (VGA_RAM_PTR)video->page[0].data;//vga_state.vga_graphics_ram; // save original mem ptr\r
 176         x=spri->x;\r
 177         y=spri->y;\r
 178 \r
 179         // Draw sprite\r
 180         j = get_vrl_by_id(spri->spritesheet, spri->curr_spri_id, spri->sprite_vrl_cont);\r
 181         if(j < 0)\r
 182         {\r
 183                 //Quit (gv, "Error retriving required sprite");\r
 184                 return;\r
 185         }\r
 186 \r
 187         // render box bounds. y does not need modification, but x and width must be multiple of 4\r
 188         if (x >= overdraw) rx = (x - overdraw) & (~3);\r
 189                 else rx = -(GVARVIDEO->page[0].dx);\r
 190         if (y >= overdraw) ry = (y - overdraw);\r
 191                 else ry = -(GVARVIDEO->page[0].dy);\r
 192         h = spri->sprite_vrl_cont->vrl_header->height + overdraw + y - ry;\r
 193         w = (x + spri->sprite_vrl_cont->vrl_header->width + (overdraw*2) + 3 - rx) & (~3);//round up\r
 194         if ((rx+w) > GVARVIDEO->page[0].width) w = GVARVIDEO->page[0].width-rx;\r
 195         if ((ry+h) > GVARVIDEO->page[0].height) h = GVARVIDEO->page[0].height-ry;\r
 196 \r
 197         // block copy pattern to where we will draw the sprite\r
 198         vga_setup_wm1_block_copy();\r
 199         o2 = VMEMPAGESIZE2;\r
 200         o = (0x10000UL - (uint16_t)VMEMPAGEDATA2) + (ry * GVARVIDEO->page[0].stridew) + (rx >> 2); // source offscreen\r
 201         for (i=0;i < h;i++,o += GVARVIDEO->page[0].stridew,o2 += (w >> 2)) vga_wm1_mem_block_copy(o2,o,w >> 2);\r
 202 \r
 203         // must restore Write Mode 0/Read Mode 0 for this code to continue drawing normally\r
 204         vga_restore_rm0wm0();\r
 205 \r
 206         // replace VGA stride with our own and mem ptr. then sprite rendering at this stage is just (0,0)\r
 207         vga_state.vga_draw_stride_limit = (GVARVIDEO->page[0].width + 3 - x) >> 2;//round up\r
 208         vga_state.vga_draw_stride = w >> 2;\r
 209         vga_state.vga_graphics_ram = omemptr + VMEMPAGESIZE2;\r
 210 \r
 211         // then the sprite. note modding ram ptr means we just draw to (x&3,0)\r
 212 #ifndef SPRITE\r
 213         modexClearRegion(&GVARVIDEO->page[0], x, y, 16, 32, 1);\r
 214 #else\r
 215         draw_vrl1_vgax_modex(\r
 216                 x-rx,\r
 217                 y-ry,\r
 218                 spri->sprite_vrl_cont->vrl_header,\r
 219                 spri->sprite_vrl_cont->line_offsets,\r
 220                 spri->sprite_vrl_cont->buffer + sizeof(struct vrl1_vgax_header),\r
 221                 spri->sprite_vrl_cont->data_size\r
 222         );\r
 223 #endif\r
 224         // restore ptr\r
 225         vga_state.vga_graphics_ram = omemptr;\r
 226 \r
 227         // block copy to visible RAM from offscreen\r
 228         vga_setup_wm1_block_copy();\r
 229         o = VMEMPAGESIZE2; // source offscreen\r
 230         o2 = (ry * GVARVIDEO->page[0].stridew) + (rx >> 2); // dest visible (original stride)\r
 231         for (i=0;i < h;i++,o += vga_state.vga_draw_stride,o2 += GVARVIDEO->page[0].stridew) vga_wm1_mem_block_copy(o2,o,w >> 2);\r
 232         // must restore Write Mode 0/Read Mode 0 for this code to continue drawing normally\r
 233         vga_restore_rm0wm0();\r
 234 \r
 235         // restore stride\r
 236         vga_state.vga_draw_stride_limit = vga_state.vga_draw_stride = GVARVIDEO->page[0].stridew;\r
 237 \r
 238         // Depending on delay, update indices\r
 239         switch(spri->delay){\r
 240                 // Delay = 0 means that sprite should loop. Nothing to change here\r
 241                 case 0:\r
 242                         break;\r
 243 \r
 244                 // Delay = 1 means that on next time unit sprite should be changed\r
 245                 case 1:\r
 246                         spri->curr_anim_spri++;\r
 247 \r
 248                         // If we hit the end of an animation sequence, restart it\r
 249                         if(!(spri->curr_spri_id = spri->curr_anim_list[spri->curr_anim_spri].sprite_id)){\r
 250                                 spri->curr_anim_spri = 0;\r
 251                                 spri->curr_spri_id = spri->curr_anim_list[spri->curr_anim_spri].sprite_id;\r
 252                         }\r
 253                         spri->delay = spri->curr_anim_list[spri->curr_anim_spri].delay;\r
 254 \r
 255                 // Delay > 1 means that we should not change sprite yet. Decrease delay\r
 256                 default:\r
 257                         spri->delay--;\r
 258                         break;\r
 259         }\r
 260         vga_state.vga_graphics_ram = video->omemptr;\r
 261 }\r