src/video/interface.c

   1 /*
   2  * libneuro, a light weight abstraction of high or lower libraries
   3  * and toolkit for applications.
   4  * Copyright (C) 2005-2006  Nicholas Niro, Robert Lemay
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  19  */
  20
  21
  22 /* interface.c
  23  * interface functions to core functions
  24  */
  25
  26 /*-------------------- Extern Headers Including --------------------*/
  27 #include <string.h> /* memcpy */
  28
  29 /*-------------------- Local Headers Including ---------------------*/
  30 #include <graphics.h>
  31 #include <extlib.h>
  32
  33 /*-------------------- Main Module Header --------------------------*/
  34 #include "video.h"
  35
  36
  37 /*--------------------      Other       ----------------------------*/
  38
  39 /*-------------------- Global Variables ----------------------------*/
  40
  41 /*-------------------- Static Variables ----------------------------*/
  42
  43 /*-------------------- Static Prototypes ---------------------------*/
  44
  45
  46
  47 /*-------------------- Static Functions ----------------------------*/
  48
  49 /*-------------------- Global Functions ----------------------------*/
  50 v_elem *
  51 Neuro_PushDraw(u32 layer, Rectan *isrc, Rectan *idst, v_object *isurface)
  52 {
  53         if (Graphics_GetSafeDrawOp() == 0)
  54                 return NULL;
  55
  56
  57         return Graphics_AddDrawingInstruction(layer, TDRAW_STATIC, isrc, idst, isurface);
  58 }
  59
  60 int
  61 Neuro_FetchDraw(v_elem *eng, Rectan *psrc, u16 *px, u16 *py, v_object **osurface)
  62 {
  63         if (!eng)
  64                 return 1;
  65
  66         if (!eng->current)
  67                 return 1;
  68
  69         if (Graphics_GetSafeDrawOp() == 0)
  70                 return 1;
  71
  72         if (psrc)
  73                 memcpy(psrc, &eng->current->src, sizeof(Rectan));
  74
  75         if (px)
  76                 *px = eng->current->dx;
  77
  78         if (py)
  79                 *py = eng->current->dy;
  80
  81         if (osurface)
  82         {
  83                 /*Debug_Val(0, "surface_ptr 0x%x addr surface_ptr 0x%x\n",
  84                                 eng->surface_ptr, &eng->surface_ptr);*/
  85                 *osurface = eng->current->surface_ptr;
  86         }
  87
  88         return 0;
  89 }
  90
  91 int
  92 Neuro_SetImgPos(v_elem *eng, u16 px, u16 py)
  93 {
  94         Rectan dst;
  95         if (!eng)
  96                 return 1;
  97
  98         if (!eng->current)
  99                 return 1;
 100
 101         if (Graphics_GetSafeDrawOp() == 0)
 102                 return 1;
 103
 104         if (!px || !py)
 105                 return 1;
 106
 107
 108
 109         dst.x = eng->current->dx;
 110         dst.y = eng->current->dy;
 111         dst.w = eng->current->src.w;
 112         dst.h = eng->current->src.h;
 113
 114         Lib_FillRect(Neuro_GetScreenBuffer(), &dst, 0);
 115
 116         eng->current->dx = px;
 117         eng->current->dy = py;
 118
 119         return 0;
 120 }
 121
 122 int
 123 Neuro_SetImgSrcPos(v_elem *eng, Rectan *psrc)
 124 {
 125         Rectan dst;
 126         if (!eng)
 127                 return 1;
 128
 129         if (!eng->current)
 130                 return 1;
 131
 132         if (Graphics_GetSafeDrawOp() == 0)
 133                 return 1;
 134
 135         if (!psrc)
 136                 return 1;
 137
 138         dst.x = eng->current->dx;
 139         dst.y = eng->current->dy;
 140         dst.w = eng->current->src.w;
 141         dst.h = eng->current->src.h;
 142
 143         Lib_FillRect(Neuro_GetScreenBuffer(), &dst, 0);
 144
 145         memcpy(&eng->current->src, psrc, sizeof(Rectan));
 146
 147         return 0;
 148 }
 149
 150 int
 151 Neuro_SetDraw(v_elem *eng, v_object *isurface)
 152 {
 153         if (!eng)
 154                 return 1;
 155
 156         if (!eng->current)
 157                 return 1;
 158
 159         if (!isurface)
 160                 return 1;
 161
 162         if (Graphics_GetSafeDrawOp() == 0)
 163                 return 1;
 164
 165         eng->current->surface_ptr = isurface;
 166
 167         return 0;
 168 }
 169
 170 int
 171 Neuro_CleanDraw(v_elem *eng)
 172 {
 173         Rectan buf;
 174         v_object *screen;
 175
 176         if (!eng)
 177                 return 1;
 178
 179         if (!eng->current)
 180                 return 1;
 181
 182         if (Graphics_GetSafeDrawOp() == 0)
 183                 return 1;
 184
 185         buf.x = eng->current->dx;
 186         buf.y = eng->current->dy;
 187         buf.w = eng->current->src.w;
 188         buf.h = eng->current->src.h;
 189
 190         /* we start by redrawing above the static
 191          * image location to reset its image.
 192          * it may be the background or black.
 193          */
 194         /*if (background)
 195         {
 196                 Lib_BlitObject(background, &buf, sclScreen2, NULL);
 197         }
 198         else*/
 199
 200         screen = Neuro_GetScreenBuffer();
 201
 202         Lib_FillRect(screen, &buf, 0);
 203
 204         /* redraw_erased_for_object(eng); */
 205         Graphics_RedrawSection(eng);
 206
 207         return 0;
 208 }
 209
 210 /* this function is to tag the element to be
 211  * redrawn.
 212  */
 213 int
 214 Neuro_FlushDraw(v_elem *eng)
 215 {
 216         if (!eng)
 217                 return 1;
 218
 219         if (!eng->current)
 220                 return 1;
 221
 222         if (Graphics_GetSafeDrawOp() == 0)
 223                 return 1;
 224
 225         if (eng->current->type == TDRAW_SDRAWN)
 226         {
 227                 eng->current->type = TDRAW_STATIC;
 228
 229                 /* flag the algorithm to tell it something changed
 230                  * and an action needs to be taken.
 231                  */
 232                 Neuro_RedrawScreen();
 233                 /* draw_this_cycle = 1; */
 234         }
 235         else
 236                 return 1;
 237
 238         return 0;
 239 }
 240
 241 int
 242 Neuro_DestroyDraw(v_elem *eng)
 243 {
 244         if (!eng)
 245                 return 1;
 246
 247         if (!eng->current)
 248                 return 1;
 249
 250         if (Graphics_GetSafeDrawOp() == 0)
 251                 return 1;
 252
 253         if (eng->current->type == TDRAW_STATIC)
 254                 return 1;
 255
 256         if (Graphics_DrawIsPresent(eng) == 0)
 257                 return 1;
 258
 259         /* eng->current->type = TDRAW_SDESTROY; */
 260
 261         /* the official way of deleting an element */
 262         Graphics_DestroyElement(eng);
 263
 264         /* clean_object(eng); */
 265
 266
 267
 268         Neuro_RedrawScreen();
 269         /* draw_this_cycle = 1; */
 270
 271         return 0;
 272 }
 273
 274 void
 275 Neuro_PushStaticDraw(u32 layer, Rectan *isrc, Rectan *idst, v_object *isurface)
 276 {
 277         Graphics_AddDrawingInstruction(layer, TDRAW_STATIC, isrc, idst, isurface);
 278 }
 279
 280 void
 281 Neuro_PushDynamicDraw(u32 layer, Rectan *isrc, Rectan *idst, v_object *isurface)
 282 {
 283         Graphics_AddDrawingInstruction(layer, TDRAW_DYNAMIC, isrc, idst, isurface);
 284 }
 285
 286 /* push a drawing instruction that will be deleted from the queue and raw
 287  * after being drawn. This replaces the hackish override method with an
 288  * ultra versatile one and much less costy ;P.
 289  */
 290 void
 291 Neuro_PushVolatileDraw(u32 layer, Rectan *isrc, Rectan *idst, v_object *isurface)
 292 {
 293         Graphics_AddDrawingInstruction(layer, TDRAW_VOLATILE, isrc, idst, isurface);
 294 }