Forum

OpenGL for SDLQuake

Discuss programming topics that involve the OpenGL API.

Moderator: InsideQC Admins

OpenGL for SDLQuake

Postby Rikku2000 » Sun Jan 22, 2012 9:06 pm

here i edit the vid_sdl.c and vid.h on sdlquake to use it with GL.

Code here for vid_sdl.c:
Code: Select all
/*
Copyright (C) 1996-1997 Id Software, Inc.

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. 

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

*/
// vid_sdl.h -- sdl video driver

// SDLGL Support by Rikku2000

#include "SDL.h"
#include "quakedef.h"
#ifndef GLQUAKE
#include "d_local.h"
#endif

// Much better for high resolution displays
#define    BASEWIDTH    (320*2)
#define    BASEHEIGHT   (200*2)

int      VGA_width, VGA_height, VGA_rowbytes, VGA_bufferrowbytes = 0;
byte   *VGA_pagebase;

viddef_t vid; // global video state
static SDL_Surface *screen = NULL;

unsigned short  d_8to16table[256];

#ifdef GLQUAKE
static int scr_width, scr_height;
static float vid_gamma = 1.0;

qboolean is8bit = false;
qboolean fullsbardraw = true;
qboolean isPermedia;
qboolean gl_mtexable;

int min_vid_width;

unsigned d_8to24table[256];
unsigned char d_15to8table[65536];

void (*VID_SetGammaRamp)(unsigned short ramp[3][256]);

static cvar_t m_filter = {"m_filter", "0"};
int texture_mode = GL_NEAREST;

int texture_extension_number = 1;
float gldepthmin, gldepthmax;

cvar_t   gl_ztrick = {"gl_ztrick", "1"};

const char *gl_vendor;
const char *gl_renderer;
const char *gl_version;
const char *gl_extensions;
#endif

static qboolean mouse_avail;
static float   mouse_x, mouse_y;
static int mouse_oldbuttonstate = 0;

void    VID_SetPalette (unsigned char *palette)
{
#ifdef GLQUAKE
   byte   *pal;
   unsigned r,g,b;
   unsigned v;
   int     r1,g1,b1;
   int      j,k,l,m;
   unsigned short i;
   unsigned   *table;
   FILE *f;
   char s[255];
   float gamma;

   pal = palette;
   table = d_8to24table;
   for (i=0 ; i<256 ; i++)
   {
      r = pal[0];
      g = pal[1];
      b = pal[2];
      pal += 3;

      v = (255<<24) + (r<<0) + (g<<8) + (b<<16);
      *table++ = v;
   }
   d_8to24table[255] &= 0xffffff;

   for (i=0; i < (1<<15); i++) {
      r = ((i & 0x1F) << 3)+4;
      g = ((i & 0x03E0) >> 2)+4;
      b = ((i & 0x7C00) >> 7)+4;
      pal = (unsigned char *)d_8to24table;
      for (v=0,k=0,l=10000*10000; v<256; v++,pal+=4) {
         r1 = r-pal[0];
         g1 = g-pal[1];
         b1 = b-pal[2];
         j = (r1*r1)+(g1*g1)+(b1*b1);
         if (j<l) {
            k=v;
            l=j;
         }
      }
      d_15to8table[i]=k;
   }
#else
    int i;
    SDL_Color colors[256];

    for ( i=0; i<256; ++i )
    {
        colors[i].r = *palette++;
        colors[i].g = *palette++;
        colors[i].b = *palette++;
    }
    SDL_SetColors(screen, colors, 0, 256);
#endif
}

void    VID_ShiftPalette (unsigned char *palette)
{
#ifndef GLQUAKE
    VID_SetPalette(palette);
#endif
}

#ifdef GLQUAKE
void CheckMultiTextureExtensions(void)  {
    gl_mtexable = false;
}

void GL_Init (void) {
   gl_vendor = (const char*)glGetString (GL_VENDOR);
   printf("GL_VENDOR: %s\n", gl_vendor);
   gl_renderer = (const char*)glGetString (GL_RENDERER);
   printf("GL_RENDERER: %s\n", gl_renderer);
   gl_version = (const char*)glGetString (GL_VERSION);
   printf("GL_VERSION: %s\n", gl_version);
   gl_extensions = (const char*)glGetString (GL_EXTENSIONS);
   printf("GL_EXTENSIONS: %s\n", gl_extensions);

   fullsbardraw = true;

   CheckMultiTextureExtensions ();

   glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
   glClearColor (0,0,0,0);
   glCullFace(GL_FRONT);
   glEnable(GL_TEXTURE_2D);
   glEnable(GL_ALPHA_TEST);
   glAlphaFunc(GL_GREATER, 0.666);
   glPolygonOffset(0.05, 25);
   glPolygonMode (GL_FRONT_AND_BACK, GL_FILL);
   glShadeModel (GL_FLAT);
   glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
   glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
   glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
   glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
   glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
   glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
}

/*
=================
GL_BeginRendering
=================
*/
void GL_BeginRendering (int *x, int *y, int *width, int *height) {
   *x = *y = 0;
   *width = vid.width;
   *height = vid.height;
}


void GL_EndRendering (void) {
    SDL_GL_SwapBuffers();

    if (fullsbardraw)
       Sbar_Changed();
}

extern qboolean VID_Is8bit(void) {
    return is8bit;
}

void VID_Init8bitPalette(void)  {
}
#endif

#ifdef GLQUAKE
static void Check_Gamma (unsigned char *pal) {
   float   f, inf;
   unsigned char   palette[768];
   int      i;

   if (i = COM_CheckParm("-gamma"))
        {
      vid_gamma = Q_atof(com_argv[i+1]);
        }
   else
        {
      vid_gamma = 0.75f;
        }

   printf( "Gamma is %f\n", vid_gamma );

   for (i=0 ; i<768 ; i++)
   {
      f = pow ( (pal[i]+1)/256.0 , vid_gamma );
      inf = f*255 + 0.5;
      if (inf < 0)
         inf = 0;
      if (inf > 255)
         inf = 255;
      palette[i] = inf;
   }

   memcpy (pal, palette, sizeof(palette));
}
#endif

void    VID_Init (unsigned char *palette)
{
#ifdef GLQUAKE
    int pnum;
    Uint32 flags;
    char   gldir[MAX_OSPATH];

    // Create native window.
    printf( "VID_Init: Creating the window\n" );

    // Set up display mode (width and height)
    vid.width = 640;
    vid.height = 400;
    if ((pnum=COM_CheckParm("-winsize")))
    {
        if (pnum >= com_argc-2)
            Sys_Error("VID: -winsize <width> <height>\n");
        vid.width = Q_atoi(com_argv[pnum+1]);
        vid.height = Q_atoi(com_argv[pnum+2]);
        if (!vid.width || !vid.height)
            Sys_Error("VID: Bad window width/height\n");
    }

    // Set video width, height and flags
    flags = (SDL_OPENGL);
    if (COM_CheckParm ("-fullscreen")) {
        flags |= SDL_FULLSCREEN;
      vid.bpp = 16;
   } else
      vid.bpp = 8;

   if (!(screen = SDL_SetVideoMode(vid.width, vid.height, vid.bpp, flags)))
      Sys_Error("VID: Couldn't set video mode: %s\n", SDL_GetError());

    Cvar_RegisterVariable (&m_filter);
    Cvar_RegisterVariable (&gl_ztrick);

    vid.aspect = 1.0;
    vid.numpages = 1;
    vid.colormap = host_colormap;
    vid.fullbright = 256 - LittleLong (*((int *)vid.colormap + 2048));
    vid.rowbytes = vid.conrowbytes = vid.width;
    vid.recalc_refdef = true;
    min_vid_width = vid.width;

    printf( "VID_Init: GL_Init starting\n" );
    GL_Init();
    printf( "VID_Init: GL_Init finished\n" );

    SDL_WM_SetCaption("glquake","glquake");

    sprintf (gldir, "%s/glquake", com_gamedir);
    Sys_mkdir (gldir);
    Check_Gamma(palette);
    VID_SetPalette (palette);

    // Check for 3DFX Extensions and initialize them.
    VID_Init8bitPalette();
#else
    int pnum, chunk;
    byte *cache;
    int cachesize;
    Uint8 video_bpp;
    Uint16 video_w, video_h;
    Uint32 flags;

    // Load the SDL library
    if (SDL_Init(SDL_INIT_VIDEO|SDL_INIT_AUDIO|SDL_INIT_CDROM) < 0)
        Sys_Error("VID: Couldn't load SDL: %s", SDL_GetError());

    // Set up display mode (width and height)
    vid.width = BASEWIDTH;
    vid.height = BASEHEIGHT;
    vid.maxwarpwidth = WARP_WIDTH;
    vid.maxwarpheight = WARP_HEIGHT;
    if ((pnum=COM_CheckParm("-winsize")))
    {
        if (pnum >= com_argc-2)
            Sys_Error("VID: -winsize <width> <height>\n");
        vid.width = Q_atoi(com_argv[pnum+1]);
        vid.height = Q_atoi(com_argv[pnum+2]);
        if (!vid.width || !vid.height)
            Sys_Error("VID: Bad window width/height\n");
    }

    // Set video width, height and flags
    flags = (SDL_SWSURFACE|SDL_HWPALETTE);
    if ( COM_CheckParm ("-fullscreen") )
        flags |= SDL_FULLSCREEN;

    // Initialize display
    if (!(screen = SDL_SetVideoMode(vid.width, vid.height, 8, flags)))
        Sys_Error("VID: Couldn't set video mode: %s\n", SDL_GetError());

    VID_SetPalette(palette);

    SDL_WM_SetCaption("sdlquake","sdlquake");
    // now know everything we need to know about the buffer
    VGA_width = vid.conwidth = vid.width;
    VGA_height = vid.conheight = vid.height;
    vid.aspect = ((float)vid.height / (float)vid.width) * (320.0 / 240.0);
    vid.numpages = 1;
    vid.colormap = host_colormap;
    vid.fullbright = 256 - LittleLong (*((int *)vid.colormap + 2048));
    VGA_pagebase = vid.buffer = screen->pixels;
    VGA_rowbytes = vid.rowbytes = screen->pitch;
    vid.conbuffer = vid.buffer;
    vid.conrowbytes = vid.rowbytes;
    vid.direct = 0;
   
    // allocate z buffer and surface cache
    chunk = vid.width * vid.height * sizeof (*d_pzbuffer);
    cachesize = D_SurfaceCacheForRes (vid.width, vid.height);
    chunk += cachesize;
    d_pzbuffer = Hunk_HighAllocName(chunk, "video");
    if (d_pzbuffer == NULL)
        Sys_Error ("Not enough memory for video mode\n");

    // initialize the cache memory
        cache = (byte *) d_pzbuffer
                + vid.width * vid.height * sizeof (*d_pzbuffer);
    D_InitCaches (cache, cachesize);
#endif

    // initialize the mouse
    SDL_ShowCursor(0);
}

void    VID_Shutdown (void)
{
#ifdef GLQUAKE
   SDL_QuitSubSystem(SDL_INIT_VIDEO);
#else
    SDL_Quit();
#endif
#endif
}

#ifndef GLQUAKE
void    VID_Update (vrect_t *rects)
{
    SDL_Rect *sdlrects;
    int n, i;
    vrect_t *rect;

    // Two-pass system, since Quake doesn't do it the SDL way...

    // First, count the number of rectangles
    n = 0;
    for (rect = rects; rect; rect = rect->pnext)
        ++n;

    // Second, copy them to SDL rectangles and update
    if (!(sdlrects = (SDL_Rect *)alloca(n*sizeof(*sdlrects))))
        Sys_Error("Out of memory");
    i = 0;
    for (rect = rects; rect; rect = rect->pnext)
    {
        sdlrects[i].x = rect->x;
        sdlrects[i].y = rect->y;
        sdlrects[i].w = rect->width;
        sdlrects[i].h = rect->height;
        ++i;
    }

    SDL_UpdateRects(screen, n, sdlrects);
}
#endif

/*
================
D_BeginDirectRect
================
*/
void D_BeginDirectRect (int x, int y, byte *pbitmap, int width, int height)
{
#ifndef GLQUAKE
    Uint8 *offset;

    if (!screen) return;
    if ( x < 0 ) x = screen->w+x-1;
    offset = (Uint8 *)screen->pixels + y*screen->pitch + x;
    while ( height-- )
    {
        memcpy(offset, pbitmap, width);
        offset += screen->pitch;
        pbitmap += width;
    }
#endif
}


/*
================
D_EndDirectRect
================
*/
void D_EndDirectRect (int x, int y, int width, int height)
{
#ifndef GLQUAKE
    if (!screen) return;
    if (x < 0) x = screen->w+x-1;
    SDL_UpdateRect(screen, x, y, width, height);
#endif
}

#ifdef GLQUAKE
/*
================
VID_IsFullScreen
================
*/
qboolean VID_IsFullScreen(void) {
  return false;
}

static void windowed_mouse_f(struct cvar_s *var) {
}
#endif

/*
================
Sys_SendKeyEvents
================
*/

void Sys_SendKeyEvents(void)
{
    SDL_Event event;
    int sym, state;
     int modstate;

    while (SDL_PollEvent(&event))
    {
        switch (event.type) {
            case SDL_KEYDOWN:
            case SDL_KEYUP:
                sym = event.key.keysym.sym;
                state = event.key.state;
                modstate = SDL_GetModState();
                switch(sym)
                {
                   case SDLK_DELETE: sym = K_DEL; break;
                   case SDLK_BACKSPACE: sym = K_BACKSPACE; break;
                   case SDLK_F1: sym = K_F1; break;
                   case SDLK_F2: sym = K_F2; break;
                   case SDLK_F3: sym = K_F3; break;
                   case SDLK_F4: sym = K_F4; break;
                   case SDLK_F5: sym = K_F5; break;
                   case SDLK_F6: sym = K_F6; break;
                   case SDLK_F7: sym = K_F7; break;
                   case SDLK_F8: sym = K_F8; break;
                   case SDLK_F9: sym = K_F9; break;
                   case SDLK_F10: sym = K_F10; break;
                   case SDLK_F11: sym = K_F11; break;
                   case SDLK_F12: sym = K_F12; break;
                   case SDLK_BREAK:
                   case SDLK_PAUSE: sym = K_PAUSE; break;
                   case SDLK_UP: sym = K_UPARROW; break;
                   case SDLK_DOWN: sym = K_DOWNARROW; break;
                   case SDLK_RIGHT: sym = K_RIGHTARROW; break;
                   case SDLK_LEFT: sym = K_LEFTARROW; break;
                   case SDLK_INSERT: sym = K_INS; break;
                   case SDLK_HOME: sym = K_HOME; break;
                   case SDLK_END: sym = K_END; break;
                   case SDLK_PAGEUP: sym = K_PGUP; break;
                   case SDLK_PAGEDOWN: sym = K_PGDN; break;
                   case SDLK_RSHIFT:
                   case SDLK_LSHIFT: sym = K_SHIFT; break;
                   case SDLK_RCTRL:
                   case SDLK_LCTRL: sym = K_CTRL; break;
                   case SDLK_RALT:
                   case SDLK_LALT: sym = K_ALT; break;
                   case SDLK_KP0:
                       if(modstate & KMOD_NUM) sym = K_INS;
                       else sym = SDLK_0;
                       break;
                   case SDLK_KP1:
                       if(modstate & KMOD_NUM) sym = K_END;
                       else sym = SDLK_1;
                       break;
                   case SDLK_KP2:
                       if(modstate & KMOD_NUM) sym = K_DOWNARROW;
                       else sym = SDLK_2;
                       break;
                   case SDLK_KP3:
                       if(modstate & KMOD_NUM) sym = K_PGDN;
                       else sym = SDLK_3;
                       break;
                   case SDLK_KP4:
                       if(modstate & KMOD_NUM) sym = K_LEFTARROW;
                       else sym = SDLK_4;
                       break;
                   case SDLK_KP5: sym = SDLK_5; break;
                   case SDLK_KP6:
                       if(modstate & KMOD_NUM) sym = K_RIGHTARROW;
                       else sym = SDLK_6;
                       break;
                   case SDLK_KP7:
                       if(modstate & KMOD_NUM) sym = K_HOME;
                       else sym = SDLK_7;
                       break;
                   case SDLK_KP8:
                       if(modstate & KMOD_NUM) sym = K_UPARROW;
                       else sym = SDLK_8;
                       break;
                   case SDLK_KP9:
                       if(modstate & KMOD_NUM) sym = K_PGUP;
                       else sym = SDLK_9;
                       break;
                   case SDLK_KP_PERIOD:
                       if(modstate & KMOD_NUM) sym = K_DEL;
                       else sym = SDLK_PERIOD;
                       break;
                   case SDLK_KP_DIVIDE: sym = SDLK_SLASH; break;
                   case SDLK_KP_MULTIPLY: sym = SDLK_ASTERISK; break;
                   case SDLK_KP_MINUS: sym = SDLK_MINUS; break;
                   case SDLK_KP_PLUS: sym = SDLK_PLUS; break;
                   case SDLK_KP_ENTER: sym = SDLK_RETURN; break;
                   case SDLK_KP_EQUALS: sym = SDLK_EQUALS; break;
                }
                // If we're not directly handled and still above 255
                // just force it to 0
                if(sym > 255) sym = 0;
                Key_Event(sym, state);
                break;

            case SDL_MOUSEMOTION:
                if ( (event.motion.x != (vid.width/2)) ||
                     (event.motion.y != (vid.height/2)) ) {
                    mouse_x = event.motion.xrel*10;
                    mouse_y = event.motion.yrel*10;
                    if ( (event.motion.x < ((vid.width/2)-(vid.width/4))) ||
                         (event.motion.x > ((vid.width/2)+(vid.width/4))) ||
                         (event.motion.y < ((vid.height/2)-(vid.height/4))) ||
                         (event.motion.y > ((vid.height/2)+(vid.height/4))) ) {
                        SDL_WarpMouse(vid.width/2, vid.height/2);
                    }
                }
                break;

            case SDL_QUIT:
                CL_Disconnect ();
                Host_ShutdownServer(false);       
                Sys_Quit ();
                break;
            default:
                break;
        }
    }
}

void IN_Init (void)
{
    if ( COM_CheckParm ("-nomouse") )
        return;
    mouse_x = mouse_y = 0.0;
    mouse_avail = 1;
}

void IN_Shutdown (void)
{
    mouse_avail = 0;
}

void IN_Commands (void)
{
    int i;
    int mouse_buttonstate;
   
    if (!mouse_avail) return;
   
    i = SDL_GetMouseState(NULL, NULL);
    /* Quake swaps the second and third buttons */
    mouse_buttonstate = (i & ~0x06) | ((i & 0x02)<<1) | ((i & 0x04)>>1);
    for (i=0 ; i<3 ; i++) {
        if ( (mouse_buttonstate & (1<<i)) && !(mouse_oldbuttonstate & (1<<i)) )
            Key_Event (K_MOUSE1 + i, true);

        if ( !(mouse_buttonstate & (1<<i)) && (mouse_oldbuttonstate & (1<<i)) )
            Key_Event (K_MOUSE1 + i, false);
    }
    mouse_oldbuttonstate = mouse_buttonstate;
}

void IN_Move (usercmd_t *cmd)
{
    if (!mouse_avail)
        return;
   
    mouse_x *= sensitivity.value;
    mouse_y *= sensitivity.value;
   
    if ( (in_strafe.state & 1) || (lookstrafe.value && (in_mlook.state & 1) ))
        cmd->sidemove += m_side.value * mouse_x;
    else
        cl.viewangles[YAW] -= m_yaw.value * mouse_x;

   if (in_mlook.state & 1)
      V_StopPitchDrift ();

   if ( (in_mlook.state & 1) && !(in_strafe.state & 1)) {
      cl.viewangles[PITCH] += m_pitch.value * mouse_y;
      if (cl.viewangles[PITCH] > 80)
         cl.viewangles[PITCH] = 80;
      if (cl.viewangles[PITCH] < -70)
         cl.viewangles[PITCH] = -70;
   } else {
      if ((in_strafe.state & 1) && noclip_anglehack)
         cmd->upmove -= m_forward.value * mouse_y;
      else
         cmd->forwardmove -= m_forward.value * mouse_y;
   }

    mouse_x = mouse_y = 0.0;
}


and here the code for vid.h add in "} viddef_t;" add after
Code: Select all
unsigned      height;
this code:
Code: Select all
int            bpp;
I am sorry for my English...
User avatar
Rikku2000
 
Posts: 49
Joined: Wed Oct 20, 2010 6:33 pm
Location: Germany

Return to OpenGL Programming

Who is online

Users browsing this forum: No registered users and 1 guest