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
  92 int
  93 Neuro_SetImgPos(v_elem *eng, u16 px, u16 py)
  94 {
  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         eng->current->dx = px;
 108         eng->current->dy = py;
 109
 110         return 0;
 111 }
 112
 113 int
 114 Neuro_SetImgLayer(v_elem *eng, u32 layer)
 115 {
 116         if (!eng)
 117                 return 1;
 118
 119         if (!eng->current)
 120                 return 1;
 121
 122         if (Graphics_GetSafeDrawOp() == 0)
 123                 return 1;
 124
 125         eng->current->layer = layer;
 126
 127         return 0;
 128 }
 129
 130 int
 131 Neuro_SetImgSrcPos(v_elem *eng, Rectan *psrc)
 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 (!psrc)
 143                 return 1;
 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                 Rectan dst;
 228
 229                 dst.x = eng->current->dx;
 230                 dst.y = eng->current->dy;
 231                 dst.w = eng->current->src.w;
 232                 dst.h = eng->current->src.h;
 233
 234
 235                 eng->current->type = TDRAW_STATIC;
 236
 237                 /* flag the algorithm to tell it something changed
 238                  * and an action needs to be taken.
 239                  */
 240                 Neuro_RedrawScreen();
 241                 /* draw_this_cycle = 1; */
 242         }
 243         else
 244                 return 1;
 245
 246         return 0;
 247 }
 248
 249 int
 250 Neuro_DestroyDraw(v_elem *eng)
 251 {
 252         if (!eng)
 253                 return 1;
 254
 255         if (!eng->current)
 256                 return 1;
 257
 258         if (Graphics_GetSafeDrawOp() == 0)
 259                 return 1;
 260
 261         if (eng->current->type == TDRAW_STATIC)
 262                 return 1;
 263
 264         if (Graphics_DrawIsPresent(eng) == 0)
 265                 return 1;
 266
 267         /* eng->current->type = TDRAW_SDESTROY; */
 268
 269         /* the official way of deleting an element */
 270         Graphics_DestroyElement(eng);
 271
 272         /* clean_object(eng); */
 273
 274
 275
 276         Neuro_RedrawScreen();
 277         /* draw_this_cycle = 1; */
 278
 279         return 0;
 280 }
 281
 282 void
 283 Neuro_PushStaticDraw(u32 layer, Rectan *isrc, Rectan *idst, v_object *isurface)
 284 {
 285         Graphics_AddDrawingInstruction(layer, TDRAW_STATIC, isrc, idst, isurface);
 286 }
 287
 288 void
 289 Neuro_PushDynamicDraw(u32 layer, Rectan *isrc, Rectan *idst, v_object *isurface)
 290 {
 291         Graphics_AddDrawingInstruction(layer, TDRAW_DYNAMIC, isrc, idst, isurface);
 292 }
 293
 294 /* push a drawing instruction that will be deleted from the queue and raw
 295  * after being drawn. This replaces the hackish override method with an
 296  * ultra versatile one and much less costy ;P.
 297  */
 298 void
 299 Neuro_PushVolatileDraw(u32 layer, Rectan *isrc, Rectan *idst, v_object *isurface)
 300 {
 301         Graphics_AddDrawingInstruction(layer, TDRAW_VOLATILE, isrc, idst, isurface);
 302 }