void GL_GenerateFBO(GLuint texId, GLuint *fboId, int w, int h) {
GLuint cRboId;
Console_Printf(" Generate FBO %dx%d. ", w, h);
glGenFramebuffersEXT(1, fboId);
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, *fboId);
if(vid_multisample.integer && gl_ext_framebuffer_multisample.integer) {
Console_Printf("(MSAA) ");
glGenRenderbuffersEXT(1, &cRboId);
glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, cRboId);
glRenderbufferStorageMultisampleEXT(GL_RENDERBUFFER_EXT, vid_multisample.integer, GL_RGBA, w, h);
glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_RENDERBUFFER_EXT, cRboId);
}
glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_2D, texId, 0);
//glDrawBuffer(GL_FRONT);
//glReadBuffer(GL_FRONT);
GL_CheckFBOStatus();
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
}
unsigned int GL_CheckFBOStatus() {
unsigned int fbo_status = glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT);
if (fbo_status != GL_FRAMEBUFFER_COMPLETE_EXT) {
Cvar_SetVarValue(&gfx_postProcEnabled, 0);
Console_Printf("^rError: framebufferstatus is not complete: ");
switch (fbo_status) {
case GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT_EXT: Console_Printf("GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT_EXT\n");break;
case GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT_EXT: Console_Printf("GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT_EXT\n");break;
case GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS_EXT: Console_Printf("GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS_EXT\n");break;
case GL_FRAMEBUFFER_INCOMPLETE_FORMATS_EXT: Console_Printf("GL_FRAMEBUFFER_INCOMPLETE_FORMATS_EXT\n");break;
case GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER_EXT: Console_Printf("GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER_EXT\n");break;
case GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER_EXT: Console_Printf("GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER_EXT\n");break;
case GL_FRAMEBUFFER_UNSUPPORTED_EXT: Console_Printf("GL_FRAMEBUFFER_UNSUPPORTED_EXT\n");break;
default: Console_Printf("UNKNOWN\n");break;
}
} else {
Console_Printf("^gOK\n");
}
#ifdef DEBUG
assert(fbo_status == GL_FRAMEBUFFER_COMPLETE_EXT);
#endif
return fbo_status;
}
void GL_InitShadow(void)
{
//if( !gl_arb_shadow.integer)
// return;
Cvar_Register(&gfx_shadowSize);
Cvar_Register(&gfx_shadowQuality);
Cvar_Register(&gfx_shadowBias);
Cvar_Register(&gfx_shadow);
Cvar_Register(&gfx_shadowDebug);
Cvar_Register(&gfx_shadowSplitWeight);
Console_Printf("- Initializing Dynamic Shadow Mapping...\n");
if(!GL_VersionAtLeast(2,1) || !GLEW_ARB_depth_texture)
{
Console_Printf(" ^rNo depth texture support!\n");
Console_Printf(" ^rShadows are disabled.\n");
Cvar_SetVarValue(&gfx_shadow, 0);
return;
}
Vid_SetThreadContext();
if(!gl_ext_framebuffer.integer)
{
int resmin = MIN(Vid_GetScreenW(), Vid_GetScreenH());
//if the gfx card can't do non-power-of-two textures, then get the
//largest power of two less than the smaller of the screen dimensions
if(!GLEW_ARB_texture_non_power_of_two)
for(int x=11;x>7;x--) //from 2048 down to 256
if(1<<x<=resmin)
{
resmin=1<<x;
break;
}
resmin = MIN(resmin, gfx_shadowSize.integer);
Cvar_SetVarValue(&gfx_shadowSize, resmin);
}
Console_Printf(" Shadow map size: %dx%d\n", gfx_shadowSize.integer, gfx_shadowSize.integer);
//now that we've got all that taken care of...
shadowTarget = new GLDepthRenderTarget(gfx_shadowSize.integer, gfx_shadowSize.integer, MAX_SPLITS);
for(int i=0;i<MAX_SPLITS;i++) {
shadowFrusta[i].fov = 45.0f/57.2957795f + 0.2f;
shadowFrusta[i].ratio = 1.0f;
//shadowFrusta[i].ratio = Vid_GetScreenW()/(float)Vid_GetScreenH();
}
GL_SwitchTexUnit(GL_TEXTURE0_ARB);
}
bool GL_SDL_SetGammaValue(float gamma)
{
if (gamma < 0.1)
{
Console_Printf("Invalid gamma value of %f\n", gamma);
return false;
}
return (SDL_SetGamma(gamma, gamma, gamma) == 0); //0 == success
}
boolean ACPI_Enable() {
ACPI_FADT* fadt = ACPI_FADT_GetInstance();
if(ACPI_FADT_IsValid()) {
outb(fadt->SMI_CommandPort,fadt->AcpiEnable);
Console_Printf("SMI_PORT %x, ENABLED %x, FADT Is Valid %d \r\n",(int)fadt->SMI_CommandPort,(int)fadt->AcpiEnable,ACPI_FADT_IsValid());
return True;
} else {
return False;
}
}
void Scene_Init()
{
Console_Printf("- Initializing World Engine...\n");
Cvar_Register(&gfx_lod1range);
Cvar_Register(&gfx_lod2range);
Cvar_Register(&gfx_lod3range);
Cvar_Register(&gfx_fog);
Cvar_Register(&gfx_fog_near);
Cvar_Register(&gfx_fog_far);
Cvar_Register(&gfx_fogr);
Cvar_Register(&gfx_fogg);
Cvar_Register(&gfx_fogb);
Cvar_Register(&gfx_farclip);
#ifndef DEDICATED_SERVER
Cvar_Register(&gfx_nearclip);
Cvar_Register(&gfx_polycount);
Cvar_Register(&gfx_sky);
Cvar_Register(&gfx_skycirrus);
Cvar_Register(&gfx_soundSpace);
Cvar_Register(&gfx_objects);
Cvar_Register(&gfx_toon);
Cvar_Register(&gfx_lockfrustum);
Cvar_Register(&gfx_dbgplanes);
Cvar_Register(&gfx_selectionScale);
Cvar_Register(&gfx_nocull);
Cvar_Register(&gfx_sceneStats);
Cvar_Register(&gfx_dynamicLighting);
Cvar_Register(&gfx_maxDLights);
Cvar_Register(&gfx_occlusion);
Cvar_Register(&gfx_maxSceneOccluders);
Cvar_Register(&gfx_drawOccluders);
//! CASE
Cvar_Register(&xr_cullMeshes);
Cvar_Register(&gfx_terrain_farclip);
Cmd_Register("raytrace", Scene_Raytrace_Cmd);
Scene_Clear();
if (!dedicated_server.integer)
{
Vid_InitScene();
Scene_InitFramePool();
}
for(int i=0;i<4;i++) {
wind_waves[i].amplitude = 0.8+M_Randnum(-0.2,0.3);
wind_waves[i].wavelength = M_Randnum(200,400);
wind_waves[i].speed = M_Randnum(1.1f,1.5f);
}
#endif
}
void print_backtrace(int signum)
{
#ifdef linux
void *bt_array[BACKTRACE_SIZE]; // Static means always allocated
int size = BACKTRACE_SIZE, i; // == probably safer
const char *signame;
char **symbols;
size = backtrace(bt_array, BACKTRACE_SIZE);
symbols = backtrace_symbols(bt_array, size); // Print out symbol names on stderr
switch(signum) {
case SIGILL: signame = "SIGILL"; break;
//case SIGQUIT: signame = "SIGQUIT"; break;
case SIGABRT: signame = "SIGABRT"; break;
case SIGFPE: signame = "SIGFPE"; break;
case SIGSEGV: signame = "SIGSEGV"; break;
case SIGBUS: signame = "SIGBUS"; break;
#ifdef SIGSYS
case SIGSYS: signame = "SIGSYS"; break;
#endif
default: signame = "(unexpected)"; break;
}
printf("Signal ");
Console_Printf("Signal ");
printf(signame);
Console_Printf(signame);
printf(" received.\n");
Console_Printf(" received.\n\n"
"Stack dump:\n{\n" );
for (i = 0; i < size; i++ ) {
Console_Printf("\t");
if(symbols[i]) {
Console_Printf(symbols[i]);
} else {
Console_Printf((const char*)bt_array[i]);
}
Console_Printf("\n");
}
Console_Printf("}\n\n" );
Host_CloseLogFiles();//make sure log files are written
#endif
SDL_Quit();
exit(127+signum);
}
//initializes an OpenGL rendering context and window
int GL_SDL_Init ()
{
if ( SDL_InitSubSystem(SDL_INIT_VIDEO) < 0 )
{
Console_Printf("Warning, couldn't initialize video, I hope this is a dedicated server\n");
}
if (!gl_mode_num)
GL_SDL_GetGLModes();
Cvar_Register(&vid_mode0_width);
Cvar_Register(&vid_mode0_height);
Cvar_Register(&vid_mode0_bpp);
return 1;
}
void GL_SDL_SetGamma(float gamma, float overbright)
{
Uint16 ramp[256*3];
float brightness=0;
int i;
for (i=0 ; i<256 ; i++){
float f = (float) (255 * pow ( (float)i/255.0 , 1/gamma ));
f = (f+brightness) * overbright;
if (f < 0) f = 0;
if (f > 255) f = 255;
ramp[i+0] = ramp[i+256] = ramp[i+512] = (unsigned short) (iround(f)<<8);
}
if (!SDL_SetGammaRamp(ramp, ramp, ramp))
{
Console_Printf("GL_SDL_SetGamma() failed\n");
}
}
//open a socket with the specified port
bool WSock_OpenPort(netconnection_t *nc, int port)
{
unsigned long addr;
NET_PRINTF("WSock_OpenPort(%i)\n", port);
nc->addr.sin_family = AF_INET;
if (strcmp(net_forceIP.string, "0.0.0.0") != 0)
{
addr = inet_addr(net_forceIP.string);
memcpy(&nc->addr.sin_addr, &addr, sizeof(unsigned long));
}
else
{
nc->addr.sin_addr.s_addr = INADDR_ANY;
}
nc->addr.sin_port = htons((unsigned short)port);
if (!WSock_NewSocket(nc))
{
NET_PRINTF("Socket creation failed\n");
return false;
}
if (bind(nc->sock, (const sockaddr*)&(nc->addr), sizeof(struct sockaddr_in)) == SOCKET_ERROR)
{
WSock_CloseNetConnection(nc);
NET_PRINTF("bind() failed (%d)\n", WSAGetLastError());
return false;
}
if (!nc->port)
{
socklen_t namelen = sizeof(struct sockaddr_in);
getsockname(nc->sock, (sockaddr*)(&nc->addr), &namelen);
nc->port = ntohs(nc->addr.sin_port);
Console_Printf("Port %i opened\n", nc->port);
}
return true;
}
bool Font_Init()
{
#ifdef _S2_EXCLUDE_FREETYPE
return true;
#else
int error;
int major, minor, patch;
error = FT_Init_FreeType( &library );
FT_Library_Version(library, &major, &minor, &patch);
if (patch != FREETYPE_PATCH)
{
Console_Printf("freetype headers don't match binary! - compiled against %i.%i.%i!\n", FREETYPE_MAJOR, FREETYPE_MINOR, FREETYPE_PATCH);
}
Console_DPrintf("Initialized freetype library version %i.%i.%i\n", major, minor, patch);
if ( error )
{
System_Error("FreeType initialization error %i\n", error);
return false;
}
return true;
#endif
}
void System_Error(char* msg, ...)
{
va_list argptr;
char s[1024];
/* printf("\n******************** ERROR ********************\n");
va_start(argptr, msg);
vprintf(msg, argptr);
va_end(argptr);
printf("\n***********************************************\n");
*/
va_start(argptr, msg);
vsprintf(s, msg, argptr);
va_end(argptr);
fprintf(stderr, "%s", s);
Console_Printf( "%s", s);
print_backtrace(SIGABRT);
System_ShutDown();
exit(1);
}
void GL_GenerateFBOWithDepth(GLuint texId, GLuint texDepthId, GLuint *fboId, int w, int h) {
//GLuint rboId;
Console_Printf(" Generate FBO w/ Depth %dx%d. ", w, h);
glGenFramebuffersEXT(1, fboId);
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, *fboId);
//glGenRenderbuffersEXT(1, &rboId);
//glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, rboId);
//color
glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_2D, texId, 0);
//depth
//glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, GL_DEPTH_COMPONENT, w, h);
//glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, rboId);
glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_TEXTURE_2D, texDepthId, 0);
GL_CheckFBOStatus();
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
}
//changes the display resolution
int GL_SDL_SetMode( int mode )
{
#ifndef _S2_DONT_INCLUDE_GL
int rgb_size[3];
int w = 800;
int h = 600;
int bpp = 0;
int depth_size = 32, stencil_size = 8;
Uint32 video_flags;
int value, i;
if (mode == 0 || mode == -2)
{
w = gl_modes[0].width = vid_mode0_width.integer;
h = gl_modes[0].height = vid_mode0_height.integer;
bpp = gl_modes[0].bpp = vid_mode0_bpp.integer;
}
else
{
w = gl_modes[mode].width;
h = gl_modes[mode].height;
bpp = gl_modes[mode].bpp;
}
// Initialize the display
switch (bpp) {
case 8:
rgb_size[0] = 2;
rgb_size[1] = 3;
rgb_size[2] = 3;
break;
case 15:
case 16:
rgb_size[0] = 5;
rgb_size[1] = 6;
rgb_size[2] = 5;
break;
default:
rgb_size[0] = 8;
rgb_size[1] = 8;
rgb_size[2] = 8;
break;
}
SDL_GL_SetAttribute( SDL_GL_RED_SIZE, rgb_size[0] );
SDL_GL_SetAttribute( SDL_GL_GREEN_SIZE, rgb_size[1] );
SDL_GL_SetAttribute( SDL_GL_BLUE_SIZE, rgb_size[2] );
SDL_GL_SetAttribute( SDL_GL_STENCIL_SIZE, stencil_size );
SDL_GL_SetAttribute( SDL_GL_DEPTH_SIZE, depth_size );
SDL_GL_SetAttribute( SDL_GL_DOUBLEBUFFER, 1 );
/* Set the flags we want to use for setting the video mode */
video_flags = SDL_OPENGL;
if (mode == -2)
video_flags |= SDL_RESIZABLE;
isFullScreen = false;
if (vid_fullscreen.integer && mode != -2)
{
video_flags |= SDL_FULLSCREEN;
isFullScreen = true;
}
if (vid_multisample.value)
{
SDL_GL_SetAttribute( SDL_GL_MULTISAMPLEBUFFERS, 1);
SDL_GL_SetAttribute( SDL_GL_MULTISAMPLESAMPLES, vid_multisample.integer);
}
i = 0;
if (!silent_vid_mode_change)
Console_Printf("attempting to set the following video mode: %i x %i x %i (%i bit depth buffer)\n", w, h, bpp, depth_size);
while (SDL_SetVideoMode( w, h, bpp, video_flags ) == NULL )
{
switch (i)
{
case 0:
case 1:
if (depth_size <= 8)
{
Console_Printf("Couldn't get at least a 16-bit depth buffer: %s\n", SDL_GetError());
SDL_Quit();
exit(1);
}
//maybe we can't get a depth buffer this large...
depth_size -= 8;
SDL_GL_SetAttribute( SDL_GL_DEPTH_SIZE, depth_size );
break;
case 2:
bpp = 16; //fall back to 16 bit
break;
case 3:
SDL_GL_SetAttribute( SDL_GL_DOUBLEBUFFER, 0 );
break;
default:
Console_Printf("Couldn't set GL mode: %s\n", SDL_GetError());
SDL_Quit();
exit(1);
}
i++;
if (!silent_vid_mode_change)
Console_Printf("attempting to set the following video mode: %i x %i x %i (%i bit depth buffer)\n", w, h, bpp, depth_size);
}
//remember context info for threads
SDL_VERSION(&_sdlinfo.version);
SDL_GetWMInfo(&_sdlinfo);
#ifndef __APPLE__
_sdlinfo.info.x11.lock_func();
_glContext = glXGetCurrentContext();
_sdlinfo.info.x11.unlock_func();
#endif
if (!silent_vid_mode_change)
{
Console_Printf("Screen Res: %d x %d\n", w, h);
Console_Printf("Screen BPP: %d\n", SDL_GetVideoSurface()->format->BitsPerPixel);
Console_Printf("Depth Buffer Size: %d\n", depth_size);
Console_Printf("\n");
/*Console_Printf( "Vendor : %s\n", glGetString( GL_VENDOR ) );
Console_Printf( "Renderer : %s\n", glGetString( GL_RENDERER ) );
Console_Printf( "Version : %s\n", glGetString( GL_VERSION ) );
Console_Printf( "Extensions : %s\n", glGetString( GL_EXTENSIONS ) );
Console_Printf("\n");*/
SDL_GL_GetAttribute( SDL_GL_RED_SIZE, &value );
Console_Printf( "SDL_GL_RED_SIZE: requested %d, got %d\n", rgb_size[0],value);
SDL_GL_GetAttribute( SDL_GL_GREEN_SIZE, &value );
Console_Printf( "SDL_GL_GREEN_SIZE: requested %d, got %d\n", rgb_size[1],value);
SDL_GL_GetAttribute( SDL_GL_BLUE_SIZE, &value );
Console_Printf( "SDL_GL_BLUE_SIZE: requested %d, got %d\n", rgb_size[2],value);
SDL_GL_GetAttribute( SDL_GL_DEPTH_SIZE, &value );
Console_Printf( "SDL_GL_DEPTH_SIZE: requested %d, got %d\n", bpp, value );
SDL_GL_GetAttribute( SDL_GL_DOUBLEBUFFER, &value );
Console_Printf( "SDL_GL_DOUBLEBUFFER: requested 1, got %d\n", value );
SDL_GL_GetAttribute( SDL_GL_STENCIL_SIZE, &value );
Console_Printf( "SDL_GL_STENCIL_SIZE: requested %d, got %d\n", stencil_size, value );
SDL_GL_GetAttribute( SDL_GL_MULTISAMPLEBUFFERS, &value);
Console_Printf( "SDL_GL_MULTISAMPLEBUFFERS: requested %i, got %d\n", vid_multisample.integer ? 1:0, value);
if (value)
{
SDL_GL_GetAttribute( SDL_GL_MULTISAMPLESAMPLES, &value);
Console_Printf( "Using anti-aliasing with %i samples\n", value);
}
else
{
Console_Printf( "Anti-aliasing not enabled\n");
}
/* Set the window manager title bar */
SDL_WM_SetCaption( "Silverback Engine", "Savage: Rebirth" );
}
return mode;
#endif
}
void Scene_Raytrace_Cmd(int argc, char *argv[])
{
#ifndef _S2_DONT_INCLUDE_GL
int x, y;
int width, height;
float ratio_x, ratio_y;
bitmap_t bmp;
float msec;
if (!scene_cam)
return;
if (argc < 2)
{
width = 640;
height = 480;
}
else
{
width = atoi(argv[0]);
height = atoi(argv[1]);
}
ratio_x = scene_cam->width / (float)width;
ratio_y = scene_cam->height / (float)height;
Bitmap_Alloc(&bmp, width, height, BITMAP_RGBA);
msec = System_Milliseconds();
for (y=0; y<height; y++)
{
for (x=0; x<width; x++)
{
vec3_t dir;
vec3_t end;
float light;
traceinfo_t trace;
Cam_ConstructRay(scene_cam, (float)x*ratio_x, (float)y*ratio_y, dir);
M_PointOnLine(scene_cam->origin, dir, gfx_farclip.value, end);
WT_TraceBox_Client(&trace, scene_cam->origin, end, zero_vec, zero_vec, 0);//SURF_TERRAIN);
if (trace.fraction < 1)
{
if (argc == 3)
light = trace.fraction;
else
light = ABS(M_DotProduct(trace.normal, scene_cam->viewaxis[AXIS_FORWARD]));
}
else
{
light = 0;
}
Bitmap_SetPixel4b(&bmp, x, y, (byte)((trace.flags & SURF_TERRAIN) ? 0 : 255)*light, (byte)((trace.flags & SURF_FOLIAGE) ? 255 : 0)*light, (byte)((trace.flags & SURF_TERRAIN) ? 255 : 0)*light, 255);
}
}
Console_Printf("raytrace took %f msec\n", System_Milliseconds() - msec);
Bitmap_WritePNG("raytrace.png", &bmp);
Bitmap_Free(&bmp);
#endif
}
GLDepthRenderTarget::GLDepthRenderTarget(int w, int h, int l):GLRenderTarget() {
GLuint shadowMapTexture=0;
GLuint rboId=0;
width = w;
height = h;
if(!gl_ext_framebuffer.integer)
return;
if(!GLEW_ARB_texture_non_power_of_two) {
width = round2(width);
height = round2(height);
texS = w/(float)width;
texT = h/(float)height;
}
glGenTextures(1, &shadowMapTexture);
if(l && gl_ext_texture_array.integer) {
Console_Printf(" Generate DEPTH ARRAY FBO %dx%dx%d. ", w, h, l);
glBindTexture(GL_TEXTURE_2D_ARRAY, shadowMapTexture);
glTexParameteri( GL_TEXTURE_2D_ARRAY, GL_TEXTURE_MIN_FILTER, GL_LINEAR );
glTexParameteri( GL_TEXTURE_2D_ARRAY, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
glTexParameteri( GL_TEXTURE_2D_ARRAY, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE );
glTexParameteri( GL_TEXTURE_2D_ARRAY, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE );
glTexParameteri( GL_TEXTURE_2D_ARRAY, GL_TEXTURE_COMPARE_FUNC, GL_LEQUAL );
glTexImage3D( GL_TEXTURE_2D_ARRAY, 0, GL_DEPTH_COMPONENT24, width, height, l, 0, GL_DEPTH_COMPONENT, GL_FLOAT, NULL);
glBindTexture(GL_TEXTURE_2D_ARRAY, 0);
glGenFramebuffersEXT(1, &fboId);
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fboId);
glGenRenderbuffersEXT(1, &rboId);
glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, rboId);
glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, GL_DEPTH_COMPONENT, width, height);
// attach a renderbuffer to depth attachment point
glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, rboId);
// attach a texture to FBO depth attachment point
// Big: actually we set the target when we go to use it
//glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_TEXTURE_2D/*_ARRAY*/, shadowMapTexture, 0);
glDrawBuffer(GL_NONE);
glReadBuffer(GL_NONE);
} else if(l==0 && GLEW_ARB_depth_texture) {
Console_Printf(" Generate DEPTH FBO %dx%d. ", w, h);
glBindTexture(GL_TEXTURE_2D, shadowMapTexture);
glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR );
glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE );
glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE );
glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_COMPARE_FUNC, GL_LEQUAL );
//glTexParameteri( GL_TEXTURE_2D, GL_DEPTH_TEXTURE_MODE, GL_LUMINANCE );
//glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_COMPARE_MODE, GL_COMPARE_R_TO_TEXTURE );
glTexImage2D( GL_TEXTURE_2D, 0, GL_DEPTH_COMPONENT24, width, height, 0, GL_DEPTH_COMPONENT, GL_FLOAT, NULL);
glBindTexture(GL_TEXTURE_2D, 0);
glGenFramebuffersEXT(1, &fboId);
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fboId);
glGenRenderbuffersEXT(1, &rboId);
glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, rboId);
glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, GL_DEPTH_COMPONENT, width, height);
// attach a renderbuffer to depth attachment point
glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, rboId);
// attach a texture to FBO depth attachment point
// Big: actually we set the target when we go to use it
//glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_TEXTURE_2D, shadowMapTexture, 0);
glDrawBuffer(GL_NONE);
glReadBuffer(GL_NONE);
}
#ifdef DEBUG
GLSL_catchLastError("GLDepthRenderTarget::GLDepthRenderTarget");
#endif
GL_CheckFBOStatus();
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
//now create a pass for when we go to use this thing
passCount = 1;
passes[0] = new GLMaterialPass(this);
passes[0]->texmaps[0] = shadowMapTexture;
passes[0]->texmap_num = 1;
if(l && gl_ext_texture_array.integer) {
passes[0]->multitexture = true;
passes[0]->arrayTexture = true;
}
}
