src/video/drawing.c

   1 /* drawing.c
   2  * interface functions to core functions
   3  */
   4
   5 /*-------------------- Extern Headers Including --------------------*/
   6
   7
   8 /*-------------------- Local Headers Including ---------------------*/
   9 #include <graphics.h>
  10 #include <extlib.h>
  11
  12 /*-------------------- Main Module Header --------------------------*/
  13 #include "video.h"
  14
  15
  16 /*--------------------      Other       ----------------------------*/
  17
  18 /*-------------------- Global Variables ----------------------------*/
  19
  20 /*-------------------- Static Variables ----------------------------*/
  21
  22 /*-------------------- Static Prototypes ---------------------------*/
  23
  24
  25
  26 /*-------------------- Static Functions ----------------------------*/
  27
  28 /*-------------------- Global Functions ----------------------------*/
  29 v_elem *
  30 Neuro_PushDraw(u32 layer, Rectan *isrc, Rectan *idst, v_object *isurface)
  31 {
  32         Graphics_SetSafeDrawOp(1);
  33         return Graphics_AddDrawingInstruction(layer, TDRAW_STATIC, isrc, idst, isurface);
  34 }
  35
  36 int
  37 Neuro_FetchDraw(v_elem *eng, Rectan **psrc, u16 **px, u16 **py, v_object **osurface)
  38 {
  39         if (!eng)
  40                 return 1;
  41
  42         if (!eng->current)
  43                 return 1;
  44
  45         if (Graphics_GetSafeDrawOp() == 0)
  46                 return 1;
  47
  48         if (psrc)
  49                 *psrc = &eng->current->src;
  50
  51         if (px)
  52                 *px = &eng->current->dx;
  53
  54         if (py)
  55                 *py = &eng->current->dy;
  56
  57         if (osurface)
  58         {
  59                 /*Debug_Val(0, "surface_ptr 0x%x addr surface_ptr 0x%x\n",
  60                                 eng->surface_ptr, &eng->surface_ptr);*/
  61                 *osurface = eng->current->surface_ptr;
  62         }
  63
  64         return 0;
  65 }
  66
  67 int
  68 Neuro_SetDraw(v_elem *eng, v_object *isurface)
  69 {
  70         if (!eng)
  71                 return 1;
  72
  73         if (!eng->current)
  74                 return 1;
  75
  76         if (!isurface)
  77                 return 1;
  78
  79         if (Graphics_GetSafeDrawOp() == 0)
  80                 return 1;
  81
  82         eng->current->surface_ptr = isurface;
  83
  84         return 0;
  85 }
  86
  87 int
  88 Neuro_CleanDraw(v_elem *eng)
  89 {
  90         Rectan buf;
  91         v_object *screen;
  92
  93         if (!eng)
  94                 return 1;
  95
  96         if (!eng->current)
  97                 return 1;
  98
  99         if (Graphics_GetSafeDrawOp() == 0)
 100                 return 1;
 101
 102         buf.x = eng->current->dx;
 103         buf.y = eng->current->dy;
 104         buf.w = eng->current->src.w;
 105         buf.h = eng->current->src.h;
 106
 107         /* we start by redrawing above the static
 108          * image location to reset its image.
 109          * it may be the background or black.
 110          */
 111         /*if (background)
 112         {
 113                 Lib_BlitObject(background, &buf, sclScreen2, NULL);
 114         }
 115         else*/
 116
 117         screen = Neuro_GetScreenBuffer();
 118
 119         Lib_FillRect(screen, &buf, 0);
 120
 121         /* redraw_erased_for_object(eng); */
 122         Graphics_RedrawSection(eng);
 123
 124         return 0;
 125 }
 126
 127 /* this function is to tag the element to be
 128  * redrawn.
 129  */
 130 int
 131 Neuro_FlushDraw(v_elem *eng)
 132 {
 133         if (!eng)
 134                 return 1;
 135
 136         if (!eng->current)
 137                 return 1;
 138
 139         if (Graphics_GetSafeDrawOp() == 0)
 140                 return 1;
 141
 142         if (eng->current->type == TDRAW_SDRAWN)
 143         {
 144                 eng->current->type = TDRAW_SREDRAW;
 145
 146                 /* flag the algorithm to tell it something changed
 147                  * and an action needs to be taken.
 148                  */
 149                 Neuro_RedrawScreen();
 150                 /* draw_this_cycle = 1; */
 151         }
 152         else
 153                 return 1;
 154
 155         return 0;
 156 }
 157
 158 int
 159 Neuro_DestroyDraw(v_elem *eng)
 160 {
 161         if (!eng)
 162                 return 1;
 163
 164         if (!eng->current)
 165                 return 1;
 166
 167         if (Graphics_GetSafeDrawOp() == 0)
 168                 return 1;
 169
 170         if (eng->current->type == TDRAW_STATIC)
 171                 return 1;
 172
 173         if (Graphics_DrawIsPresent(eng) == 0)
 174                 return 1;
 175
 176         eng->current->type = TDRAW_SDESTROY;
 177         /* clean_object(eng); */
 178
 179         Neuro_RedrawScreen();
 180         /* draw_this_cycle = 1; */
 181
 182         return 0;
 183 }
 184
 185 void
 186 Neuro_PushStaticDraw(u32 layer, Rectan *isrc, Rectan *idst, v_object *isurface)
 187 {
 188         Graphics_AddDrawingInstruction(layer, TDRAW_STATIC, isrc, idst, isurface);
 189 }
 190
 191 void
 192 Neuro_PushDynamicDraw(u32 layer, Rectan *isrc, Rectan *idst, v_object *isurface)
 193 {
 194         Graphics_AddDrawingInstruction(layer, TDRAW_DYNAMIC, isrc, idst, isurface);
 195 }
 196
 197 /* push a drawing instruction that will be deleted from the queue and raw
 198  * after being drawn. This replaces the hackish override method with an
 199  * ultra versatile one and much less costy ;P.
 200  */
 201 void
 202 Neuro_PushVolatileDraw(u32 layer, Rectan *isrc, Rectan *idst, v_object *isurface)
 203 {
 204         Graphics_AddDrawingInstruction(layer, TDRAW_VOLATILE, isrc, idst, isurface);
 205 }