gfx/libs/glut/state.c

   1 /*
   2  * DOS/DJGPP Mesa Utility Toolkit
   3  * Version:  1.0
   4  *
   5  * Copyright (C) 2005  Daniel Borca   All Rights Reserved.
   6  *
   7  * Permission is hereby granted, free of charge, to any person obtaining a
   8  * copy of this software and associated documentation files (the "Software"),
   9  * to deal in the Software without restriction, including without limitation
  10  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  11  * and/or sell copies of the Software, and to permit persons to whom the
  12  * Software is furnished to do so, subject to the following conditions:
  13  *
  14  * The above copyright notice and this permission notice shall be included
  15  * in all copies or substantial portions of the Software.
  16  *
  17  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  18  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  19  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  20  * DANIEL BORCA BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
  21  * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  22  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  23  */
  24
  25 #include <stdio.h>
  26
  27 #include "internal.h"
  28
  29 #include <aros/debug.h>
  30
  31 extern struct AROSMesaGLUT_TaskNode     *_glut_findtask(struct Task *);
  32
  33 static int timer_installed;
  34 #include <time.h>
  35
  36 static struct timeval time_start;
  37
  38 int APIENTRY
  39 glutGet (GLenum type)
  40 {
  41
  42    D(bug("[AMGLUT] In glutGet(type:%d) ", type));
  43
  44    struct AROSMesaGLUT_TaskNode *__glutTask = _glut_findtask(FindTask(NULL));
  45
  46    switch (type) {
  47       case GLUT_WINDOW_X:
  48       {
  49          D(bug("GLUT_WINDOW_X = %d\n", __glutTask->AMGLUTTN_WindowCurrent->amglutwin_xpos));
  50
  51          return __glutTask->AMGLUTTN_WindowCurrent->amglutwin_xpos;
  52       }
  53       case GLUT_WINDOW_Y:
  54       {
  55          D(bug("GLUT_WINDOW_Y = %d\n", __glutTask->AMGLUTTN_WindowCurrent->amglutwin_ypos));
  56
  57          return __glutTask->AMGLUTTN_WindowCurrent->amglutwin_ypos;
  58       }
  59       case GLUT_WINDOW_WIDTH:
  60       {
  61          D(bug("GLUT_WINDOW_WIDTH = %d\n", __glutTask->AMGLUTTN_WindowCurrent->amglutwin_width));
  62
  63          return __glutTask->AMGLUTTN_WindowCurrent->amglutwin_width;
  64       }
  65       case GLUT_WINDOW_HEIGHT:
  66       {
  67          D(bug("GLUT_WINDOW_HEIGHT = %d\n", __glutTask->AMGLUTTN_WindowCurrent->amglutwin_height));
  68
  69          return __glutTask->AMGLUTTN_WindowCurrent->amglutwin_height;
  70       }
  71       case GLUT_WINDOW_STENCIL_SIZE:
  72       {
  73          D(bug("GLUT_STENCIL_SIZE = %d\n", _glut_visual.stencil));
  74
  75          return _glut_visual.stencil;
  76       }
  77       case GLUT_WINDOW_DEPTH_SIZE:
  78       {
  79          D(bug("GLUT_DEPTH_SIZE = %d\n", _glut_visual.depth));
  80
  81          return _glut_visual.depth;
  82       }
  83       case GLUT_WINDOW_RGBA:
  84       {
  85          D(bug("GLUT_WINDOW_RGBA = %d", !(_glut_default.mode & GLUT_INDEX)));
  86
  87          return !(_glut_default.mode & GLUT_INDEX);
  88       }
  89       case GLUT_WINDOW_COLORMAP_SIZE:
  90       {
  91          D(bug("GLUT_WINDOW_COLORMAP_SIZE\n"));
  92
  93          return (_glut_default.mode & GLUT_INDEX) ? (256 - RESERVED_COLORS) : 0;
  94       }
  95       case GLUT_SCREEN_WIDTH:
  96       {
  97          D(bug("GLUT_SCREEN_WIDTH = %d\n", _glut_visual.geometry[0]));
  98
  99          return _glut_visual.geometry[0];
 100       }
 101       case GLUT_SCREEN_HEIGHT:
 102       {
 103         D(bug("GLUT_SCREEN_HEIGHT = %d\n", _glut_visual.geometry[1]));
 104
 105          return _glut_visual.geometry[1];
 106       }
 107       case GLUT_INIT_WINDOW_X:
 108          return _glut_default.x;
 109       case GLUT_INIT_WINDOW_Y:
 110          return _glut_default.y;
 111       case GLUT_INIT_WINDOW_WIDTH:
 112          return _glut_default.width;
 113       case GLUT_INIT_WINDOW_HEIGHT:
 114          return _glut_default.height;
 115       case GLUT_INIT_DISPLAY_MODE:
 116          return _glut_default.mode;
 117       case GLUT_ELAPSED_TIME:
 118       {
 119          D(bug("GLUT_ELAPSED_TIME\n"));
 120
 121          if (!timer_installed) {
 122             timer_installed = GL_TRUE;
 123 /*            gettimeofday(&then, NULL);*/
 124             CurrentTime(&time_start.tv_sec, &time_start.tv_usec);
 125             return 0;
 126          } else {
 127             struct timeval time_current;
 128 /*            gettimeofday(&now, NULL);
 129             return (now.tv_usec - then.tv_usec) / 1000 +
 130                    (now.tv_sec  - then.tv_sec)  * 1000;*/
 131             CurrentTime(&time_current.tv_sec, &time_current.tv_usec);
 132             return (time_current.tv_usec - time_start.tv_usec) / 1000 +
 133                    (time_current.tv_sec  - time_start.tv_sec)  * 1000;
 134          }
 135       }
 136       default:
 137       {
 138          D(bug("UNKNOWN VALUE!\n"));
 139
 140          return -1;
 141       }
 142    }
 143 }
 144
 145
 146 int APIENTRY
 147 glutDeviceGet (GLenum type)
 148 {
 149    D(bug("[AMGLUT] In glutDeviceGet()\n"));
 150
 151    switch (type) {
 152       case GLUT_HAS_KEYBOARD:
 153          return GL_TRUE;
 154       case GLUT_HAS_MOUSE:
 155          return GL_TRUE;
 156       case GLUT_NUM_MOUSE_BUTTONS:
 157          return 3;
 158       case GLUT_HAS_SPACEBALL:
 159       case GLUT_HAS_DIAL_AND_BUTTON_BOX:
 160       case GLUT_HAS_TABLET:
 161          return GL_FALSE;
 162       case GLUT_NUM_SPACEBALL_BUTTONS:
 163       case GLUT_NUM_BUTTON_BOX_BUTTONS:
 164       case GLUT_NUM_DIALS:
 165       case GLUT_NUM_TABLET_BUTTONS:
 166          return 0;
 167       default:
 168          return -1;
 169    }
 170 }
 171
 172
 173 int APIENTRY
 174 glutGetModifiers (void)
 175 {
 176    int mod = 0;
 177
 178    D(bug("[AMGLUT] In glutGetModifiers()\n"));
 179
 180 //   int shifts = pc_keyshifts();
 181
 182 /*   if (shifts & (KB_SHIFT_FLAG | KB_CAPSLOCK_FLAG)) {
 183       mod |= GLUT_ACTIVE_SHIFT;
 184    }
 185
 186    if (shifts & KB_ALT_FLAG) {
 187       mod |= GLUT_ACTIVE_ALT;
 188    }
 189
 190    if (shifts & KB_CTRL_FLAG) {
 191       mod |= GLUT_ACTIVE_CTRL;
 192    }*/
 193
 194    return mod;
 195 }
 196
 197
 198 void APIENTRY
 199 glutReportErrors (void)
 200 {
 201    D(bug("[AMGLUT] In glutReportErrors()\n"));
 202
 203    /* reports all the OpenGL errors that happened till now */
 204 }
 205
 206
 207 /* GAME MODE
 208  * Hack alert: incomplete... what is GameMode, anyway?
 209  */
 210 static GLint game;
 211 static GLboolean game_possible;
 212 static GLboolean game_active;
 213 static GLuint game_width;
 214 static GLuint game_height;
 215 static GLuint game_bpp;
 216 static GLuint game_refresh;
 217
 218
 219 void APIENTRY
 220 glutGameModeString (const char *string)
 221 {
 222    D(bug("[AMGLUT] In glutGameModeString()\n"));
 223
 224    if (sscanf(string, "%ux%u:%u@%u", &game_width, &game_height, &game_bpp, &game_refresh) == 4) {
 225       game_possible = GL_TRUE;
 226    }
 227 }
 228
 229
 230 int APIENTRY
 231 glutGameModeGet (GLenum mode)
 232 {
 233    D(bug("[AMGLUT] In glutGameModeGet()\n"));
 234
 235    struct AROSMesaGLUT_TaskNode *__glutTask = _glut_findtask(FindTask(NULL));
 236    switch (mode) {
 237       case GLUT_GAME_MODE_ACTIVE:
 238          return game_active;
 239       case GLUT_GAME_MODE_POSSIBLE:
 240          return game_possible && !__glutTask->AMGLUTTN_WindowCurrent;
 241       case GLUT_GAME_MODE_WIDTH:
 242          return game_active ? (int)game_width : -1;
 243       case GLUT_GAME_MODE_HEIGHT:
 244          return game_active ? (int)game_height : -1;
 245       case GLUT_GAME_MODE_PIXEL_DEPTH:
 246          return game_active ? (int)game_bpp : -1;
 247       case GLUT_GAME_MODE_REFRESH_RATE:
 248          return game_active ? (int)game_refresh : -1;
 249       default:
 250          return -1;
 251    }
 252 }
 253
 254
 255 int APIENTRY
 256 glutEnterGameMode (void)
 257 {
 258    D(bug("[AMGLUT] In glutEnterGameMode()\n"));
 259
 260    if (glutGameModeGet(GLUT_GAME_MODE_POSSIBLE)) {
 261       _glut_visual.bpp = game_bpp;
 262       _glut_visual.refresh = game_refresh;
 263
 264       glutInitWindowSize(game_width, game_height);
 265
 266       if ((game = glutCreateWindow("<game>")) > 0) {
 267          game_active = GL_TRUE;
 268       }
 269
 270       return game;
 271    } else {
 272       return 0;
 273    }
 274 }
 275
 276
 277 void GLUTAPIENTRY
 278 glutLeaveGameMode (void)
 279 {
 280    D(bug("[AMGLUT] In glutLeaveGameMode()\n"));
 281
 282    if (glutGameModeGet(GLUT_GAME_MODE_ACTIVE)) {
 283       game_active = GL_FALSE;
 284
 285       glutDestroyWindow(game);
 286    }
 287 }