jprdonnelly/Descent3
1
0
Fork 0
mirror of https://github.com/kevinbentley/Descent3.git synced 2026-04-04 11:00:04 -04:00
Code Issues Packages Projects Releases Wiki Activity
Files
df209742fcda59d466b849eff9ee0e7b908d7d40
Descent3/renderer/HardwareOpenGL.cpp
Kevin Bentley df209742fc Initial import
2024-04-15 21:43:29 -06:00

3635 lines
85 KiB
C++
Raw Blame History

#include "RendererConfig.h"
#ifndef USE_SOFTWARE_TNL
#include "byteswap.h"
#if defined(WIN32)
# include <windows.h>
# include "ddraw.h"
#elif defined(__LINUX__)
# include "linux/linux_fix.h"
# include "linux/dyna_xext.h"
# include "lnxscreenmode.h"
# define min(a,b) (((a)<(b))?(a):(b))
# define max(a,b) (((a)>(b))?(a):(b))
#else
#endif
#include "DDAccess.h"
#include "pstypes.h"
#include "pserror.h"
#include "mono.h"
#include "3d.h"
#include "renderer.h"
#include "ddvid.h"
#include "ddio.h"
#include "application.h"
#include "bitmap.h"
#include "lightmap.h"
#include "rend_opengl.h"
#include "grdefs.h"
#include "mem.h"
#include "rtperformance.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <GL/gl.h>
#include <GL/glu.h>
#include "HardwareInternal.h"
#include "../Descent3/args.h"
#define DECLARE_OPENGL
#include "dyna_gl.h"
#if defined(WIN32)
#include "win/arb_extensions.h"
#endif
int FindArg(char *);
void rend_SetLightingState(light_state state);
#define CHANGE_RESOLUTION_IN_FULLSCREEN
// The font characteristics
static float rend_FontRed[4],rend_FontBlue[4],rend_FontGreen[4],rend_FontAlpha[4];
char Renderer_error_message[256]="Generic renderer error";
// The following values are referenced by the game code, but only
// UseMultitexture is actually referenced and used in this code - and
// even that can probably go away and we just assume there is more than
// one texture unit (which, since I believe OpenGL 1.2 is a requirement)
bool UseHardware = true;
bool NoLightmaps = false;
bool StateLimited = false;
bool UseMultitexture = false;
bool UseWBuffer = false;
// General renderer states
int Overlay_map = -1;
int Bump_map = 0;
int Bumpmap_ready = 0;
ubyte Overlay_type = OT_NONE;
float Z_bias = 0.0f;
ubyte Renderer_close_flag = 0;
ubyte Renderer_initted = 0;
renderer_type Renderer_type = RENDERER_OPENGL;
int WindowGL = 0;
extern matrix Unscaled_matrix;
extern vector View_position;
#ifndef GL_UNSIGNED_SHORT_5_5_5_1
#define GL_UNSIGNED_SHORT_5_5_5_1 0x8034
#endif
#ifndef GL_UNSIGNED_SHORT_4_4_4_4
#define GL_UNSIGNED_SHORT_4_4_4_4 0x8033
#endif
#define CHECK_ERROR(x)
#if defined(WIN32)
// Moved from DDGR library
static HWND hOpenGLWnd = NULL;
static HDC hOpenGLDC = NULL;
HGLRC ResourceContext;
static WORD Saved_gamma_values[256*3];
#elif defined(__LINUX__)
char loadedLibrary[_MAX_PATH];
#else
#endif
#define GET_WRAP_STATE(x) (x>>4)
#define GET_FILTER_STATE(x) (x & 0x0f)
#define SET_WRAP_STATE(x,s) {x&=0x0F; x|=(s<<4);}
#define SET_FILTER_STATE(x,s) {x&=0xF0; x|=(s);}
// OpenGL Stuff
static int OpenGL_window_initted=0;
static int OpenGL_polys_drawn=0;
static int OpenGL_verts_processed=0;
static int OpenGL_uploads=0;
static int OpenGL_sets_this_frame[10];
static int OpenGL_packed_pixels=0;
static int Cur_texture_object_num=1;
static int OpenGL_cache_initted=0;
static int OpenGL_last_bound[2];
static int Last_texel_unit_set=-1;
static int OpenGL_last_frame_polys_drawn=0;
static int OpenGL_last_frame_verts_processed=0;
static int OpenGL_last_uploaded=0;
static float OpenGL_Alpha_factor=1.0f;
#ifndef RELEASE
// This is for the Microsoft OpenGL reference driver
// Setting this will turn off bilinear filtering and zbuffer so we can get decent
// framerates to discern driver problems
static ubyte Fast_test_render=0;
#endif
#if defined(_USE_OGL_ACTIVE_TEXTURES)
PFNGLACTIVETEXTUREARBPROC oglActiveTextureARB = NULL;
PFNGLCLIENTACTIVETEXTUREARBPROC oglClientActiveTextureARB = NULL;
PFNGLMULTITEXCOORD4FARBPROC oglMultiTexCoord4f = NULL;
#endif
ushort *OpenGL_bitmap_remap = NULL;
ushort *OpenGL_lightmap_remap = NULL;
ubyte *OpenGL_bitmap_states = NULL;
ubyte *OpenGL_lightmap_states = NULL;
uint *opengl_Upload_data = NULL;
uint *opengl_Translate_table = NULL;
uint *opengl_4444_translate_table = NULL;
ushort *opengl_packed_Upload_data = NULL;
ushort *opengl_packed_Translate_table = NULL;
ushort *opengl_packed_4444_translate_table = NULL;
rendering_state OpenGL_state;
static float Alpha_multiplier = 1.0f;
renderer_preferred_state OpenGL_preferred_state={0,1,1.5};
// These structs are for drawing with OpenGL vertex arrays
// Useful for fast indexing
typedef struct
{
float r,g,b,a;
} color_array;
typedef struct
{
float s,t,r,w;
} tex_array;
vector GL_verts[100];
color_array GL_colors[100];
tex_array GL_tex_coords[100];
tex_array GL_tex_coords2[100];
bool OpenGL_multitexture_state=false;
module *OpenGLDLLHandle=NULL;
int Already_loaded=0;
bool opengl_Blending_on=0;
static oeApplication *ParentApplication = NULL;
#if 0
int checkForGLErrors( char *file, int line )
{
/*
int errors = 0 ;
int counter = 0 ;
static int errcnt = 0;
if(!dglGetError)
return 0;
while ( counter < 1000 )
{
GLenum x = dglGetError() ;
if ( x == GL_NO_ERROR )
return errors ;
printf( "%s:%d OpenGL error: %s [%08x]\n", file,line, gluErrorString ( x ), errcnt++ ) ;
errors++ ;
counter++ ;
}
*/
char *sdlp = SDL_GetError();
if(sdlp && *sdlp)
mprintf((0,"SDL: %s",sdlp));
return 1;
}
#endif
//Sets up multi-texturing using ARB extensions
void opengl_GetDLLFunctions(void)
{
#if defined(WIN32)
oglActiveTextureARB=(PFNGLACTIVETEXTUREARBPROC)dwglGetProcAddress( "glActiveTextureARB" );
if (!oglActiveTextureARB)
goto dll_error;
oglClientActiveTextureARB=(PFNGLCLIENTACTIVETEXTUREARBPROC)dwglGetProcAddress( "glClientActiveTextureARB" );
if (!oglClientActiveTextureARB)
goto dll_error;
oglMultiTexCoord4f=(PFNGLMULTITEXCOORD4FARBPROC)dwglGetProcAddress( "glMultiTexCoord4f" );
if (!oglMultiTexCoord4f)
goto dll_error;
#else
#define mod_GetSymbol(x, funcStr, y) __SDL_mod_GetSymbol(funcStr)
oglActiveTextureARB = (PFNGLACTIVETEXTUREARBPROC) mod_GetSymbol(OpenGLDLLHandle,"glActiveTextureARB",255);
oglClientActiveTextureARB = (PFNGLCLIENTACTIVETEXTUREARBPROC) mod_GetSymbol(OpenGLDLLHandle,"glClientActiveTextureARB",255);
oglMultiTexCoord4f = (PFNGLMULTITEXCOORD4FARBPROC) mod_GetSymbol(OpenGLDLLHandle,"glMultiTexCoord4f",255);
if( !oglMultiTexCoord4f )
{
oglMultiTexCoord4f = (PFNGLMULTITEXCOORD4FARBPROC) mod_GetSymbol(OpenGLDLLHandle,"glMultiTexCoord4fARB",255);
}
if (oglActiveTextureARB == NULL || oglClientActiveTextureARB == NULL || oglMultiTexCoord4f == NULL)
{
goto dll_error;
}
#undef mod_GetSymbol
#endif
UseMultitexture = true;
return;
dll_error:
oglActiveTextureARB = NULL;
oglClientActiveTextureARB = NULL;
oglMultiTexCoord4f = NULL;
UseMultitexture = false;
}
// returns true if the passed in extension name is supported
bool opengl_CheckExtension( char *extName )
{
char *p = (char *)dglGetString(GL_EXTENSIONS);
int extNameLen = strlen(extName);
char *end = p + strlen(p);
while( p < end )
{
int n = strcspn(p, " ");
if ((extNameLen == n) && (strncmp(extName, p, n) == 0))
return true;
p += (n + 1);
}
return false;
}
// Gets some specific information about this particular flavor of opengl
void opengl_GetInformation ()
{
mprintf ((0,"OpenGL Vendor: %s\n",dglGetString(GL_VENDOR)));
mprintf ((0,"OpenGL Renderer: %s\n",dglGetString(GL_RENDERER)));
mprintf ((0,"OpenGL Version: %s\n",dglGetString(GL_VERSION)));
mprintf ((0,"OpenGL Extensions: %s\n",dglGetString (GL_EXTENSIONS)));
/*
#ifndef RELEASE
// If this is the microsoft driver, then make stuff go faster
const ubyte *renderer=dglGetString(GL_RENDERER);
if (!(strnicmp ((const char *)renderer,"GDI",3)))
Fast_test_render=1;
else
Fast_test_render=0;
#endif
*/
}
int opengl_MakeTextureObject (int tn)
{
int num=Cur_texture_object_num;
Cur_texture_object_num++;
if (UseMultitexture && Last_texel_unit_set!=tn)
{
#if (defined(_USE_OGL_ACTIVE_TEXTURES))
oglActiveTextureARB (GL_TEXTURE0_ARB+tn);
Last_texel_unit_set=tn;
#endif
}
dglBindTexture (GL_TEXTURE_2D,num);
dglPixelStorei (GL_UNPACK_ALIGNMENT,2);
dglTexParameteri (GL_TEXTURE_2D,GL_TEXTURE_WRAP_S,GL_REPEAT);
dglTexParameteri (GL_TEXTURE_2D,GL_TEXTURE_WRAP_T,GL_REPEAT);
dglTexParameteri (GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_NEAREST);
dglTexParameteri (GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_NEAREST);
//glTexEnvf (GL_TEXTURE_ENV,GL_TEXTURE_ENV_MODE,GL_MODULATE);
CHECK_ERROR(2)
return num;
}
int opengl_InitCache(void)
{
OpenGL_bitmap_remap=(ushort *)mem_malloc (MAX_BITMAPS*2);
ASSERT (OpenGL_bitmap_remap);
OpenGL_lightmap_remap=(ushort *)mem_malloc (MAX_LIGHTMAPS*2);
ASSERT (OpenGL_lightmap_remap);
OpenGL_bitmap_states=(ubyte *)mem_malloc (MAX_BITMAPS);
ASSERT (OpenGL_bitmap_states);
OpenGL_lightmap_states=(ubyte *)mem_malloc (MAX_LIGHTMAPS);
ASSERT (OpenGL_lightmap_states);
Cur_texture_object_num=1;
// Setup textures and cacheing
int i;
for (i=0;i<MAX_BITMAPS;i++)
{
OpenGL_bitmap_remap[i]=65535;
OpenGL_bitmap_states[i]=255;
GameBitmaps[i].flags|=BF_CHANGED|BF_BRAND_NEW;
}
for (i=0;i<MAX_LIGHTMAPS;i++)
{
OpenGL_lightmap_remap[i]=65535;
OpenGL_lightmap_states[i]=255;
GameLightmaps[i].flags|=LF_CHANGED|LF_BRAND_NEW;
}
dglTexEnvf (GL_TEXTURE_ENV,GL_TEXTURE_ENV_MODE,GL_MODULATE);
if (UseMultitexture)
{
#if (defined(_USE_OGL_ACTIVE_TEXTURES))
oglActiveTextureARB (GL_TEXTURE0_ARB+1);
dglTexEnvf (GL_TEXTURE_ENV,GL_TEXTURE_ENV_MODE,GL_MODULATE);
oglActiveTextureARB (GL_TEXTURE0_ARB+0);
#endif
}
CHECK_ERROR(3)
OpenGL_cache_initted=1;
return 1;
}
// Sets default states for our renderer
void opengl_SetDefaults()
{
mprintf ((0,"Setting states\n"));
OpenGL_state.cur_color=0x00FFFFFF;
OpenGL_state.cur_bilinear_state=-1;
OpenGL_state.cur_zbuffer_state=-1;
OpenGL_state.cur_texture_quality=-1;
OpenGL_state.cur_light_state=LS_GOURAUD;
OpenGL_state.cur_color_model=CM_MONO;
OpenGL_state.cur_bilinear_state=-1;
OpenGL_state.cur_alpha_type=AT_TEXTURE;
// Enable some states
dglAlphaFunc (GL_GREATER,0);
dglEnable (GL_ALPHA_TEST);
dglEnable (GL_BLEND);
dglEnable (GL_DITHER);
opengl_Blending_on=true;
#ifndef RELEASE
if (Fast_test_render)
{
dglDisable (GL_DITHER);
}
#endif
rend_SetAlphaType(AT_ALWAYS);
rend_SetAlphaValue(255);
rend_SetFiltering(1);
rend_SetLightingState(LS_NONE);
rend_SetTextureType(TT_FLAT);
rend_SetColorModel(CM_RGB);
rend_SetZBufferState(1);
rend_SetZValues(0,3000);
opengl_SetGammaValue (OpenGL_preferred_state.gamma);
OpenGL_last_bound[0]=9999999;
OpenGL_last_bound[1]=9999999;
Last_texel_unit_set=-1;
OpenGL_multitexture_state=false;
dglEnableClientState (GL_VERTEX_ARRAY);
dglEnableClientState (GL_COLOR_ARRAY);
dglEnableClientState (GL_TEXTURE_COORD_ARRAY);
dglVertexPointer (3,GL_FLOAT,0,GL_verts);
dglColorPointer (4,GL_FLOAT,0,GL_colors);
dglTexCoordPointer (4,GL_FLOAT,0,GL_tex_coords);
dglHint (GL_PERSPECTIVE_CORRECTION_HINT,GL_NICEST);
dglHint (GL_FOG_HINT,GL_NICEST);
dglEnable (GL_SCISSOR_TEST);
dglScissor (0,0,OpenGL_state.screen_width,OpenGL_state.screen_height);
dglDisable (GL_SCISSOR_TEST);
dglDepthRange(0.0f,1.0f);
if (UseMultitexture)
{
#if (defined(_USE_OGL_ACTIVE_TEXTURES))
oglActiveTextureARB (GL_TEXTURE0_ARB+1);
oglClientActiveTextureARB (GL_TEXTURE0_ARB+1);
dglEnableClientState (GL_TEXTURE_COORD_ARRAY);
dglTexCoordPointer (4,GL_FLOAT,0,GL_tex_coords2);
dglHint (GL_PERSPECTIVE_CORRECTION_HINT,GL_NICEST);
dglHint (GL_FOG_HINT,GL_NICEST);
oglClientActiveTextureARB (GL_TEXTURE0_ARB+0);
dglDisable (GL_TEXTURE_2D);
dglAlphaFunc (GL_GREATER,0);
dglEnable (GL_ALPHA_TEST);
dglEnable (GL_BLEND);
dglEnable (GL_DITHER);
dglBlendFunc (GL_DST_COLOR,GL_ZERO);
oglActiveTextureARB (GL_TEXTURE0_ARB+0);
#endif
}
}
#if defined(WIN32)
// Check for OpenGL support,
int opengl_Setup(HDC glhdc)
{
if (!Already_loaded)
{
if (!(OpenGLDLLHandle=LoadOpenGLDLL("opengl32.dll")))
{
rend_SetErrorMessage("Failed to load opengl dll!\n");
Int3();
return 0;
}
}
// Finds an acceptable pixel format to render to
PIXELFORMATDESCRIPTOR pfd, pfd_copy;
int pf;
memset(&pfd, 0, sizeof(pfd));
pfd.nSize = sizeof(pfd);
pfd.nVersion = 1;
pfd.dwFlags = PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER | PFD_GENERIC_ACCELERATED;
pfd.iPixelType = PFD_TYPE_RGBA;
/*if (!WindowGL)
{
if (OpenGL_preferred_state.bit_depth==32)
{
pfd.cColorBits = 32;
pfd.cDepthBits = 32;
}
else
{
pfd.cColorBits = OpenGL_preferred_state.bit_depth;
pfd.cDepthBits =OpenGL_preferred_state.bit_depth;
}
pfd.cColorBits = 16;
pfd.cDepthBits =16;
}
else
{
pfd.cColorBits = 16;
pfd.cDepthBits =16;
}*/
// Find the user's "best match" PFD
pf = ChoosePixelFormat(glhdc, &pfd);
if (pf == 0)
{
Int3();
//FreeLibrary(opengl_dll_handle);
return NULL;
}
mprintf ((0,"Choose pixel format successful!\n"));
// Try and set the new PFD
if (SetPixelFormat(glhdc, pf, &pfd) == FALSE)
{
DWORD ret=GetLastError();
Int3();
//FreeLibrary(opengl_dll_handle);
return NULL;
}
mprintf ((0,"SetPixelFormat successful!\n"));
// Get a copy of the newly set PFD
if(DescribePixelFormat(glhdc, pf, sizeof(PIXELFORMATDESCRIPTOR), &pfd_copy)==0)
{
Int3();
//FreeLibrary(opengl_dll_handle);
return NULL;
}
// Check the returned PFD to see if it is hardware accelerated
if((pfd_copy.dwFlags & PFD_GENERIC_ACCELERATED)==0 && (pfd_copy.dwFlags & PFD_GENERIC_FORMAT)!=0)
{
Int3();
//FreeLibrary(opengl_dll_handle);
return NULL;
}
// Create an OpenGL context, and make it the current context
ResourceContext = dwglCreateContext((HDC)glhdc);
if(ResourceContext==NULL) {
DWORD ret=GetLastError();
//FreeLibrary(opengl_dll_handle);
Int3();
return NULL;
}
ASSERT (ResourceContext!=NULL);
mprintf ((0,"Making context current\n"));
dwglMakeCurrent((HDC)glhdc, ResourceContext);
Already_loaded=1;
return 1;
}
#elif defined(__LINUX__)
#ifdef __CHECK_FOR_TOO_SLOW_RENDERING__
static long minimumAcceptableRender = -1;
static Uint32 lastSwapTicks = 0;
static int tooSlowCount = 0;
static int tooSlowChecksLeft = 0;
void setMinimumAcceptableRenderTime(int ms)
{
if (nofpscheck)
return;
minimumAcceptableRender = ms;
lastSwapTicks = SDL_GetTicks();
tooSlowCount = 0;
tooSlowChecksLeft = 15; // check 15 frames.
}
#endif
extern bool linux_permit_gamma;
extern renderer_preferred_state Render_preferred_state;
extern bool ddio_mouseGrabbed;
int d3SDLEventFilter(const SDL_Event *event);
int opengl_Setup(oeApplication *app,int *width,int *height)
{
// rcg11192000 don't check for FPS.
#ifdef __CHECK_FOR_TOO_SLOW_RENDERING__
nofpscheck = (FindArgChar("-nofpscheck", 'H') != 0);
//rcg01252000 reset these, so they don't barf if we change
// video modes for a movie or whatnot in the middle of
// checking rendering speed...
minimumAcceptableRender = -1;
lastSwapTicks = 0;
tooSlowCount = 0;
tooSlowChecksLeft = 0;
#endif
// rcg09182000 don't need to quitsubsystem anymore...
// SDL_QuitSubSystem(SDL_INIT_VIDEO); // here goes nothing...
// Already_loaded = false;
SDL_ClearError();
int rc = SDL_Init(SDL_INIT_VIDEO);
if (rc != 0)
{
char buffer[512];
snprintf(buffer, sizeof(buffer),
"SDL_GetError() reports \"%s\".\n", SDL_GetError());
fprintf(stderr, "SDL: SDL_Init() failed! rc == (%d).\n", rc);
fprintf(stderr, "%s", buffer);
rend_SetErrorMessage(buffer);
return(0);
} // if
SDL_SetEventFilter(d3SDLEventFilter);
bool fullscreen = false;
char *env = getenv("MESA_GLX_FX");
if ((!env) || (*env=='f')) // Full screen Mesa mode !!! needs more.
{
fullscreen = true;
}
if (FindArgChar("-fullscreen", 'f'))
{
fullscreen = true;
}
else if (FindArgChar("-windowed", 'w'))
{
fullscreen = false;
}
if (env == NULL)
{
putenv((char*)(fullscreen ? "MESA_GLX_FX=f" : "MESA_GLX_FX=w"));
}
putenv("FX_GLIDE_NO_SPLASH=1");
if (!Already_loaded)
{
#define MAX_ARGS 30
#define MAX_CHARS_PER_ARG 100
extern char GameArgs[MAX_ARGS][MAX_CHARS_PER_ARG];
char gl_library[256];
int arg;
arg = FindArgChar("-gllibrary", 'g');
if(arg!=0)
{
strcpy(gl_library,GameArgs[arg+1]);
}
else
{
#if defined(MACOSX)
strcpy(gl_library,"/System/Library/Frameworks/OpenGL.framework/Versions/A/Libraries/libGL.dylib");
#else
strcpy(gl_library,"libGL.so");
#endif
}
mprintf((0, "OpenGL: Attempting to use \"%s\" for OpenGL\n", gl_library));
putenv("MESA_FX_NO_SIGNALS=ihatesegfaults");
// ryan's adds. 04/18/2000...SDL stuff on 04/25/2000
bool success = true;
OpenGLDLLHandle=LoadOpenGLDLL(gl_library);
if (!(OpenGLDLLHandle))
{
// rcg07072000 last ditch effort...
OpenGLDLLHandle=LoadOpenGLDLL("libGL.so.1");
if (!(OpenGLDLLHandle))
{
success = false;
}
} // if
if (success == false)
{
char buffer[512];
sprintf(buffer,"Failed to load library [%s].\n",gl_library);
fprintf(stderr,"%s",buffer);
rend_SetErrorMessage(buffer);
return 0;
} // if
}
#ifdef __PERMIT_GL_LOGGING
if (FindArg("-gllogging"))
{
printf("\n"
"************************************************************\n"
"************************************************************\n"
"************************************************************\n"
"************************************************************\n"
"************************************************************\n"
"******** GL LOGGING ENABLED. ***************************\n"
"************************************************************\n"
"************************************************************\n"
"************************************************************\n"
"************************************************************\n"
"************************************************************\n"
"\n");
DGL_EnableLogging(1);
__glLog = true;
} // if
#endif
SDL_GL_SetAttribute( SDL_GL_RED_SIZE, 5 );
SDL_GL_SetAttribute( SDL_GL_GREEN_SIZE, 5 );
SDL_GL_SetAttribute( SDL_GL_BLUE_SIZE, 5 );
SDL_GL_SetAttribute( SDL_GL_DEPTH_SIZE, 16 );
SDL_GL_SetAttribute( SDL_GL_DOUBLEBUFFER, 1 );
int flags = SDL_OPENGL;
if( fullscreen )
{
flags |= SDL_FULLSCREEN;
}
if( !FindArg("-nomousecap") )
{
// ShowCursor(0) and input grabbing need to be done before setting
// the video mode, or the Voodoo 3 gets a hardware cursor stuck
// on the screen.
SDL_ShowCursor( 0 );
SDL_WM_GrabInput(SDL_GRAB_ON);
}
// Should we shoot for 32-bpp if available? !!!
SDL_Surface *surface = SDL_SetVideoMode( *width, *height, 32, flags );
mprintf((0, "OpenGL: SDL GL surface is %sNULL.", (surface == NULL) ? "" : "NOT "));
if (ddio_mouseGrabbed == false)
{
SDL_WM_GrabInput(SDL_GRAB_OFF);
}
SDL_WM_SetCaption( "Descent 3", "Descent3" );
//rcg09182000 gamma fun.
//rcg01112000 --nogamma fun.
if (FindArgChar("-nogamma", 'M'))
{
linux_permit_gamma = false;
}
else
{
float f = Render_preferred_state.gamma;
bool gammarc = SDL_SetGamma(f, f, f);
linux_permit_gamma = (gammarc == 0);
} // else
if (ParentApplication)
{
reinterpret_cast<oeLnxApplication*>(ParentApplication)->set_sizepos(0,0,*width,*height);
SDL_FillRect(SDL_GetVideoSurface(),NULL,SDL_MapRGB(SDL_GetVideoSurface()->format,255,0,0));
}
Already_loaded = 1;
return 1;
}
#endif
// Sets up our OpenGL rendering context
// Returns 1 if ok, 0 if something bad
int opengl_Init (oeApplication *app,renderer_preferred_state *pref_state)
{
int width,height;
int retval=1;
int i;
mprintf ((0,"Setting up opengl mode!\n"));
if (pref_state)
{
OpenGL_preferred_state=*pref_state;
}
if( app != NULL )
{
ParentApplication = app;
}
int windowX = 0, windowY = 0;
#if defined(WIN32)
/***********************************************************
* WINDOWS OPENGL
***********************************************************
*/
static HWnd hwnd = NULL;
if( ParentApplication != NULL )
{
hwnd = static_cast<HWnd>( reinterpret_cast<oeWin32Application*>(ParentApplication)->m_hWnd );
}
if (!WindowGL)
{
// First set our display mode
// Create direct draw surface
DEVMODE devmode;
devmode.dmSize=sizeof(devmode);
devmode.dmBitsPerPel=16;
//devmode.dmBitsPerPel=OpenGL_preferred_state.bit_depth;
devmode.dmPelsWidth=OpenGL_preferred_state.width;
devmode.dmPelsHeight=OpenGL_preferred_state.height;
devmode.dmFields=DM_BITSPERPEL|DM_PELSWIDTH|DM_PELSHEIGHT;
#ifdef CHANGE_RESOLUTION_IN_FULLSCREEN
int retval = ChangeDisplaySettings(&devmode,0);
#else
int retval = DISP_CHANGE_SUCCESSFUL;
#endif
if (retval!=DISP_CHANGE_SUCCESSFUL)
{
mprintf ((0,"Display mode change failed (err=%d), trying default!\n",retval));
retval=-1;
devmode.dmBitsPerPel=16;
devmode.dmPelsWidth=640;
devmode.dmPelsHeight=480;
devmode.dmFields=DM_BITSPERPEL|DM_PELSWIDTH|DM_PELSHEIGHT;
retval=ChangeDisplaySettings(&devmode,0);
if (retval!=DISP_CHANGE_SUCCESSFUL)
{
mprintf ((0,"OpenGL_INIT:Change display setting failed failed!\n"));
rend_SetErrorMessage ("OGL: ChangeDisplaySettings failed. Make sure your desktop is set to 16bit mode!");
ChangeDisplaySettings(NULL,0);
opengl_Close();
return 0;
}
else
{
OpenGL_preferred_state.bit_depth=16;
OpenGL_preferred_state.width=640;
OpenGL_preferred_state.height=480;
}
}
else
{
mprintf ((0,"Setdisplaymode to %d x %d (%d bits) is successful!\n",OpenGL_preferred_state.width,OpenGL_preferred_state.height,OpenGL_preferred_state.bit_depth));
}
}
memset (&OpenGL_state,0,sizeof(rendering_state));
// These values are set here - samir
if (app!=NULL)
{
hOpenGLWnd = (HWND)((oeWin32Application *)app)->m_hWnd;
}
hOpenGLDC = GetDC(hOpenGLWnd);
if (WindowGL)
{
RECT rect;
POINT topLeft;
GetClientRect( (HWND)hOpenGLWnd, &rect );
topLeft.x = rect.left;
topLeft.y = rect.top;
ClientToScreen( (HWND)hOpenGLWnd, &topLeft );
width = rect.right - rect.left + 1;
height = rect.bottom - rect.top + 1;
windowX = topLeft.x;
windowY = topLeft.y;
}
else
{
SetWindowPos(hOpenGLWnd, HWND_TOPMOST, 0, 0, OpenGL_preferred_state.width,OpenGL_preferred_state.height, SWP_FRAMECHANGED);
width=OpenGL_preferred_state.width;
height=OpenGL_preferred_state.height;
RECT rect;
GetWindowRect ((HWND)hOpenGLWnd,&rect);
mprintf ((0,"rect=%d %d %d %d\n",rect.top,rect.right,rect.bottom,rect.left));
}
OpenGL_state.screen_width=width;
OpenGL_state.screen_height=height;
if (!opengl_Setup(hOpenGLDC))
{
opengl_Close();
return 0;
}
// Save gamma values for later
GetDeviceGammaRamp(hOpenGLDC,(LPVOID)Saved_gamma_values);
#elif defined(__LINUX__)
/***********************************************************
* LINUX OPENGL
***********************************************************
*/
// Setup OpenGL_state.screen_width & OpenGL_state.screen_height & width & height
width = OpenGL_preferred_state.width;
height = OpenGL_preferred_state.height;
if(!opengl_Setup(app,&width,&height))
{
opengl_Close();
return 0;
}
memset (&OpenGL_state,0,sizeof(rendering_state));
OpenGL_state.screen_width = width;
OpenGL_state.screen_height = height;
#else
// Setup OpenGL_state.screen_width & OpenGL_state.screen_height & width & height
#endif
// Get some info
opengl_GetInformation();
mprintf ((0,"Setting up multitexture...\n"));
// Determine if Multitexture is supported
bool supportsMultiTexture = opengl_CheckExtension ("GL_ARB_multitexture");
if (!supportsMultiTexture)
{
supportsMultiTexture = opengl_CheckExtension ("GL_SGIS_multitexture");
}
if (FindArg ("-NoMultitexture"))
{
supportsMultiTexture = false;
}
if( supportsMultiTexture )
{
// attempt to grab Multitexture functions
opengl_GetDLLFunctions();
}
else
{
// No multitexture at all
UseMultitexture = false;
}
// Do we have packed pixel formats?
OpenGL_packed_pixels=opengl_CheckExtension ("GL_EXT_packed_pixels");
opengl_InitCache();
if(UseMultitexture)
{
mprintf((0,"Using multitexture."));
}
else
{
mprintf((0,"Not using multitexture."));
}
if (OpenGL_packed_pixels)
{
opengl_packed_Upload_data=(ushort *)mem_malloc (2048*2048*2);
opengl_packed_Translate_table=(ushort *)mem_malloc (65536*2);
opengl_packed_4444_translate_table=(ushort *)mem_malloc (65536*2);
ASSERT (opengl_packed_Upload_data);
ASSERT (opengl_packed_Translate_table);
ASSERT (opengl_packed_4444_translate_table);
mprintf ((0,"Building packed OpenGL translate table...\n"));
for (i=0;i<65536;i++)
{
int r=(i>>10) & 0x1f;
int g=(i>>5) & 0x1f;
int b=i & 0x1f;
#ifdef BRIGHTNESS_HACK
r *= BRIGHTNESS_HACK;
g *= BRIGHTNESS_HACK;
b *= BRIGHTNESS_HACK;
if( r > 0x1F ) r = 0x1F;
if( g > 0x1F ) g = 0x1F;
if( b > 0x1F ) b = 0x1F;
#endif
ushort pix;
if (!(i & OPAQUE_FLAG))
{
pix=0;
}
else
{
pix=(r<<11) | (g<<6) | (b<<1) | 1;
}
opengl_packed_Translate_table[i]=INTEL_INT(pix);
// 4444 table
int a=(i>>12) & 0xf;
r=(i>>8) & 0xf;
g=(i>>4) & 0xf;
b=i & 0xf;
pix = (r<<12) | (g<<8) | (b<<4) | a;
opengl_packed_4444_translate_table[i] = INTEL_INT(pix);
}
}
else
{
opengl_Upload_data=(uint *)mem_malloc (2048*2048*4);
opengl_Translate_table=(uint *)mem_malloc (65536*4);
opengl_4444_translate_table=(uint *)mem_malloc (65536*4);
ASSERT (opengl_Upload_data);
ASSERT (opengl_Translate_table);
ASSERT (opengl_4444_translate_table);
mprintf ((0,"Building OpenGL translate table...\n"));
for (i=0;i<65536;i++)
{
uint pix;
int r=(i>>10) & 0x1f;
int g=(i>>5) & 0x1f;
int b=i & 0x1f;
#ifdef BRIGHTNESS_HACK
r *= BRIGHTNESS_HACK;
g *= BRIGHTNESS_HACK;
b *= BRIGHTNESS_HACK;
if( r > 0x1F ) r = 0x1F;
if( g > 0x1F ) g = 0x1F;
if( b > 0x1F ) b = 0x1F;
#endif
float fr=(float)r/31.0f;
float fg=(float)g/31.0f;
float fb=(float)b/31.0f;
r=255*fr;
g=255*fg;
b=255*fb;
if (!(i & OPAQUE_FLAG))
{
pix=0;
}
else
{
pix=(255<<24) | (b<<16) | (g<<8) | (r);
}
opengl_Translate_table[i]=INTEL_INT(pix);
// Do 4444
int a=(i>>12) & 0xf;
r=(i>>8) & 0xf;
g=(i>>4) & 0xf;
b=i & 0xf;
float fa=(float)a/15.0f;
fr=(float)r/15.0f;
fg=(float)g/15.0f;
fb=(float)b/15.0f;
a=255*fa;
r=255*fr;
g=255*fg;
b=255*fb;
pix=(a<<24) | (b<<16) | (g<<8) | (r);
opengl_4444_translate_table[i]=INTEL_INT(pix);
}
}
opengl_SetDefaults();
g3_ForceTransformRefresh();
CHECK_ERROR(4)
OpenGL_state.initted = 1;
mprintf ((0,"OpenGL initialization at %d x %d was successful.\n",width,height));
return retval;
}
// Releases the rendering context
void opengl_Close ()
{
CHECK_ERROR(5)
uint *delete_list=(uint *)mem_malloc (Cur_texture_object_num*sizeof(int));
ASSERT (delete_list);
for (int i=1;i<Cur_texture_object_num;i++)
delete_list[i]=i;
if (Cur_texture_object_num>1)
dglDeleteTextures (Cur_texture_object_num,(const uint *)delete_list);
mem_free (delete_list);
#if defined(WIN32)
if (dwglMakeCurrent)
dwglMakeCurrent(NULL, NULL);
if (dwglDeleteContext)
dwglDeleteContext(ResourceContext);
// Change our display back
if (!WindowGL)
{
#ifdef CHANGE_RESOLUTION_IN_FULLSCREEN
ChangeDisplaySettings(NULL,0);
#endif
}
#elif defined(__LINUX__)
// SDL_Quit() handles this for us.
#else
#endif
if (OpenGL_packed_pixels)
{
if (opengl_packed_Upload_data)
{
mem_free (opengl_packed_Upload_data);
}
if (opengl_packed_Translate_table)
{
mem_free (opengl_packed_Translate_table);
}
if (opengl_packed_4444_translate_table)
{
mem_free (opengl_packed_4444_translate_table);
}
opengl_packed_Upload_data=NULL;
opengl_packed_Translate_table=NULL;
opengl_packed_4444_translate_table=NULL;
}
else
{
if (opengl_Upload_data)
mem_free (opengl_Upload_data);
if (opengl_Translate_table)
mem_free (opengl_Translate_table);
if (opengl_4444_translate_table)
mem_free (opengl_4444_translate_table);
opengl_Upload_data=NULL;
opengl_Translate_table=NULL;
opengl_4444_translate_table=NULL;
}
if (OpenGL_cache_initted)
{
mem_free (OpenGL_lightmap_remap);
mem_free (OpenGL_bitmap_remap);
mem_free (OpenGL_lightmap_states);
mem_free (OpenGL_bitmap_states);
OpenGL_cache_initted=0;
}
#if defined(WIN32)
// Restore gamma values
SetDeviceGammaRamp(hOpenGLDC,(LPVOID)Saved_gamma_values);
// I'm freeing the DC here - samir
ReleaseDC(hOpenGLWnd, hOpenGLDC);
#elif defined(__LINUX__)
#else
#endif
//mod_FreeModule (OpenGLDLLHandle);
OpenGL_state.initted = 0;
}
// Takes our 16bit format and converts it into the memory scheme that OpenGL wants
void opengl_TranslateBitmapToOpenGL (int texnum,int bm_handle,int map_type,int replace,int tn)
{
ushort *bm_ptr;
int w,h;
int size;
if (UseMultitexture && Last_texel_unit_set!=tn)
{
#if (defined(_USE_OGL_ACTIVE_TEXTURES))
oglActiveTextureARB (GL_TEXTURE0_ARB+tn);
Last_texel_unit_set=tn;
#endif
}
if (map_type==MAP_TYPE_LIGHTMAP)
{
if (GameLightmaps[bm_handle].flags & LF_BRAND_NEW)
replace=0;
bm_ptr=lm_data (bm_handle);
GameLightmaps[bm_handle].flags &=~(LF_CHANGED|LF_BRAND_NEW);
w=lm_w(bm_handle);
h=lm_h(bm_handle);
size=GameLightmaps[bm_handle].square_res;
}
else
{
if (GameBitmaps[bm_handle].flags & BF_BRAND_NEW)
replace=0;
bm_ptr=bm_data (bm_handle,0);
GameBitmaps[bm_handle].flags &=~(BF_CHANGED|BF_BRAND_NEW);
w=bm_w(bm_handle,0);
h=bm_h(bm_handle,0);
size=w;
}
if (OpenGL_last_bound[tn]!=texnum)
{
dglBindTexture (GL_TEXTURE_2D,texnum);
OpenGL_sets_this_frame[0]++;
OpenGL_last_bound[tn]=texnum;
}
int i;
if (OpenGL_packed_pixels)
{
if (map_type==MAP_TYPE_LIGHTMAP)
{
ushort *left_data=(ushort *)opengl_packed_Upload_data;
int bm_left=0;
for (int i=0;i<h;i++,left_data+=size,bm_left+=w)
{
ushort *dest_data=left_data;
for (int t=0;t<w;t++)
{
*dest_data++=opengl_packed_Translate_table[bm_ptr[bm_left+t]];
}
}
if (replace)
{
dglTexSubImage2D (GL_TEXTURE_2D,0,0,0,size,size,GL_RGBA,GL_UNSIGNED_SHORT_5_5_5_1,opengl_packed_Upload_data);
}
else
{
dglTexImage2D (GL_TEXTURE_2D,0,GL_RGB5_A1,size,size,0,GL_RGBA,GL_UNSIGNED_SHORT_5_5_5_1,opengl_packed_Upload_data);
}
}
else
{
int limit=0;
if (bm_mipped(bm_handle))
{
limit=NUM_MIP_LEVELS+3;
}
else
{
limit=1;
}
for (int m=0;m<limit;m++)
{
if (m<NUM_MIP_LEVELS)
{
bm_ptr=bm_data (bm_handle,m);
w=bm_w(bm_handle,m);
h=bm_h(bm_handle,m);
}
else
{
bm_ptr=bm_data (bm_handle,NUM_MIP_LEVELS-1);
w=bm_w(bm_handle,NUM_MIP_LEVELS-1);
h=bm_h(bm_handle,NUM_MIP_LEVELS-1);
w>>=m-(NUM_MIP_LEVELS-1);
h>>=m-(NUM_MIP_LEVELS-1);
if ((w < 1) || (h < 1))
continue;
}
if (bm_format(bm_handle)==BITMAP_FORMAT_4444)
{
// Do 4444
if (bm_mipped(bm_handle))
{
for (i=0;i<w*h;i++)
opengl_packed_Upload_data[i]=0xf|(opengl_packed_4444_translate_table[bm_ptr[i]]);
}
else
{
for (i=0;i<w*h;i++)
opengl_packed_Upload_data[i]=opengl_packed_4444_translate_table[bm_ptr[i]];
}
if (replace)
{
dglTexSubImage2D (GL_TEXTURE_2D,m,0,0,w,h,GL_RGBA,GL_UNSIGNED_SHORT_4_4_4_4,opengl_packed_Upload_data);
}
else
{
dglTexImage2D (GL_TEXTURE_2D,m,GL_RGBA4,w,h,0,GL_RGBA,GL_UNSIGNED_SHORT_4_4_4_4,opengl_packed_Upload_data);
}
}
else
{
// Do 1555
for (i=0;i<w*h;i++)
{
opengl_packed_Upload_data[i]=opengl_packed_Translate_table[bm_ptr[i]];
}
if (replace)
{
dglTexSubImage2D (GL_TEXTURE_2D,m,0,0,w,h,GL_RGBA,GL_UNSIGNED_SHORT_5_5_5_1,opengl_packed_Upload_data);
}
else
{
dglTexImage2D (GL_TEXTURE_2D,m,GL_RGB5_A1,w,h,0,GL_RGBA,GL_UNSIGNED_SHORT_5_5_5_1,opengl_packed_Upload_data);
}
}
}
}
}
else
{
if (map_type==MAP_TYPE_LIGHTMAP)
{
uint *left_data=(uint *)opengl_Upload_data;
int bm_left=0;
for (int i=0;i<h;i++,left_data+=size,bm_left+=w)
{
uint *dest_data=left_data;
for (int t=0;t<w;t++)
{
*dest_data++=opengl_Translate_table[bm_ptr[bm_left+t]];
}
}
if(size>0)
{
if (replace)
{
dglTexSubImage2D (GL_TEXTURE_2D,0,0,0,size,size,GL_RGBA,GL_UNSIGNED_BYTE,opengl_Upload_data);
}
else
{
dglTexImage2D (GL_TEXTURE_2D,0,GL_RGBA,size,size,0,GL_RGBA,GL_UNSIGNED_BYTE,opengl_Upload_data);
}
}
}
else
{
int limit=0;
if (bm_mipped(bm_handle))
{
limit=NUM_MIP_LEVELS+3; // ryan added +3.
}
else
{
limit=1;
}
for (int m=0;m<limit;m++)
{
bm_ptr=bm_data (bm_handle,m);
w=bm_w(bm_handle,m);
h=bm_h(bm_handle,m);
if (bm_format(bm_handle)==BITMAP_FORMAT_4444)
{
// Do 4444
if (bm_mipped(bm_handle))
{
for (i=0;i<w*h;i++)
opengl_Upload_data[i]=INTEL_INT((255<<24))|opengl_4444_translate_table[bm_ptr[i]];
}
else
{
for (i=0;i<w*h;i++)
opengl_Upload_data[i]=opengl_4444_translate_table[bm_ptr[i]];
}
}
else
{
// Do 1555
for (i=0;i<w*h;i++)
opengl_Upload_data[i]=opengl_Translate_table[bm_ptr[i]];
}
//rcg06262000 my if wrapper.
if ((w > 0) && (h > 0))
{
if (replace)
{
dglTexSubImage2D (GL_TEXTURE_2D,m,0,0,w,h,GL_RGBA,GL_UNSIGNED_BYTE,opengl_Upload_data);
}
else
{
dglTexImage2D (GL_TEXTURE_2D,m,GL_RGBA,w,h,0,GL_RGBA,GL_UNSIGNED_BYTE,opengl_Upload_data);
}
}
}
}
}
//mprintf ((1,"Doing slow upload to opengl!\n"));
if (map_type==MAP_TYPE_LIGHTMAP)
{
GameLightmaps[bm_handle].flags&=~LF_LIMITS;
}
CHECK_ERROR(6)
OpenGL_uploads++;
}
extern bool Force_one_texture;
// Utilizes a LRU cacheing scheme to select/upload textures the opengl driver
int opengl_MakeBitmapCurrent (int handle,int map_type,int tn)
{
int w,h;
int texnum;
if (map_type==MAP_TYPE_LIGHTMAP)
{
w=GameLightmaps[handle].square_res;
h=GameLightmaps[handle].square_res;
}
else
{
if(Force_one_texture)
{
handle=0;
}
w=bm_w(handle,0);
h=bm_h(handle,0);
}
if( w != h )
{
mprintf ((0,"Can't use non-square textures with OpenGL!\n"));
return 0;
}
// See if the bitmaps is already in the cache
if (map_type==MAP_TYPE_LIGHTMAP)
{
if (OpenGL_lightmap_remap[handle]==65535)
{
texnum=opengl_MakeTextureObject (tn);
SET_WRAP_STATE(OpenGL_lightmap_states[handle],1);
SET_FILTER_STATE(OpenGL_lightmap_states[handle],0);
OpenGL_lightmap_remap[handle]=texnum;
opengl_TranslateBitmapToOpenGL(texnum,handle,map_type,0,tn);
}
else
{
texnum=OpenGL_lightmap_remap[handle];
if (GameLightmaps[handle].flags & LF_CHANGED)
opengl_TranslateBitmapToOpenGL(texnum,handle,map_type,1,tn);
}
}
else
{
if (OpenGL_bitmap_remap[handle]==65535)
{
texnum=opengl_MakeTextureObject (tn);
SET_WRAP_STATE(OpenGL_bitmap_states[handle],1);
SET_FILTER_STATE(OpenGL_bitmap_states[handle],0);
OpenGL_bitmap_remap[handle]=texnum;
opengl_TranslateBitmapToOpenGL(texnum,handle,map_type,0,tn);
}
else
{
texnum=OpenGL_bitmap_remap[handle];
if( GameBitmaps[handle].flags & BF_CHANGED )
{
opengl_TranslateBitmapToOpenGL(texnum,handle,map_type,1,tn);
}
}
}
if (OpenGL_last_bound[tn]!=texnum)
{
if (UseMultitexture && Last_texel_unit_set!=tn)
{
#if (defined(_USE_OGL_ACTIVE_TEXTURES))
oglActiveTextureARB (GL_TEXTURE0_ARB+tn);
Last_texel_unit_set=tn;
#endif
}
dglBindTexture (GL_TEXTURE_2D,texnum);
OpenGL_last_bound[tn]=texnum;
OpenGL_sets_this_frame[0]++;
}
CHECK_ERROR(7)
return 1;
}
// Sets up an appropriate wrap type for the current bound texture
void opengl_MakeWrapTypeCurrent(int handle,int map_type,int tn)
{
int uwrap;
wrap_type dest_wrap;
if (tn==1)
dest_wrap=WT_CLAMP;
else
dest_wrap=OpenGL_state.cur_wrap_type;
if (map_type==MAP_TYPE_LIGHTMAP)
uwrap=GET_WRAP_STATE(OpenGL_lightmap_states[handle]);
else
uwrap=GET_WRAP_STATE(OpenGL_bitmap_states[handle]);
if (uwrap==dest_wrap)
return;
if (UseMultitexture && Last_texel_unit_set!=tn)
{
#if (defined(_USE_OGL_ACTIVE_TEXTURES))
oglActiveTextureARB (GL_TEXTURE0_ARB+tn);
Last_texel_unit_set=tn;
#endif
}
OpenGL_sets_this_frame[1]++;
if (OpenGL_state.cur_wrap_type==WT_CLAMP)
{
dglTexParameteri (GL_TEXTURE_2D,GL_TEXTURE_WRAP_S,GL_CLAMP);
dglTexParameteri (GL_TEXTURE_2D,GL_TEXTURE_WRAP_T,GL_CLAMP);
}
else if (OpenGL_state.cur_wrap_type==WT_WRAP_V)
{
dglTexParameteri (GL_TEXTURE_2D,GL_TEXTURE_WRAP_S,GL_CLAMP);
dglTexParameteri (GL_TEXTURE_2D,GL_TEXTURE_WRAP_T,GL_REPEAT);
}
else
{
dglTexParameteri (GL_TEXTURE_2D,GL_TEXTURE_WRAP_S,GL_REPEAT);
dglTexParameteri (GL_TEXTURE_2D,GL_TEXTURE_WRAP_T,GL_REPEAT);
}
if (map_type==MAP_TYPE_LIGHTMAP)
{
SET_WRAP_STATE (OpenGL_lightmap_states[handle],dest_wrap);
}
else
{
SET_WRAP_STATE (OpenGL_bitmap_states[handle],dest_wrap);
}
CHECK_ERROR(8)
}
// Chooses the correct filter type for the currently bound texture
void opengl_MakeFilterTypeCurrent(int handle,int map_type,int tn)
{
int magf;
sbyte dest_state;
if (map_type==MAP_TYPE_LIGHTMAP)
{
magf=GET_FILTER_STATE(OpenGL_lightmap_states[handle]);
dest_state=1;
}
else
{
magf=GET_FILTER_STATE(OpenGL_bitmap_states[handle]);
dest_state=OpenGL_preferred_state.filtering;
if (!OpenGL_state.cur_bilinear_state)
dest_state=0;
}
if (magf==dest_state)
return;
#if (defined(_USE_OGL_ACTIVE_TEXTURES))
if (UseMultitexture && Last_texel_unit_set!=tn)
{
oglActiveTextureARB (GL_TEXTURE0_ARB+tn);
Last_texel_unit_set=tn;
}
#endif
OpenGL_sets_this_frame[2]++;
if (dest_state)
{
if (map_type==MAP_TYPE_BITMAP && bm_mipped(handle))
{
dglTexParameteri (GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR);
dglTexParameteri (GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR_MIPMAP_NEAREST);
}
else
{
dglTexParameteri (GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR);
dglTexParameteri (GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR);
}
}
else
{
if (map_type==MAP_TYPE_BITMAP && bm_mipped(handle))
{
//dglTexParameteri (GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_NEAREST_MIPMAP_NEAREST);
dglTexParameteri (GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_NEAREST);
dglTexParameteri (GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_NEAREST_MIPMAP_NEAREST);
}
else
{
dglTexParameteri (GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_NEAREST);
dglTexParameteri (GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_NEAREST);
}
}
if (map_type==MAP_TYPE_LIGHTMAP)
{
SET_FILTER_STATE (OpenGL_lightmap_states[handle],dest_state);
}
else
{
SET_FILTER_STATE (OpenGL_bitmap_states[handle],dest_state);
}
CHECK_ERROR(9)
}
// returns the alpha that we should use
float opengl_GetAlphaMultiplier(void)
{
switch(OpenGL_state.cur_alpha_type)
{
case AT_ALWAYS:
return 1.0;
case AT_CONSTANT:
return OpenGL_state.cur_alpha/255.0;
case AT_TEXTURE:
return 1.0;
case AT_CONSTANT_TEXTURE:
return OpenGL_state.cur_alpha/255.0;
case AT_VERTEX:
return 1.0;
case AT_CONSTANT_TEXTURE_VERTEX:
case AT_CONSTANT_VERTEX:
return OpenGL_state.cur_alpha/255.0;
case AT_TEXTURE_VERTEX:
return 1.0;
case AT_LIGHTMAP_BLEND:
case AT_LIGHTMAP_BLEND_SATURATE:
return OpenGL_state.cur_alpha/255.0;
case AT_SATURATE_TEXTURE:
return OpenGL_state.cur_alpha/255.0;
case AT_SATURATE_VERTEX:
return 1.0;
case AT_SATURATE_CONSTANT_VERTEX:
return OpenGL_state.cur_alpha/255.0;
case AT_SATURATE_TEXTURE_VERTEX:
return 1.0;
case AT_SPECULAR:
return 1.0;
default:
//Int3(); // no type defined,get jason
return 0;
}
}
// Turns on/off multitexture blending
void opengl_SetMultitextureBlendMode (bool state)
{
if (OpenGL_multitexture_state==state)
return;
OpenGL_multitexture_state=state;
#if (defined(_USE_OGL_ACTIVE_TEXTURES))
if (state)
{
oglActiveTextureARB( GL_TEXTURE1_ARB );
oglClientActiveTextureARB( GL_TEXTURE1_ARB );
dglEnableClientState( GL_TEXTURE_COORD_ARRAY );
dglEnable( GL_TEXTURE_2D );
oglActiveTextureARB( GL_TEXTURE0_ARB );
oglClientActiveTextureARB( GL_TEXTURE0_ARB );
Last_texel_unit_set = 0;
}
else
{
oglActiveTextureARB( GL_TEXTURE1_ARB );
oglClientActiveTextureARB( GL_TEXTURE1_ARB );
dglDisableClientState( GL_TEXTURE_COORD_ARRAY );
dglDisable( GL_TEXTURE_2D );
oglActiveTextureARB( GL_TEXTURE0_ARB );
oglClientActiveTextureARB( GL_TEXTURE0_ARB );
Last_texel_unit_set = 0;
}
#endif
}
// Takes nv vertices and draws the polygon defined by those vertices. Uses bitmap "handle"
// as a texture
void opengl_DrawMultitexturePolygon3D(int handle,g3Point **p,int nv,int map_type)
{
g3Point *pnt;
int i,fr,fg,fb;
float alpha;
vector *vertp;
color_array *colorp;
tex_array *texp,*texp2;
float one_over_square_res=1.0/GameLightmaps[Overlay_map].square_res;
float xscalar=(float)GameLightmaps[Overlay_map].width*one_over_square_res;
float yscalar=(float)GameLightmaps[Overlay_map].height*one_over_square_res;
ASSERT (nv<100);
if (OpenGL_state.cur_light_state==LS_NONE)
{
fr=GR_COLOR_RED(OpenGL_state.cur_color);
fg=GR_COLOR_GREEN(OpenGL_state.cur_color);
fb=GR_COLOR_BLUE(OpenGL_state.cur_color);
}
alpha=Alpha_multiplier*OpenGL_Alpha_factor;
vertp=&GL_verts[0];
texp=&GL_tex_coords[0];
texp2=&GL_tex_coords2[0];
colorp=&GL_colors[0];
// Specify our coordinates
for (i=0;i<nv;i++,vertp++,texp++,colorp++,texp2++)
{
pnt=p[i];
ASSERT( pnt->p3_flags & PF_ORIGPOINT );
if (OpenGL_state.cur_alpha_type & ATF_VERTEX)
alpha=pnt->p3_a*Alpha_multiplier*OpenGL_Alpha_factor;
// If we have a lighting model, apply the correct lighting!
if (OpenGL_state.cur_light_state!=LS_NONE)
{
// Do lighting based on intesity (MONO) or colored (RGB)
if (OpenGL_state.cur_color_model==CM_MONO)
{
colorp->r=pnt->p3_l;
colorp->g=pnt->p3_l;
colorp->b=pnt->p3_l;
colorp->a=alpha;
}
else
{
colorp->r=pnt->p3_r;
colorp->g=pnt->p3_g;
colorp->b=pnt->p3_b;
colorp->a=alpha;
}
}
else
{
colorp->r=1;
colorp->g=1;
colorp->b=1;
colorp->a=alpha;
}
/*
// Texture this polygon!
float texw=1.0/(pnt->p3_z+Z_bias);
texp->s=pnt->p3_u*texw;
texp->t=pnt->p3_v*texw;
texp->r=0;
texp->w=texw;
texp2->s=pnt->p3_u2*xscalar*texw;
texp2->t=pnt->p3_v2*yscalar*texw;
texp2->r=0;
texp2->w=texw;
*/
texp->s = pnt->p3_u;
texp->t = pnt->p3_v;
texp->r = 0.0f;
texp->w = 1.0f;
texp2->s = pnt->p3_u2 * xscalar;
texp2->t = pnt->p3_v2 * yscalar;
texp2->r = 0.0f;
texp2->w = 1.0f;
// Finally, specify a vertex
/*
vertp->x=pnt->p3_sx+x_add;
vertp->y=pnt->p3_sy+y_add;
vertp->z = -max(0,min(1.0,1.0-(1.0/(pnt->p3_z+Z_bias))));
*/
*vertp = pnt->p3_vecPreRot;
}
// make sure our bitmap is ready to be drawn
opengl_MakeBitmapCurrent (handle,map_type,0);
opengl_MakeWrapTypeCurrent (handle,map_type,0);
opengl_MakeFilterTypeCurrent(handle,map_type,0);
// make sure our bitmap is ready to be drawn
opengl_MakeBitmapCurrent (Overlay_map,MAP_TYPE_LIGHTMAP,1);
opengl_MakeWrapTypeCurrent (Overlay_map,MAP_TYPE_LIGHTMAP,1);
opengl_MakeFilterTypeCurrent(Overlay_map,MAP_TYPE_LIGHTMAP,1);
opengl_SetMultitextureBlendMode (true);
// And draw!
dglDrawArrays (GL_POLYGON,0,nv);
OpenGL_polys_drawn++;
OpenGL_verts_processed+=nv;
CHECK_ERROR(10)
}
void opengl_DrawFlatPolygon3D(g3Point **p,int nv)
{
float fr,fg,fb;
int i;
if (UseMultitexture)
{
opengl_SetMultitextureBlendMode (false);
}
float alpha=Alpha_multiplier*OpenGL_Alpha_factor;
fr=GR_COLOR_RED(OpenGL_state.cur_color);
fg=GR_COLOR_GREEN(OpenGL_state.cur_color);
fb=GR_COLOR_BLUE(OpenGL_state.cur_color);
fr/=255.0;
fg/=255.0;
fb/=255.0;
// And draw!
dglBegin (GL_POLYGON);
for (i=0;i<nv;i++)
{
g3Point *pnt=p[i];
ASSERT( pnt->p3_flags & PF_ORIGPOINT );
if (OpenGL_state.cur_alpha_type & ATF_VERTEX)
alpha=pnt->p3_a*Alpha_multiplier*OpenGL_Alpha_factor;
// If we have a lighting model, apply the correct lighting!
if (OpenGL_state.cur_light_state!=LS_NONE)
{
// Do lighting based on intesity (MONO) or colored (RGB)
if (OpenGL_state.cur_color_model==CM_MONO)
dglColor4f (pnt->p3_l,pnt->p3_l,pnt->p3_l,alpha);
else
{
dglColor4f (pnt->p3_r,pnt->p3_g,pnt->p3_b,alpha);
}
}
else
{
dglColor4f( fr,fg,fb,alpha );
}
/*
// Finally, specify a vertex
float z = max(0,min(1.0,1.0-(1.0/(pnt->p3_z+Z_bias))));
dglVertex3f (pnt->p3_sx+x_add,pnt->p3_sy+y_add,-z);
*/
dglVertex3f( pnt->p3_vecPreRot.x, pnt->p3_vecPreRot.y, pnt->p3_vecPreRot.z );
}
dglEnd();
CHECK_ERROR(11)
OpenGL_polys_drawn++;
OpenGL_verts_processed+=nv;
}
// Sets the gamma correction value
void opengl_SetGammaValue( float val )
{
// if( WindowGL )
// return;
OpenGL_preferred_state.gamma = val;
mprintf ((0,"Setting gamma to %f\n",val));
#if defined(WIN32)
WORD rampvals[3*256];
for (int i=0;i<256;i++)
{
float norm=(float)i/255.0f;
float newval = powf(norm,1.0f/val);
newval*=65535;
newval=min(65535,newval);
rampvals[i]=newval;
rampvals[i+256]=newval;
rampvals[i+512]=newval;
}
SetDeviceGammaRamp(hOpenGLDC,(LPVOID)rampvals);
#endif
}
// Resets the texture cache
void opengl_ResetCache(void)
{
if( OpenGL_cache_initted )
{
mem_free(OpenGL_lightmap_remap);
mem_free(OpenGL_bitmap_remap);
mem_free(OpenGL_lightmap_states);
mem_free(OpenGL_bitmap_states);
OpenGL_cache_initted=0;
}
opengl_InitCache();
}
ubyte opengl_Framebuffer_ready=0;
chunked_bitmap opengl_Chunked_bitmap;
void opengl_ChangeChunkedBitmap(int bm_handle, chunked_bitmap *chunk)
{
int bw=bm_w(bm_handle,0);
int bh=bm_h(bm_handle,0);
//determine optimal size of the square bitmaps
float fopt=128.0f;
int iopt;
//find the smallest dimension and base off that
int smallest = min(bw,bh);
if(smallest<=32)
fopt=32;
else
if(smallest<=64)
fopt=64;
else
fopt=128;
iopt=(int)fopt;
// Get how many pieces we need across and down
float temp=bw/fopt;
int how_many_across=temp;
if ((temp-how_many_across)>0)
how_many_across++;
temp=bh/fopt;
int how_many_down=temp;
if ((temp-how_many_down)>0)
how_many_down++;
ASSERT (how_many_across>0);
ASSERT (how_many_down>0);
// Now go through our big bitmap and partition it into pieces
ushort *src_data=bm_data(bm_handle,0);
ushort *sdata;
ushort *ddata;
int shift;
switch(iopt)
{
case 32:
shift = 5;
break;
case 64:
shift = 6;
break;
case 128:
shift = 7;
break;
default:
Int3(); //Get Jeff
break;
}
int maxx,maxy;
int windex,hindex;
int s_y,s_x,d_y,d_x;
for(hindex=0;hindex<how_many_down;hindex++){
for(windex=0;windex<how_many_across;windex++){
//loop through the chunks
//find end x and y
if(windex<how_many_across-1)
maxx=iopt;
else
maxx = bw - (windex<<shift);
if(hindex<how_many_down-1)
maxy=iopt;
else
maxy = bh - (hindex<<shift);
//find the starting source x and y
s_x = (windex<<shift);
s_y = (hindex<<shift);
//get the pointers pointing to the right spot
ddata = bm_data(chunk->bm_array[hindex*how_many_across+windex],0);
GameBitmaps[chunk->bm_array[hindex*how_many_across+windex]].flags|=BF_CHANGED;
sdata = &src_data[s_y * bw + s_x];
//copy the data
for(d_y=0;d_y<maxy;d_y++){
for(d_x=0;d_x<maxx;d_x++){
ddata[d_x] = sdata[d_x];
}//end for d_x
sdata += bw;
ddata += iopt;
}//end for d_y
}//end for windex
}//end for hindex
}
// Tells the software renderer whether or not to use mipping
void rend_SetMipState( sbyte mipstate )
{
}
// Init our renderer
int rend_Init(renderer_type state, oeApplication *app,renderer_preferred_state *pref_state)
{
#ifndef DEDICATED_ONLY
int retval=0;
rend_SetRendererType( state );
if( !Renderer_initted )
{
if( !Renderer_close_flag )
{
atexit( rend_Close );
Renderer_close_flag = 1;
}
Renderer_initted=1;
}
if( OpenGL_window_initted )
{
rend_CloseOpenGLWindow();
OpenGL_window_initted=0;
}
mprintf ((0,"Renderer init is set to %d\n",Renderer_initted));
#ifndef OEM_V3
int flags = app->flags();
if( flags & OEAPP_WINDOWED )
{
// initialize for windowed
retval = rend_InitOpenGLWindow( app, pref_state );
}
else
{
// initialize for full screen
retval=opengl_Init( app, pref_state );
}
#endif
return retval;
#else
return 0;
#endif //#ifdef DEDICATED_ONLY
}
void rend_Close(void)
{
mprintf((0,"CLOSE:Renderer init is set to %d\n",Renderer_initted));
if(!Renderer_initted)
return;
if( OpenGL_window_initted )
{
if( Renderer_type == RENDERER_OPENGL )
{
rend_CloseOpenGLWindow();
}
OpenGL_window_initted = 0;
}
opengl_Close();
Renderer_initted=0;
}
#ifdef DEDICATED_ONLY
void rend_DrawPolygon3D( int , g3Point **, int , int ){ }
void rend_DrawPolygon2D( int , g3Point **, int , int ){ }
#else
static inline float __recip(float x)
{
#if MACOSX
__asm__ __volatile__ (
"fres %0, %1 \n\t"
: "=f" (x) : "f" (x)
);
return(x);
#else
return(1.0f / x);
#endif
}
// Takes nv vertices and draws the 3D polygon defined by those vertices.
// Uses bitmap "handle" as a texture
void rend_DrawPolygon3D( int handle, g3Point **p, int nv, int map_type )
{
g3Point *pnt;
int i;
float fr,fg,fb;
float alpha;
vector *vertp;
color_array *colorp;
tex_array *texp;
ASSERT (nv<100);
g3_RefreshTransforms( false );
if (OpenGL_state.cur_texture_quality==0)
{
opengl_DrawFlatPolygon3D(p,nv);
return;
}
if (Overlay_type!=OT_NONE && UseMultitexture)
{
opengl_DrawMultitexturePolygon3D(handle,p,nv,map_type);
return;
}
if (OpenGL_state.cur_light_state==LS_FLAT_GOURAUD)
{
fr=GR_COLOR_RED(OpenGL_state.cur_color)/255.0;
fg=GR_COLOR_GREEN(OpenGL_state.cur_color)/255.0;
fb=GR_COLOR_BLUE(OpenGL_state.cur_color)/255.0;
}
if (UseMultitexture)
{
opengl_SetMultitextureBlendMode (false);
}
// make sure our bitmap is ready to be drawn
opengl_MakeBitmapCurrent (handle,map_type,0);
opengl_MakeWrapTypeCurrent (handle,map_type,0);
opengl_MakeFilterTypeCurrent(handle,map_type,0);
alpha=Alpha_multiplier*OpenGL_Alpha_factor;
vertp=&GL_verts[0];
texp=&GL_tex_coords[0];
colorp=&GL_colors[0];
// Specify our coordinates
for (i=0;i<nv;i++,vertp++,texp++,colorp++)
{
pnt = p[i];
// all points should be original
ASSERT( pnt->p3_flags & PF_ORIGPOINT );
////////////////////////////////////////////
if( pnt->p3_flags&PF_ORIGPOINT )
{
if( !(pnt->p3_flags&PF_PROJECTED) )
{
g3_ProjectPoint( pnt );
}
// get the original point
float origPoint[4];
origPoint[0] = pnt->p3_vecPreRot.x;
origPoint[1] = pnt->p3_vecPreRot.y;
origPoint[2] = pnt->p3_vecPreRot.z;
origPoint[3] = 1.0f;
// transform by the full transform
float view[4];
g3_TransformVert( view, origPoint, gTransformFull );
vector tempv = pnt->p3_vecPreRot - View_position;
vector testPt = tempv * Unscaled_matrix;
float screenX = pnt->p3_sx + OpenGL_state.clip_x1;
float screenY = pnt->p3_sy + OpenGL_state.clip_y1;
// normalize
float oOW = 1.0f / view[3];
view[0] *= oOW;
view[1] *= oOW;
view[2] *= oOW;
oOW *= 1.0f;
}
////////////////////////////////////////////
if (OpenGL_state.cur_alpha_type & ATF_VERTEX)
{
alpha=pnt->p3_a*Alpha_multiplier*OpenGL_Alpha_factor;
}
// If we have a lighting model, apply the correct lighting!
if (OpenGL_state.cur_light_state!=LS_NONE)
{
if (OpenGL_state.cur_light_state==LS_FLAT_GOURAUD)
{
colorp->r=fr;
colorp->g=fg;
colorp->b=fb;
colorp->a=alpha;
}
else
{
// Do lighting based on intesity (MONO) or colored (RGB)
if (OpenGL_state.cur_color_model==CM_MONO)
{
colorp->r=pnt->p3_l;
colorp->g=pnt->p3_l;
colorp->b=pnt->p3_l;
colorp->a=alpha;
}
else
{
colorp->r=pnt->p3_r;
colorp->g=pnt->p3_g;
colorp->b=pnt->p3_b;
colorp->a=alpha;
}
}
}
else
{
colorp->r=1;
colorp->g=1;
colorp->b=1;
colorp->a=alpha;
}
/*
#ifdef __LINUX__
//MY TEST HACK...MAYBE BAD DRIVERS? OR MAYBE THIS IS
//HOW IT SHOULD BE DONE (STILL BUGGY)
// Texture this polygon!
float texw=1.0/(pnt->p3_z+Z_bias);
if(OpenGL_TextureHack)
{
texp->s=pnt->p3_u;
texp->t=pnt->p3_v;
}else
{
texp->s=pnt->p3_u*texw;
texp->t=pnt->p3_v*texw;
}
texp->r=0;
texp->w=texw;
#else
// Texture this polygon!
float texw=1.0/(pnt->p3_z+Z_bias);
texp->s=pnt->p3_u*texw;
texp->t=pnt->p3_v*texw;
texp->r=0;
texp->w=texw;
#endif
*/
texp->s = pnt->p3_u;
texp->t = pnt->p3_v;
texp->r = 0.0f;
texp->w = 1.0f;
// Finally, specify a vertex
/*
vertp->x=pnt->p3_sx+x_add;
vertp->y=pnt->p3_sy+y_add;
float z = max(0,min(1.0,1.0-(1.0/(pnt->p3_z+Z_bias))));
vertp->z=-z;
*/
*vertp = pnt->p3_vecPreRot;
}
// And draw!
dglDrawArrays (GL_POLYGON,0,nv);
OpenGL_polys_drawn++;
OpenGL_verts_processed+=nv;
CHECK_ERROR(10)
// If there is a lightmap to draw, draw it as well
if (Overlay_type!=OT_NONE)
{
return; // Temp fix until I figure out whats going on
Int3(); // Shouldn't reach here
}
}
// Takes nv vertices and draws the 2D polygon defined by those vertices.
// Uses bitmap "handle" as a texture
void rend_DrawPolygon2D( int handle, g3Point **p, int nv )
{
ASSERT( nv < 100 );
ASSERT( Overlay_type == OT_NONE );
g3_RefreshTransforms( true );
if( UseMultitexture )
{
opengl_SetMultitextureBlendMode( false );
}
int xAdd = OpenGL_state.clip_x1;
int yAdd = OpenGL_state.clip_y1;
float fr,fg,fb;
if( OpenGL_state.cur_light_state == LS_FLAT_GOURAUD || OpenGL_state.cur_texture_quality == 0 )
{
float scale = 1.0f / 255.0f;
fr = GR_COLOR_RED(OpenGL_state.cur_color) * scale;
fg = GR_COLOR_GREEN(OpenGL_state.cur_color) * scale;
fb = GR_COLOR_BLUE(OpenGL_state.cur_color) * scale;
}
// make sure our bitmap is ready to be drawn
opengl_MakeBitmapCurrent( handle, MAP_TYPE_BITMAP, 0 );
opengl_MakeWrapTypeCurrent( handle, MAP_TYPE_BITMAP, 0 );
opengl_MakeFilterTypeCurrent( handle, MAP_TYPE_BITMAP, 0 );
float alpha = Alpha_multiplier * OpenGL_Alpha_factor;
vector *vertp = &GL_verts[0];
tex_array *texp = &GL_tex_coords[0];
color_array *colorp = &GL_colors[0];
// Specify our coordinates
int i;
for( i = 0; i < nv; ++i, ++vertp, ++texp, ++colorp )
{
g3Point *pnt = p[i];
if( OpenGL_state.cur_alpha_type & ATF_VERTEX )
{
// the alpha should come from the vertex
alpha = pnt->p3_a * Alpha_multiplier * OpenGL_Alpha_factor;
}
// If we have a lighting model, apply the correct lighting!
if( OpenGL_state.cur_light_state == LS_FLAT_GOURAUD || OpenGL_state.cur_texture_quality == 0 )
{
// pull the color from the constant color data
colorp->r=fr;
colorp->g=fg;
colorp->b=fb;
colorp->a=alpha;
}
else if( OpenGL_state.cur_light_state != LS_NONE )
{
// Do lighting based on intensity (MONO) or colored (RGB)
if( OpenGL_state.cur_color_model == CM_MONO )
{
colorp->r=pnt->p3_l;
colorp->g=pnt->p3_l;
colorp->b=pnt->p3_l;
colorp->a=alpha;
}
else
{
colorp->r=pnt->p3_r;
colorp->g=pnt->p3_g;
colorp->b=pnt->p3_b;
colorp->a=alpha;
}
}
else
{
// force white
colorp->r=1.0f;
colorp->g=1.0f;
colorp->b=1.0f;
colorp->a=alpha;
}
texp->s = pnt->p3_u;
texp->t = pnt->p3_v;
texp->r = 0.0f;
texp->w = 1.0f;
// Finally, specify a vertex
vertp->x = pnt->p3_sx + xAdd;
vertp->y = pnt->p3_sy + yAdd;
vertp->z = 0.0f;
}
// And draw!
if( OpenGL_state.cur_texture_quality == 0 )
{
// force disable textures
dglDisableClientState( GL_TEXTURE_COORD_ARRAY );
}
// draw the data in the arrays
dglDrawArrays( GL_POLYGON, 0, nv );
if( OpenGL_state.cur_texture_quality == 0 )
{
// re-enable textures
dglEnableClientState( GL_TEXTURE_COORD_ARRAY );
}
OpenGL_polys_drawn++;
OpenGL_verts_processed+=nv;
CHECK_ERROR(10)
}
#endif // DEDICATED_ONLY
void rend_SetFlatColor( ddgr_color color )
{
OpenGL_state.cur_color=color;
}
// Sets the fog state to TRUE or FALSE
void rend_SetFogState(sbyte state)
{
if( state==OpenGL_state.cur_fog_state )
return;
OpenGL_state.cur_fog_state = state;
if( state == 1 )
{
dglEnable(GL_FOG);
}
else
{
dglDisable(GL_FOG);
}
}
// Sets the near and far plane of fog
void rend_SetFogBorders(float nearz, float farz)
{
// Sets the near and far plane of fog
float fogStart = nearz;
float fogEnd = farz;
OpenGL_state.cur_fog_start = fogStart;
OpenGL_state.cur_fog_end = fogEnd;
dglFogi( GL_FOG_MODE, GL_LINEAR );
dglFogf( GL_FOG_START, fogStart );
dglFogf( GL_FOG_END, fogEnd );
}
void rend_SetRendererType(renderer_type state)
{
Renderer_type=state;
mprintf((0,"RendererType is set to %d.\n",state));
}
void rend_SetLighting(light_state state)
{
if (state==OpenGL_state.cur_light_state)
return; // No redundant state setting
#if (defined(_USE_OGL_ACTIVE_TEXTURES))
if (UseMultitexture && Last_texel_unit_set!=0)
{
oglActiveTextureARB (GL_TEXTURE0_ARB+0);
Last_texel_unit_set=0;
}
#endif
OpenGL_sets_this_frame[4]++;
switch (state)
{
case LS_NONE:
dglShadeModel (GL_SMOOTH);
OpenGL_state.cur_light_state=LS_NONE;
break;
case LS_FLAT_GOURAUD:
dglShadeModel (GL_SMOOTH);
OpenGL_state.cur_light_state=LS_FLAT_GOURAUD;
break;
case LS_GOURAUD:
case LS_PHONG:
dglShadeModel (GL_SMOOTH);
OpenGL_state.cur_light_state=LS_GOURAUD;
break;
default:
Int3();
break;
}
CHECK_ERROR(13)
}
void rend_SetColorModel(color_model state)
{
switch (state)
{
case CM_MONO:
OpenGL_state.cur_color_model=CM_MONO;
break;
case CM_RGB:
OpenGL_state.cur_color_model=CM_RGB;
break;
default:
Int3();
break;
}
}
void rend_SetTextureType(texture_type state)
{
if (state==OpenGL_state.cur_texture_type)
return; // No redundant state setting
#if (defined(_USE_OGL_ACTIVE_TEXTURES))
if (UseMultitexture && Last_texel_unit_set!=0)
{
oglActiveTextureARB (GL_TEXTURE0_ARB+0);
Last_texel_unit_set=0;
}
#endif
OpenGL_sets_this_frame[3]++;
switch (state)
{
case TT_FLAT:
dglDisable (GL_TEXTURE_2D);
OpenGL_state.cur_texture_quality=0;
break;
case TT_LINEAR:
case TT_LINEAR_SPECIAL:
case TT_PERSPECTIVE:
case TT_PERSPECTIVE_SPECIAL:
dglEnable (GL_TEXTURE_2D);
OpenGL_state.cur_texture_quality=2;
break;
default:
Int3(); // huh? Get Jason
break;
}
CHECK_ERROR(12)
OpenGL_state.cur_texture_type=state;
}
void rend_StartFrame(int x1,int y1,int x2,int y2,int clear_flags)
{
if( clear_flags & RF_CLEAR_ZBUFFER )
{
dglClear(GL_DEPTH_BUFFER_BIT);
}
OpenGL_state.clip_x1=x1;
OpenGL_state.clip_y1=y1;
OpenGL_state.clip_x2=x2;
OpenGL_state.clip_y2=y2;
}
#ifdef __CHECK_FOR_TOO_SLOW_RENDERING__
static void slownessAbort(void)
{
#ifdef __LINUX__
SDL_Surface *surface = SDL_GetVideoSurface();
SDL_SetVideoMode(surface->w, surface->h, surface->format->BitsPerPixel,
surface->flags & ~SDL_OPENGL);
sdl_ShowMessage("Your OpenGL driver is too slow to play this game.\n"
"Driver used: [ %s ]\n"
"Please change your driver!\n"
"Email support@lokigames.com for help,\n"
"or call 1-714-508-2140 (9-5 PM US Pacific Time).\n",
loadedLibrary);
SDL_GL_SwapBuffers();
Sleep(10000);
SDL_Quit();
_exit(99);
#else
#error Fill in an aborting notice for your platform.
#endif
} // slownessAbort
#endif
// Flips the screen
void rend_Flip(void)
{
#ifndef RELEASE
int i;
RTP_INCRVALUE(texture_uploads,OpenGL_uploads);
RTP_INCRVALUE(polys_drawn,OpenGL_polys_drawn);
mprintf_at ((1,1,0,"Uploads=%d Polys=%d Verts=%d ",OpenGL_uploads,OpenGL_polys_drawn,OpenGL_verts_processed));
mprintf_at ((1,2,0,"Sets= 0:%d 1:%d 2:%d 3:%d ",OpenGL_sets_this_frame[0],OpenGL_sets_this_frame[1],OpenGL_sets_this_frame[2],OpenGL_sets_this_frame[3]));
mprintf_at ((1,3,0,"Sets= 4:%d 5:%d ",OpenGL_sets_this_frame[4],OpenGL_sets_this_frame[5]));
for (i=0;i<10;i++)
{
OpenGL_sets_this_frame[i]=0;
}
#endif
OpenGL_last_frame_polys_drawn = OpenGL_polys_drawn;
OpenGL_last_frame_verts_processed = OpenGL_verts_processed;
OpenGL_last_uploaded = OpenGL_uploads;
OpenGL_uploads = 0;
OpenGL_polys_drawn = 0;
OpenGL_verts_processed = 0;
#if defined(WIN32)
SwapBuffers ((HDC)hOpenGLDC);
#elif defined(__LINUX__)
SDL_GL_SwapBuffers();
#endif
#ifdef __PERMIT_GL_LOGGING
if (__glLog == true)
{
DGL_LogNewFrame();
}
#endif
#ifdef __CHECK_FOR_TOO_SLOW_RENDERING__
if (minimumAcceptableRender > 0)
{
Uint32 newticks = SDL_GetTicks();
if ((newticks - lastSwapTicks) > minimumAcceptableRender)
{
tooSlowCount++;
if (tooSlowCount >= 3)
{
slownessAbort();
} // if
} // if
// disable check?
tooSlowChecksLeft--;
if (tooSlowChecksLeft <= 0)
{
minimumAcceptableRender = -1;
}
lastSwapTicks = newticks;
} // if
#endif
}
void rend_EndFrame(void)
{
}
// draws a scaled 2d bitmap to our buffer
void rend_DrawScaledBitmap(int x1,int y1,int x2,int y2,
int bm,float u0,float v0,float u1,float v1,int color,float *alphas)
{
g3Point *ptr_pnts[4];
g3Point pnts[4];
float r,g,b;
if (color!=-1)
{
r=GR_COLOR_RED(color)/255.0;
g=GR_COLOR_GREEN(color)/255.0;
b=GR_COLOR_BLUE(color)/255.0;
}
for (int i=0;i<4;i++)
{
if (color==-1)
pnts[i].p3_l=1.0;
else
{
pnts[i].p3_r=r;
pnts[i].p3_g=g;
pnts[i].p3_b=b;
}
if (alphas)
{
pnts[i].p3_a=alphas[i];
}
pnts[i].p3_z=1.0f;
pnts[i].p3_flags=PF_PROJECTED;
}
pnts[0].p3_sx=x1;
pnts[0].p3_sy=y1;
pnts[0].p3_u=u0;
pnts[0].p3_v=v0;
pnts[1].p3_sx=x2;
pnts[1].p3_sy=y1;
pnts[1].p3_u=u1;
pnts[1].p3_v=v0;
pnts[2].p3_sx=x2;
pnts[2].p3_sy=y2;
pnts[2].p3_u=u1;
pnts[2].p3_v=v1;
pnts[3].p3_sx=x1;
pnts[3].p3_sy=y2;
pnts[3].p3_u=u0;
pnts[3].p3_v=v1;
ptr_pnts[0]=&pnts[0];
ptr_pnts[1]=&pnts[1];
ptr_pnts[2]=&pnts[2];
ptr_pnts[3]=&pnts[3];
rend_SetTextureType( TT_LINEAR );
rend_DrawPolygon2D( bm, ptr_pnts, 4 );
}
// Sets where the software renderer should write to
void rend_SetSoftwareParameters(float aspect,int width,int height,int pitch,ubyte *framebuffer)
{
}
// Sets the state of bilinear filtering for our textures
void rend_SetFiltering(sbyte state)
{
#ifndef RELEASE
if (Fast_test_render)
{
state=0;
}
#endif
OpenGL_state.cur_bilinear_state=state;
}
// Sets the state of z-buffering to on or off
void rend_SetZBufferState(sbyte state)
{
#ifndef RELEASE
if (Fast_test_render)
{
state=0;
}
#endif
if (state==OpenGL_state.cur_zbuffer_state)
return; // No redundant state setting
OpenGL_sets_this_frame[5]++;
OpenGL_state.cur_zbuffer_state=state;
// mprintf ((0,"OPENGL: Setting zbuffer state to %d.\n",state));
if (state)
{
dglEnable (GL_DEPTH_TEST);
dglDepthFunc (GL_LEQUAL);
}
else
{
dglDisable (GL_DEPTH_TEST);
}
CHECK_ERROR(14)
}
// Sets the near and far planes for z buffer
void rend_SetZValues(float nearz,float farz)
{
OpenGL_state.cur_near_z = nearz;
OpenGL_state.cur_far_z = farz;
// mprintf ((0,"OPENGL:Setting depth range to %f - %f\n",nearz,farz));
//JEFF: glDepthRange must take parameters [0,1]
//It is set in init
//@@dglDepthRange (0,farz);
}
// Sets a bitmap as a overlay map to rendered on top of the next texture map
// a -1 value indicates no overlay map
void rend_SetOverlayMap(int handle)
{
Overlay_map=handle;
}
void rend_SetOverlayType(ubyte type)
{
Overlay_type=type;
}
// Clears the display to a specified color
void rend_ClearScreen(ddgr_color color)
{
int r=(color>>16 & 0xFF);
int g=(color>>8 & 0xFF);
int b=(color & 0xFF);
dglClearColor ((float)r/255.0f,(float)g/255.0f,(float)b/255.0f,0);
dglClear (GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
}
// Clears the zbuffer for the screen
void rend_ClearZBuffer(void)
{
dglClear(GL_DEPTH_BUFFER_BIT);
}
// Clears the zbuffer for the screen
void rend_ResetCache(void)
{
mprintf((0,"Resetting texture cache!\n"));
opengl_ResetCache ();
}
// Fills a rectangle on the display
void rend_FillRect(ddgr_color color,int x1,int y1,int x2,int y2)
{
int r=GR_COLOR_RED(color);
int g=GR_COLOR_GREEN(color);
int b=GR_COLOR_BLUE(color);
int width=x2-x1;
int height=y2-y1;
x1+=OpenGL_state.clip_x1;
y1+=OpenGL_state.clip_y1;
dglEnable (GL_SCISSOR_TEST);
dglScissor (x1,OpenGL_state.screen_height-(height+y1),width,height);
dglClearColor ((float)r/255.0,(float)g/255.0,(float)b/255.0,0);
dglClear (GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
width=OpenGL_state.clip_x2-OpenGL_state.clip_x1;
height=OpenGL_state.clip_y2-OpenGL_state.clip_y1;
dglScissor (OpenGL_state.clip_x1,OpenGL_state.screen_height-(OpenGL_state.clip_y1+height),width,height);
dglDisable (GL_SCISSOR_TEST);
}
// Sets a pixel on the display
void rend_SetPixel(ddgr_color color,int x,int y)
{
int r=(color>>16 & 0xFF);
int g=(color>>8 & 0xFF);
int b=(color & 0xFF);
g3_RefreshTransforms(true);
dglColor3ub (r,g,b);
dglBegin (GL_POINTS);
dglVertex2i (x,y);
dglEnd();
}
// Sets a pixel on the display
ddgr_color rend_GetPixel(int x,int y)
{
ddgr_color color[4];
dglReadPixels (x,(OpenGL_state.screen_height-1)-y,1,1,GL_RGBA,GL_UNSIGNED_BYTE,(GLvoid *)color);
return color[0];
}
void rend_FillCircle(ddgr_color col, int x, int y, int rad)
{
}
void rend_DrawCircle(int x, int y, int rad)
{
}
// Sets up a font character to draw. We draw our fonts as pieces of textures
void rend_DrawFontCharacter(int bm_handle,int x1,int y1,int x2,int y2,float u,float v,float w,float h)
{
g3Point *ptr_pnts[4];
g3Point pnts[4];
for (int i=0;i<4;i++)
{
pnts[i].p3_z=1; // Make REALLY close!
pnts[i].p3_flags=PF_PROJECTED;
ptr_pnts[i]=&pnts[i];
}
pnts[0].p3_sx=x1;
pnts[0].p3_sy=y1;
pnts[0].p3_u=u;
pnts[0].p3_v=v;
pnts[1].p3_sx=x2;
pnts[1].p3_sy=y1;
pnts[1].p3_u=u+w;
pnts[1].p3_v=v;
pnts[2].p3_sx=x2;
pnts[2].p3_sy=y2;
pnts[2].p3_u=u+w;
pnts[2].p3_v=v+h;
pnts[3].p3_sx=x1;
pnts[3].p3_sy=y2;
pnts[3].p3_u=u;
pnts[3].p3_v=v+h;
rend_DrawPolygon2D(bm_handle,ptr_pnts,4);
}
// Draws a line
void rend_DrawLine(int x1,int y1,int x2,int y2)
{
sbyte atype;
light_state ltype;
texture_type ttype;
int color=OpenGL_state.cur_color;
g3_RefreshTransforms(true);
int r=GR_COLOR_RED(color);
int g=GR_COLOR_GREEN(color);
int b=GR_COLOR_BLUE(color);
atype=OpenGL_state.cur_alpha_type;
ltype=OpenGL_state.cur_light_state;
ttype=OpenGL_state.cur_texture_type;
rend_SetAlphaType (AT_ALWAYS);
rend_SetLighting (LS_NONE);
rend_SetTextureType (TT_FLAT);
dglBegin (GL_LINES);
dglColor4ub (r,g,b,255);
dglVertex2i (x1+OpenGL_state.clip_x1,y1+OpenGL_state.clip_y1);
dglColor4ub (r,g,b,255);
dglVertex2i (x2+OpenGL_state.clip_x1,y2+OpenGL_state.clip_y1);
dglEnd();
rend_SetAlphaType (atype);
rend_SetLighting(ltype);
rend_SetTextureType (ttype);
}
// Sets the argb characteristics of the font characters. color1 is the upper left and proceeds clockwise
void rend_SetCharacterParameters (ddgr_color color1,ddgr_color color2,ddgr_color color3,ddgr_color color4)
{
rend_FontRed[0]=(float)(GR_COLOR_RED(color1)/255.0f);
rend_FontRed[1]=(float)(GR_COLOR_RED(color2)/255.0f);
rend_FontRed[2]=(float)(GR_COLOR_RED(color3)/255.0f);
rend_FontRed[3]=(float)(GR_COLOR_RED(color4)/255.0f);
rend_FontGreen[0]=(float)(GR_COLOR_GREEN(color1)/255.0f);
rend_FontGreen[1]=(float)(GR_COLOR_GREEN(color2)/255.0f);
rend_FontGreen[2]=(float)(GR_COLOR_GREEN(color3)/255.0f);
rend_FontGreen[3]=(float)(GR_COLOR_GREEN(color4)/255.0f);
rend_FontBlue[0]=(float)(GR_COLOR_BLUE(color1)/255.0f);
rend_FontBlue[1]=(float)(GR_COLOR_BLUE(color2)/255.0f);
rend_FontBlue[2]=(float)(GR_COLOR_BLUE(color3)/255.0f);
rend_FontBlue[3]=(float)(GR_COLOR_BLUE(color4)/255.0f);
rend_FontAlpha[0]=(color1>>24)/255.0f;
rend_FontAlpha[1]=(color2>>24)/255.0f;
rend_FontAlpha[2]=(color3>>24)/255.0f;
rend_FontAlpha[3]=(color4>>24)/255.0f;
}
// Sets the color of fog
void rend_SetFogColor(ddgr_color color)
{
if (color==OpenGL_state.cur_fog_color)
return;
float fc[4];
fc[0]=GR_COLOR_RED(color);
fc[1]=GR_COLOR_GREEN(color);
fc[2]=GR_COLOR_BLUE(color);
fc[3]=1;
fc[0]/=255.0f;
fc[1]/=255.0f;
fc[2]/=255.0f;
dglFogfv (GL_FOG_COLOR,fc);
}
// Sets the lighting state of opengl
void rend_SetLightingState(light_state state)
{
if (state==OpenGL_state.cur_light_state)
return; // No redundant state setting
if (UseMultitexture && Last_texel_unit_set!=0)
{
#if (defined(_USE_OGL_ACTIVE_TEXTURES))
oglActiveTextureARB (GL_TEXTURE0_ARB+0);
Last_texel_unit_set=0;
#endif
}
OpenGL_sets_this_frame[4]++;
switch (state)
{
case LS_NONE:
dglShadeModel (GL_SMOOTH);
OpenGL_state.cur_light_state=LS_NONE;
break;
case LS_FLAT_GOURAUD:
dglShadeModel (GL_SMOOTH);
OpenGL_state.cur_light_state=LS_FLAT_GOURAUD;
break;
case LS_GOURAUD:
case LS_PHONG:
dglShadeModel (GL_SMOOTH);
OpenGL_state.cur_light_state=LS_GOURAUD;
break;
default:
Int3();
break;
}
CHECK_ERROR(13)
}
void rend_SetAlphaType(sbyte atype)
{
if (atype==OpenGL_state.cur_alpha_type)
return; // don't set it redundantly
#if (defined(_USE_OGL_ACTIVE_TEXTURES))
if (UseMultitexture && Last_texel_unit_set!=0)
{
oglActiveTextureARB (GL_TEXTURE0_ARB+0);
Last_texel_unit_set=0;
}
#endif
OpenGL_sets_this_frame[6]++;
if (atype==AT_ALWAYS)
{
if (opengl_Blending_on)
{
dglDisable (GL_BLEND);
opengl_Blending_on=false;
}
}
else
{
if (!opengl_Blending_on)
{
dglEnable (GL_BLEND);
opengl_Blending_on=true;
}
}
switch (atype)
{
case AT_ALWAYS:
rend_SetAlphaValue (255);
dglBlendFunc (GL_ONE,GL_ZERO);
break;
case AT_CONSTANT:
dglBlendFunc (GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA);
break;
case AT_TEXTURE:
rend_SetAlphaValue (255);
dglBlendFunc (GL_ONE,GL_ZERO);
break;
case AT_CONSTANT_TEXTURE:
dglBlendFunc (GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA);
break;
case AT_VERTEX:
dglBlendFunc (GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA);
break;
case AT_CONSTANT_TEXTURE_VERTEX:
case AT_CONSTANT_VERTEX:
dglBlendFunc (GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA);
break;
case AT_TEXTURE_VERTEX:
dglBlendFunc (GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA);
break;
case AT_LIGHTMAP_BLEND:
dglBlendFunc (GL_DST_COLOR,GL_ZERO);
break;
case AT_SATURATE_TEXTURE:
case AT_LIGHTMAP_BLEND_SATURATE:
dglBlendFunc (GL_SRC_ALPHA,GL_ONE);
break;
case AT_SATURATE_VERTEX:
dglBlendFunc (GL_SRC_ALPHA,GL_ONE);
break;
case AT_SATURATE_CONSTANT_VERTEX:
dglBlendFunc (GL_SRC_ALPHA,GL_ONE);
break;
case AT_SATURATE_TEXTURE_VERTEX:
dglBlendFunc (GL_SRC_ALPHA,GL_ONE);
break;
case AT_SPECULAR:
break;
default:
Int3(); // no type defined,get jason
break;
}
OpenGL_state.cur_alpha_type=atype;
Alpha_multiplier=opengl_GetAlphaMultiplier();
CHECK_ERROR(15)
}
// Sets the alpha value for constant alpha
void rend_SetAlphaValue(ubyte val)
{
OpenGL_state.cur_alpha=val;
Alpha_multiplier=opengl_GetAlphaMultiplier();
}
// Sets the overall alpha scale factor (all alpha values are scaled by this value)
// usefull for motion blur effect
void rend_SetAlphaFactor(float val)
{
if(val<0.0f) val = 0.0f;
if(val>1.0f) val = 1.0f;
OpenGL_Alpha_factor = val;
}
// Returns the current Alpha factor
float rend_GetAlphaFactor(void)
{
return OpenGL_Alpha_factor;
}
// Sets the texture wrapping type
void rend_SetWrapType(wrap_type val)
{
OpenGL_state.cur_wrap_type=val;
}
// Draws a line using the states of the renderer
void rend_DrawSpecialLine(g3Point *p0,g3Point *p1)
{
g3_RefreshTransforms(true);
int x_add=OpenGL_state.clip_x1;
int y_add=OpenGL_state.clip_y1;
float fr,fg,fb,alpha;
int i;
fr=GR_COLOR_RED(OpenGL_state.cur_color);
fg=GR_COLOR_GREEN(OpenGL_state.cur_color);
fb=GR_COLOR_BLUE(OpenGL_state.cur_color);
fr/=255.0f;
fg/=255.0f;
fb/=255.0f;
alpha=Alpha_multiplier*OpenGL_Alpha_factor;
// And draw!
dglBegin (GL_LINES);
for (i=0;i<2;i++)
{
g3Point *pnt=p0;
if (i==1)
pnt=p1;
if (OpenGL_state.cur_alpha_type & ATF_VERTEX)
alpha=pnt->p3_a*Alpha_multiplier*OpenGL_Alpha_factor;
// If we have a lighting model, apply the correct lighting!
if (OpenGL_state.cur_light_state!=LS_NONE)
{
if (OpenGL_state.cur_light_state==LS_FLAT_GOURAUD)
{
dglColor4f (fr,fg,fb,alpha);
}
else
{
// Do lighting based on intesity (MONO) or colored (RGB)
if (OpenGL_state.cur_color_model==CM_MONO)
dglColor4f (pnt->p3_l,pnt->p3_l,pnt->p3_l,alpha);
else
{
dglColor4f (pnt->p3_r,pnt->p3_g,pnt->p3_b,alpha);
}
}
}
else
{
dglColor4f (fr,fg,fb,alpha);
}
// Finally, specify a vertex
float z = max(0,min(1.0,1.0-(1.0/(pnt->p3_z+Z_bias))));
dglVertex3f (pnt->p3_sx+x_add,pnt->p3_sy+y_add,-z);
}
dglEnd();
}
// Takes a screenshot of the current frame and puts it into the handle passed
void rend_Screenshot(int bm_handle)
{
ushort *dest_data;
uint *temp_data;
int i,t;
int total=OpenGL_state.screen_width*OpenGL_state.screen_height;
ASSERT((bm_w(bm_handle,0))==OpenGL_state.screen_width);
ASSERT((bm_h(bm_handle,0))==OpenGL_state.screen_height);
int w=bm_w(bm_handle,0);
int h=bm_h(bm_handle,0);
temp_data=(uint *)mem_malloc (total*4);
ASSERT (temp_data); // Ran out of memory?
dest_data=bm_data (bm_handle,0);
dglReadPixels (0,0,OpenGL_state.screen_width,OpenGL_state.screen_height,GL_RGBA,GL_UNSIGNED_BYTE,(GLvoid *)temp_data);
for (i=0;i<h;i++)
{
for (t=0;t<w;t++)
{
uint spix=temp_data[i*w+t];
int r=spix & 0xff;
int g=(spix>>8) & 0xff;
int b=(spix>>16) & 0xff;
dest_data[(((h-1)-i)*w)+t]=GR_RGB16(r,g,b);
}
}
mem_free(temp_data);
}
void rend_SetZBias(float z_bias)
{
if( Z_bias != z_bias )
{
Z_bias=z_bias;
// Force refresh our transforms to take the Zbias into account
g3_GetModelViewMatrix( &View_position, &Unscaled_matrix, (float*)gTransformModelView );
g3_UpdateFullTransform();
g3_ForceTransformRefresh();
}
}
// Enables/disables writes the depth buffer
void rend_SetZBufferWriteMask(int state)
{
OpenGL_sets_this_frame[5]++;
if(state)
{
dglDepthMask(GL_TRUE);
}
else
{
dglDepthMask(GL_FALSE);
}
}
// Gets a pointer to a linear frame buffer
void rend_GetLFBLock(renderer_lfb *lfb)
{
}
// Releases an lfb lock
void rend_ReleaseLFBLock(renderer_lfb *lfb)
{
}
// Returns the aspect ratio of the physical screen
void rend_GetProjectionParameters(int *width,int *height)
{
*width=OpenGL_state.clip_x2-OpenGL_state.clip_x1;
*height=OpenGL_state.clip_y2-OpenGL_state.clip_y1;
}
void rend_GetProjectionScreenParameters( int &screenLX, int &screenTY, int &screenW, int &screenH )
{
screenLX = OpenGL_state.clip_x1;
screenTY = OpenGL_state.clip_y1;
screenW = OpenGL_state.clip_x2 - OpenGL_state.clip_x1 + 1;
screenH = OpenGL_state.clip_y2 - OpenGL_state.clip_y1 + 1;
}
// Returns the aspect ratio of the physical screen
float rend_GetAspectRatio(void)
{
float aspect_ratio = (float)((3.0f * OpenGL_state.screen_width)/(4.0f * OpenGL_state.screen_height));
return aspect_ratio;
}
// Given a source x,y and width,height, draws any sized bitmap into the renderer lfb
void rend_DrawLFBBitmap(int sx,int sy,int w,int h,int dx,int dy,ushort *data,int rowsize)
{
}
// given a chunked bitmap, renders it.
void rend_DrawChunkedBitmap(chunked_bitmap *chunk, int x, int y, ubyte alpha)
{
int *bm_array = chunk->bm_array;
int w = chunk->w;
int h = chunk->h;
int piece_w=bm_w(bm_array[0],0);
int piece_h=bm_h(bm_array[0],0);
int screen_w, screen_h;
int i,t;
rend_SetZBufferState (0);
rend_GetProjectionParameters(&screen_w, &screen_h);
for (i=0;i<h;i++)
{
for (t=0;t<w;t++)
{
int dx=x+(piece_w*t);
int dy=y+(piece_h*i);
int dw,dh;
if ((dx+piece_w)>screen_w)
dw=piece_w-((dx+piece_w)-screen_w);
else
dw=piece_w;
if ((dy+piece_h)>screen_h)
dh=piece_h-((dy+piece_h)-screen_h);
else
dh=piece_h;
float u2=(float)dw/(float)piece_w;
float v2=(float)dh/(float)piece_h;
rend_DrawSimpleBitmap(bm_array[i*w+t],dx,dy);
}
}
rend_SetZBufferState (1);
}
// given a chunked bitmap, renders it.scaled
void rend_DrawScaledChunkedBitmap(chunked_bitmap *chunk, int x, int y, int neww, int newh, ubyte alpha)
{
int *bm_array = chunk->bm_array;
int w = chunk->w;
int h = chunk->h;
int piece_w;
int piece_h;
int screen_w, screen_h;
int i,t;
float scalew,scaleh;
scalew = ((float)neww)/((float)chunk->pw);
scaleh = ((float)newh)/((float)chunk->ph);
piece_w = scalew * ((float)bm_w(bm_array[0],0));
piece_h = scaleh * ((float)bm_h(bm_array[0],0));
rend_GetProjectionParameters(&screen_w, &screen_h);
rend_SetOverlayType (OT_NONE);
rend_SetLighting (LS_NONE);
rend_SetColorModel (CM_MONO);
rend_SetZBufferState (0);
rend_SetAlphaType (AT_CONSTANT_TEXTURE);
rend_SetAlphaValue (alpha);
rend_SetWrapType (WT_WRAP);
for (i=0;i<h;i++)
{
for (t=0;t<w;t++)
{
int dx=x+(piece_w*t);
int dy=y+(piece_h*i);
int dw,dh;
if ((dx+piece_w)>screen_w)
dw=piece_w-((dx+piece_w)-screen_w);
else
dw=piece_w;
if ((dy+piece_h)>screen_h)
dh=piece_h-((dy+piece_h)-screen_h);
else
dh=piece_h;
float u2=(float)dw/(float)piece_w;
float v2=(float)dh/(float)piece_h;
rend_DrawScaledBitmap(dx,dy,dx+dw,dy+dh,bm_array[i*w+t],0,0,u2,v2);
}
}
rend_SetZBufferState (1);
}
// Sets some global preferences for the renderer
int rend_SetPreferredState(renderer_preferred_state *pref_state)
{
int retval = 1;
renderer_preferred_state old_state = OpenGL_preferred_state;
OpenGL_preferred_state = *pref_state;
if( OpenGL_state.initted )
{
int reinit = 0;
mprintf ((0,"Inside pref state!\n"));
// Change gamma if needed
if( pref_state->width!=OpenGL_state.screen_width || pref_state->height!=OpenGL_state.screen_height || old_state.bit_depth!=pref_state->bit_depth)
{
reinit=1;
}
if( reinit )
{
opengl_Close();
retval = opengl_Init( NULL, &OpenGL_preferred_state );
}
else
{
if( old_state.gamma !=pref_state->gamma )
{
opengl_SetGammaValue( pref_state->gamma );
}
}
}
else
{
OpenGL_preferred_state = *pref_state;
}
return retval;
}
// Sets the gamma for this display
void rend_SetGammaValue(float val)
{
}
// Draws a simple bitmap at the specified x,y location
void rend_DrawSimpleBitmap(int bm_handle,int x,int y)
{
rend_SetAlphaType(AT_CONSTANT_TEXTURE);
rend_SetAlphaValue(255);
rend_SetLighting(LS_NONE);
rend_SetColorModel(CM_MONO);
rend_SetOverlayType(OT_NONE);
rend_SetFiltering(0);
rend_DrawScaledBitmap(x,y,x+bm_w(bm_handle,0),y+bm_h(bm_handle,0),bm_handle,0,0,1,1);
rend_SetFiltering(1);
}
// Fills in the passed in pointer with the current rendering state
void rend_GetRenderState(rendering_state *rstate)
{
memcpy( rstate, &OpenGL_state, sizeof(rendering_state) );
}
// Takes a bitmap and blits it to the screen using linear frame buffer stuff
// X and Y are the destination X,Y
void rend_CopyBitmapToFramebuffer(int bm_handle,int x,int y)
{
ASSERT( opengl_Framebuffer_ready );
if( opengl_Framebuffer_ready == 1 )
{
bm_CreateChunkedBitmap( bm_handle, &opengl_Chunked_bitmap );
opengl_Framebuffer_ready = 2;
}
else
{
opengl_ChangeChunkedBitmap( bm_handle, &opengl_Chunked_bitmap );
}
rend_DrawChunkedBitmap( &opengl_Chunked_bitmap, 0, 0, 255 );
}
// Gets a renderer ready for a framebuffer copy, or stops a framebuffer copy
void rend_SetFrameBufferCopyState(bool state)
{
if( state )
{
ASSERT( opengl_Framebuffer_ready == 0 );
opengl_Framebuffer_ready = 1;
}
else
{
ASSERT( opengl_Framebuffer_ready != 0 );
opengl_Framebuffer_ready = 0;
if( opengl_Framebuffer_ready == 2 )
{
bm_DestroyChunkedBitmap( &opengl_Chunked_bitmap );
opengl_ResetCache();
}
}
}
// Changes the resolution of the renderer
void rend_SetResolution(int width,int height)
{
}
// Gets OpenGL ready to work in a window
int rend_InitOpenGLWindow (oeApplication *app,renderer_preferred_state *pref_state)
{
WindowGL = 1;
return opengl_Init( app, pref_state );
}
// Shuts down OpenGL in a window
void rend_CloseOpenGLWindow(void)
{
opengl_Close();
WindowGL=0;
OpenGL_window_initted=0;
mprintf ((1,"SHUTTING DOWN WINDOWED OPENGL!"));
}
// Sets the hardware bias level for coplanar polygons
// This helps reduce z buffer artifacts
void rend_SetCoplanarPolygonOffset(float factor)
{
if( factor == 0.0f )
{
dglDisable( GL_POLYGON_OFFSET_FILL );
}
else
{
dglEnable( GL_POLYGON_OFFSET_FILL );
dglPolygonOffset( -1.0f, -1.0f );
}
}
// Preuploads a texture to the video card
void rend_PreUploadTextureToCard(int handle,int map_type)
{
}
// Frees an uploaded texture from the video card
void rend_FreePreUploadedTexture(int handle,int map_type)
{
}
// Retrieves an error message
char *rend_GetErrorMessage ()
{
return (char *)Renderer_error_message;
}
// Sets an error message
void rend_SetErrorMessage (char *str)
{
ASSERT( strlen(str) < 256 );
strcpy( Renderer_error_message, str );
}
// Returns 1 if there is mid video memory, 2 if there is low vid memory, or 0 if there is large vid memory
int rend_LowVidMem(void)
{
return 0;
}
// Returns 1 if the renderer supports bumpmapping
int rend_SupportsBumpmapping(void)
{
return 0;
}
// Sets a bumpmap to be rendered, or turns off bumpmapping altogether
void rend_SetBumpmapReadyState(int state,int map)
{
}
// returns the direct draw object
void *rend_RetrieveDirectDrawObj(void **frontsurf, void **backsurf)
{
*frontsurf = NULL;
*backsurf = NULL;
return NULL;
}
// returns rendering statistics for the frame
void rend_GetStatistics(tRendererStats *stats)
{
if( Renderer_initted )
{
stats->poly_count = OpenGL_last_frame_polys_drawn;
stats->vert_count = OpenGL_last_frame_verts_processed;
stats->texture_uploads = OpenGL_last_uploaded;
}
else
{
memset( stats, 0, sizeof(tRendererStats) );
}
}
void rend_TransformSetToPassthru(void)
{
int width = OpenGL_state.screen_width;
int height = OpenGL_state.screen_height;
// Projection
dglMatrixMode(GL_PROJECTION);
dglLoadIdentity();
dglOrtho( (GLfloat)0.0f, (GLfloat)(width), (GLfloat)(height), (GLfloat)0.0f, 0.0f, 1.0f);
// Viewport
dglViewport( 0, 0, width, height);
// ModelView
dglMatrixMode(GL_MODELVIEW);
dglLoadIdentity();
}
void rend_TransformSetViewport( int lx, int ty, int width, int height )
{
dglViewport( lx, OpenGL_state.screen_height - (ty + height - 1), width, height);
}
void rend_TransformSetProjection( float trans[4][4] )
{
dglMatrixMode( GL_PROJECTION );
dglLoadMatrixf( &trans[0][0] );
}
void rend_TransformSetModelView( float trans[4][4] )
{
dglMatrixMode( GL_MODELVIEW );
dglLoadMatrixf( &trans[0][0] );
}
#endif
Reference in New Issue View Git Blame Copy Permalink