zdoom/raze-gles
0
0
Fork 0
mirror of https://github.com/ZDoom/raze-gles.git synced 2024-12-25 19:20:46 +00:00
Code Issues Projects Releases Packages Wiki Activity

Second draft of depth peeling code. It should be in a usable state, although still slow as hell.

Browse source 
git-svn-id: https://svn.eduke32.com/eduke32@446 1a8010ca-5511-0410-912e-c29ae57300e0
This commit is contained in:
Plagman 2007-01-06 01:29:45 +00:00
parent 8a3ca3dbc4
commit 5a7cceb19d
11 changed files with 302 additions and 323 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

5
polymer/build/include/baselayer.h
View file

@ -41,6 +41,11 @@ struct glinfo {
char texnpot; char texnpot;
char multisample; char multisample;
char nvmultisamplehint; char nvmultisamplehint;
char arbfp;
char depthtex;
char shadow;
char fbos;
char rect;
}; };
extern struct glinfo glinfo; extern struct glinfo glinfo;
#endif #endif

2
polymer/build/include/build.h
View file

@ -490,6 +490,8 @@ extern long glusetexcache, glusetexcachecompression;
extern long glmultisample, glnvmultisamplehint; extern long glmultisample, glnvmultisamplehint;
extern long glwidescreen, glprojectionhacks; extern long glwidescreen, glprojectionhacks;
void gltexapplyprops (void); void gltexapplyprops (void);
extern long r_depthpeeling, r_peelscount;
#endif #endif
void hicinit(void); void hicinit(void);

16
polymer/build/include/glbuild.h
View file

@ -30,6 +30,14 @@
# define APIENTRY # define APIENTRY
#endif #endif
// those defines are somehow missing from glext.h
#define GL_FRAMEBUFFER_EXT 0x8D40
#define GL_COLOR_ATTACHMENT0_EXT 0x8CE0
#define GL_DEPTH_ATTACHMENT_EXT 0x8D00
#define GL_FRAMEBUFFER_COMPLETE_EXT 0x8CD5
#define GL_TEXTURE_RECTANGLE 0x84F5
extern void (APIENTRY * bglClearColor)( GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha ); extern void (APIENTRY * bglClearColor)( GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha );
extern void (APIENTRY * bglClear)( GLbitfield mask ); extern void (APIENTRY * bglClear)( GLbitfield mask );
extern void (APIENTRY * bglColorMask)( GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha ); extern void (APIENTRY * bglColorMask)( GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha );
@ -132,10 +140,18 @@ extern void (APIENTRY * bglStencilFunc)(GLenum func, GLint ref, GLuint mask);
extern void (APIENTRY * bglGenProgramsARB)(GLsizei, GLuint *); extern void (APIENTRY * bglGenProgramsARB)(GLsizei, GLuint *);
extern void (APIENTRY * bglBindProgramARB)(GLenum, GLuint); extern void (APIENTRY * bglBindProgramARB)(GLenum, GLuint);
extern void (APIENTRY * bglProgramStringARB)(GLenum, GLenum, GLsizei, const GLvoid *); extern void (APIENTRY * bglProgramStringARB)(GLenum, GLenum, GLsizei, const GLvoid *);
extern void (APIENTRY * bglDeleteProgramsARB)(GLsizei n, const GLuint *programs);
// Multitexturing // Multitexturing
extern void (APIENTRY * bglActiveTextureARB)(GLenum texture); extern void (APIENTRY * bglActiveTextureARB)(GLenum texture);
// Frame Buffer Objects
extern void (APIENTRY * bglGenFramebuffersEXT)(GLsizei n, GLuint *framebuffers);
extern void (APIENTRY * bglBindFramebufferEXT)(GLenum target, GLuint framebuffer);
extern void (APIENTRY * bglFramebufferTexture2DEXT)(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level);
extern GLenum (APIENTRY * bglCheckFramebufferStatusEXT)(GLenum target);
extern void (APIENTRY * bglDeleteFramebuffersEXT)(GLsizei n, const GLuint *framebuffers);
#ifdef RENDERTYPEWIN #ifdef RENDERTYPEWIN
// Windows // Windows
extern HGLRC (WINAPI * bwglCreateContext)(HDC); extern HGLRC (WINAPI * bwglCreateContext)(HDC);

17
polymer/build/src/baselayer.c
View file

@ -21,6 +21,11 @@ struct glinfo glinfo = {
0, // non-power-of-two textures 0, // non-power-of-two textures
0, // multisampling 0, // multisampling
0, // nvidia multisampling hint 0, // nvidia multisampling hint
0, // ARBfp
0, // depth textures
0, // shadow comparison
0, // Frame Buffer Objects
0, // rectangle textures
}; };
#endif #endif
@ -89,6 +94,11 @@ static int osdcmd_glinfo(const osdfuncparm_t *parm)
" Clamp-to-edge: %s\n" " Clamp-to-edge: %s\n"
" Multisampling: %s\n" " Multisampling: %s\n"
" Nvidia multisample hint: %s\n" " Nvidia multisample hint: %s\n"
" ARBfp fragment programs: %s\n"
" Depth textures: %s\n"
" Shadow textures: %s\n"
" Frame Buffer Objects: %s\n"
" Rectangle textures: %s\n"
" Extensions:\n", " Extensions:\n",
glinfo.version, glinfo.version,
glinfo.vendor, glinfo.vendor,
@ -99,7 +109,12 @@ static int osdcmd_glinfo(const osdfuncparm_t *parm)
glinfo.texcompr ? "supported": "not supported", glinfo.texcompr ? "supported": "not supported",
glinfo.clamptoedge ? "supported": "not supported", glinfo.clamptoedge ? "supported": "not supported",
glinfo.multisample ? "supported": "not supported", glinfo.multisample ? "supported": "not supported",
glinfo.nvmultisamplehint ? "supported": "not supported" glinfo.nvmultisamplehint ? "supported": "not supported",
glinfo.arbfp ? "supported": "not supported",
glinfo.depthtex ? "supported": "not supported",
glinfo.shadow ? "supported": "not supported",
glinfo.fbos ? "supported": "not supported",
glinfo.rect ? "supported": "not supported"
); );
s = Bstrdup(glinfo.extensions); s = Bstrdup(glinfo.extensions);

297
polymer/build/src/engine.c
View file

@ -3130,7 +3130,6 @@ if (!davoxptr && i > 0) { davoxptr = (char *)voxoff[daindex][0]; i = 0; }
} }
#endif #endif
// //
// drawsprite (internal) // drawsprite (internal)
// //
@ -5740,7 +5739,9 @@ void drawrooms(long daposx, long daposy, long daposz,
} }
//============================================================================= //POLYMOST BEGINS //============================================================================= //POLYMOST BEGINS
polymost_drawrooms(); if (rendmode) { return; } polymost_drawrooms();
if (rendmode)
return;
#endif #endif
//============================================================================= //POLYMOST ENDS //============================================================================= //POLYMOST ENDS
@ -5951,9 +5952,10 @@ int sameside(_equation* eq, _point2d* p1, _point2d* p2)
return (0); return (0);
} }
#ifdef USE_OPENGL
void drawpeel(int peel) void drawpeel(int peel)
{ {
bglBindTexture(GL_TEXTURE_RECTANGLE_NV, peels[peel]); bglBindTexture(GL_TEXTURE_RECTANGLE, peels[peel]);
bglBegin(GL_QUADS); bglBegin(GL_QUADS);
bglTexCoord2f(0.0f, 0.0f); bglTexCoord2f(0.0f, 0.0f);
bglVertex2f(-1.0f, -1.0f); bglVertex2f(-1.0f, -1.0f);
@ -5965,6 +5967,7 @@ void drawpeel(int peel)
bglVertex2f(-1.0f, 1.0f); bglVertex2f(-1.0f, 1.0f);
bglEnd(); bglEnd();
} }
#endif
// //
// drawmasks // drawmasks
@ -6002,8 +6005,11 @@ killsprite:
spritesy[i] = yp; spritesy[i] = yp;
} }
if (!usegoodalpha) #ifdef USE_OPENGL
if ((!r_depthpeeling) || (rendmode < 3))
#endif
{ {
gap = 1; while (gap < spritesortcnt) gap = (gap<<1)+1; gap = 1; while (gap < spritesortcnt) gap = (gap<<1)+1;
for (gap>>=1;gap>0;gap>>=1) //Sort sprite list for (gap>>=1;gap>0;gap>>=1) //Sort sprite list
for (i=0;i<spritesortcnt-gap;i++) for (i=0;i<spritesortcnt-gap;i++)
@ -6059,11 +6065,6 @@ if (!usegoodalpha)
} }
} }
if (usegoodalpha)
{
bglNewList(1, GL_COMPILE);
peelcompiling = 1;
}
begindrawing(); //{{{ begindrawing(); //{{{
/*for(i=spritesortcnt-1;i>=0;i--) /*for(i=spritesortcnt-1;i>=0;i--)
@ -6083,206 +6084,13 @@ if (!usegoodalpha)
drawline256(xs+65536,ys-65536,xs-65536,ys+65536,31); drawline256(xs+65536,ys-65536,xs-65536,ys+65536,31);
}*/ }*/
if (!usegoodalpha)
{
{ // Removing previous sorting code
#ifdef POLYMOST
//Hack to make it draw all opaque quads first. This should reduce the chances of
//bad sorting causing transparent quads knocking out opaque quads behind it.
//
//Need to store alpha flag with all textures before this works right!
if (rendmode == 3)
{
for (i=spritesortcnt-1;i>=0;i--)
if ((!(tspriteptr[i]->cstat&2))
#ifdef USE_OPENGL #ifdef USE_OPENGL
&& (!gltexmayhavealpha(tspriteptr[i]->picnum,tspriteptr[i]->pal)) if ((!r_depthpeeling) || (rendmode < 3))
#endif #endif
)
{ drawsprite(i); tspriteptr[i] = 0; } //draw only if it is fully opaque
for (i=j=0;i<spritesortcnt;i++)
{
if (!tspriteptr[i]) continue;
tspriteptr[j] = tspriteptr[i];
spritesx[j] = spritesx[i];
spritesy[j] = spritesy[i]; j++;
}
spritesortcnt = j;
for (i=maskwallcnt-1;i>=0;i--)
{
k = thewall[maskwall[i]];
if ((!(wall[k].cstat&128))
#ifdef USE_OPENGL
&& (!gltexmayhavealpha(wall[k].overpicnum,wall[k].pal))
#endif
)
{ drawmaskwall(i); maskwall[i] = -1; } //draw only if it is fully opaque
}
for (i=j=0;i<maskwallcnt;i++)
{
if (maskwall[i] < 0) continue;
maskwall[j++] = maskwall[i];
}
maskwallcnt = j;
}
#endif
while ((spritesortcnt > 0) && (maskwallcnt > 0)) //While BOTH > 0
{
j = maskwall[maskwallcnt-1];
if (spritewallfront(tspriteptr[spritesortcnt-1],(long)thewall[j]) == 0)
drawsprite(--spritesortcnt);
else
{
//Check to see if any sprites behind the masked wall...
k = -1;
gap = 0;
for (i=spritesortcnt-2;i>=0;i--)
if ((xb1[j] <= (spritesx[i]>>8)) && ((spritesx[i]>>8) <= xb2[j]))
if (spritewallfront(tspriteptr[i],(long)thewall[j]) == 0)
{
drawsprite(i);
tspriteptr[i]->owner = -1;
k = i;
gap++;
}
if (k >= 0) //remove holes in sprite list
{
for (i=k;i<spritesortcnt;i++)
if (tspriteptr[i]->owner >= 0)
{
if (i > k)
{
tspriteptr[k] = tspriteptr[i];
spritesx[k] = spritesx[i];
spritesy[k] = spritesy[i];
}
k++;
}
spritesortcnt -= gap;
}
//finally safe to draw the masked wall
drawmaskwall(--maskwallcnt);
}
}
while (spritesortcnt > 0) drawsprite(--spritesortcnt);
while (maskwallcnt > 0) drawmaskwall(--maskwallcnt);
}
}
else
{ {
// PLAG : The heart of good transparency -> sorted rendering on all layers.
// that's why this code interleaves the drawing of all possible transparent entities
// bubblesort is used, shouldn't cause any problems cpu-wise since the lists are small
// SPRITES PREPROCESSING
/*l = spritesortcnt;
indexes = malloc(l * sizeof(long));
depths = malloc(l * sizeof(long));
// first pass to set base indexes and depths
i = l;
while (i > 0)
{
i--;
indexes[i] = --spritesortcnt;
depths[i] = (tspriteptr[spritesortcnt]->x - globalposx) * (tspriteptr[spritesortcnt]->x - globalposx) +
(tspriteptr[spritesortcnt]->y - globalposy) * (tspriteptr[spritesortcnt]->y - globalposy);
}
// second pass (and possibly more) to z-sort
j = 0;
while (j == 0)
{
j = 1;
for(i=l-1;i>0;i--)
{
if (depths[i] < depths[i-1])
{
swaplong(&indexes[i-1], &indexes[i]);
swaplong(&depths[i-1], &depths[i]);
j = 0;
}
}
}*/
// MASKS PREPROCESSING
//k = maskwallcnt;
// first pass to set wall equations and init the tree
/*i = k;
while (i > 0)
{
i--;
// leaf index
maskleaves[i].index = --maskwallcnt;
// leaf boundaries
maskleaves[i].p1.x = wall[thewall[maskwall[maskleaves[i].index]]].x - globalposx;
maskleaves[i].p1.y = wall[thewall[maskwall[maskleaves[i].index]]].y - globalposy;
maskleaves[i].p2.x = wall[wall[thewall[maskwall[maskleaves[i].index]]].point2].x - globalposx;
maskleaves[i].p2.y = wall[wall[thewall[maskwall[maskleaves[i].index]]].point2].y - globalposy;
// leaf equations
maskleaves[i].maskeq = equation(maskleaves[i].p1.x, maskleaves[i].p1.y, maskleaves[i].p2.x, maskleaves[i].p2.y);
maskleaves[i].p1eq = equation(0, 0, maskleaves[i].p1.x, maskleaves[i].p1.y);
maskleaves[i].p2eq = equation(0, 0, maskleaves[i].p2.x, maskleaves[i].p2.y);
// drawing flag
maskleaves[i].drawing = 0;
//OSD_Printf("Processed mask - %i\n", i);
}
// second pass to connect the leaves together
i = k;
while (i > 0)
{
i--;
m = 0;
j = k;
while (j > 0)
{
j--;
if ((i != j) && (wallobstructswall(&maskleaves[i], &maskleaves[j])))
maskleaves[i].branch[m++] = &maskleaves[j];
}
maskleaves[i].branch[m] = NULL;
//OSD_Printf("Processed parents for mask %i\n", i);
}*/
// DRAWING
// in this code all sprites are drawn, and masks are inserted when needed
/*i = l - 1;
while (i >= 0)
{
//OSD_Printf("sprite - %i\n", depths[i]);
drawsprite(indexes[i]);
i--;
}
// this codes draws the remaining (if any) masked walls, meaning those that are directly before the player
while (k > 0)
{
k--;
//OSD_Printf("Beginning drawing process for mask %i\n", k);
//drawmaskleaf(&maskleaves[k]);
drawmaskwall(k);
}
free(indexes);
free(depths);*/
pos.x = globalposx; pos.x = globalposx;
pos.y = globalposy; pos.y = globalposy;
//OSD_Printf("EIN OBSERVER POSITION : x=%i y=%i\n", pos.x, pos.y);
while (maskwallcnt) while (maskwallcnt)
{ {
maskwallcnt--; maskwallcnt--;
@ -6292,21 +6100,13 @@ else
dot2.x = wall[wall[thewall[maskwall[maskwallcnt]]].point2].x; dot2.x = wall[wall[thewall[maskwall[maskwallcnt]]].point2].x;
dot2.y = wall[wall[thewall[maskwall[maskwallcnt]]].point2].y; dot2.y = wall[wall[thewall[maskwall[maskwallcnt]]].point2].y;
//OSD_Printf("EIN WALL : x1=%i y1=%i x2=%i y2=%i\n", dot.x, dot.y, dot2.x, dot2.y);
maskeq = equation(dot.x, dot.y, dot2.x, dot2.y); maskeq = equation(dot.x, dot.y, dot2.x, dot2.y);
p1eq = equation(pos.x, pos.y, dot.x, dot.y); p1eq = equation(pos.x, pos.y, dot.x, dot.y);
p2eq = equation(pos.x, pos.y, dot2.x, dot2.y); p2eq = equation(pos.x, pos.y, dot2.x, dot2.y);
//OSD_Printf("EIN WALL EQUATION : a=%f b=%f c=%f\n", maskeq.a, maskeq.b, maskeq.c);
//OSD_Printf("EIN WALL POINT1 TO POSITION EQUATION : a=%f b=%f c=%f\n", p1eq.a, p1eq.b, p1eq.c);
//OSD_Printf("EIN WALL POINT2 TO POSITION EQUATION : a=%f b=%f c=%f\n", p2eq.a, p2eq.b, p2eq.c);
middle.x = (dot.x + dot2.x) / 2; middle.x = (dot.x + dot2.x) / 2;
middle.y = (dot.y + dot2.y) / 2; middle.y = (dot.y + dot2.y) / 2;
//OSD_Printf("EIN WALL MIDDLE POINT POSITION : x=%i y=%i\n", middle.x, middle.y);
i = spritesortcnt; i = spritesortcnt;
while (i) while (i)
{ {
@ -6316,8 +6116,6 @@ else
spr.x = tspriteptr[i]->x; spr.x = tspriteptr[i]->x;
spr.y = tspriteptr[i]->y; spr.y = tspriteptr[i]->y;
//OSD_Printf("EIN SPRITE POSITION : x=%i y=%i\n", spr.x, spr.y);
if ((sameside(&maskeq, &spr, &pos) == 0) && sameside(&p1eq, &middle, &spr) && sameside(&p2eq, &middle, &spr)) if ((sameside(&maskeq, &spr, &pos) == 0) && sameside(&p1eq, &middle, &spr) && sameside(&p2eq, &middle, &spr))
{ {
drawsprite(i); drawsprite(i);
@ -6335,13 +6133,23 @@ else
drawsprite(spritesortcnt); drawsprite(spritesortcnt);
} }
//while (spritesortcnt > 0) drawsprite(--spritesortcnt); } /* depthpeeling */
//while (maskwallcnt > 0) drawmaskwall(--maskwallcnt); #ifdef USE_OPENGL
} /* goodalpha */ else
{
curpolygonoffset = 0;
while (spritesortcnt > 0)
{
bglDisable(GL_POLYGON_OFFSET_FILL);
drawsprite(--spritesortcnt);
}
bglDisable(GL_POLYGON_OFFSET_FILL);
while (maskwallcnt > 0) drawmaskwall(--maskwallcnt);
}
#endif
indrawroomsandmasks = 0; #ifdef USE_OPENGL
enddrawing(); //}}} if ((r_depthpeeling) && (rendmode >= 3))
if (usegoodalpha)
{ {
bglEndList(); bglEndList();
peelcompiling = 0; peelcompiling = 0;
@ -6351,40 +6159,30 @@ else
bglAlphaFunc(GL_GREATER, 0.0f); bglAlphaFunc(GL_GREATER, 0.0f);
i = 0; i = 0;
while (i < numpeels) while (i < r_peelscount)
{ {
if (i > 0) if (i > 0)
{ {
bglClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
bglEnable(GL_FRAGMENT_PROGRAM_ARB); bglEnable(GL_FRAGMENT_PROGRAM_ARB);
bglActiveTextureARB(GL_TEXTURE1_ARB); bglActiveTextureARB(GL_TEXTURE1_ARB);
bglEnable(GL_TEXTURE_RECTANGLE_NV); bglBindTexture(GL_TEXTURE_RECTANGLE, ztexture[(i - 1) % 2]);
bglBindTexture(GL_TEXTURE_RECTANGLE_NV, ztexture);
bglActiveTextureARB(GL_TEXTURE0_ARB); bglActiveTextureARB(GL_TEXTURE0_ARB);
} }
if (i == (r_peelscount - 1))
bglEnable(GL_BLEND);
bglBindFramebufferEXT(GL_FRAMEBUFFER_EXT, peelfbos[i]);
bglPushAttrib(GL_VIEWPORT_BIT);
bglViewport(0, 0, xdim, ydim);
bglClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
bglCallList(1); bglCallList(1);
bglPopAttrib();
bglBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
if (i > 0) if (i > 0)
{
bglActiveTextureARB(GL_TEXTURE1_ARB);
bglDisable(GL_TEXTURE_RECTANGLE_NV);
bglActiveTextureARB(GL_TEXTURE0_ARB);
bglDisable(GL_FRAGMENT_PROGRAM_ARB); bglDisable(GL_FRAGMENT_PROGRAM_ARB);
}
// save output to a peel
bglBindTexture(GL_TEXTURE_RECTANGLE_NV, peels[i]);
bglCopyTexSubImage2D(GL_TEXTURE_RECTANGLE_NV, 0, 0, 0, 0, 0, xdim, ydim);
if (i < (numpeels - 1))
{
// save depth buffer
bglBindTexture(GL_TEXTURE_RECTANGLE_NV, ztexture);
bglCopyTexSubImage2D(GL_TEXTURE_RECTANGLE_NV, 0, 0, 0, 0, 0, xdim, ydim);
}
i++; i++;
} }
@ -6392,7 +6190,6 @@ else
bglClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); bglClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
bglEnable(GL_BLEND); bglEnable(GL_BLEND);
bglDisable(GL_ALPHA_TEST);
bglDisable(GL_DEPTH_TEST); bglDisable(GL_DEPTH_TEST);
bglColor4f(1.0f, 1.0f, 1.0f, 1.0f); bglColor4f(1.0f, 1.0f, 1.0f, 1.0f);
@ -6405,18 +6202,18 @@ else
bglPushMatrix(); bglPushMatrix();
bglLoadIdentity(); bglLoadIdentity();
bglEnable(GL_TEXTURE_RECTANGLE_NV); bglEnable(GL_TEXTURE_RECTANGLE);
if (curpeel == -1) if (r_curpeel == -1)
{ {
i = numpeels - 1; i = r_peelscount - 1;
while (i >= 0) while (i >= 0)
drawpeel(i--); drawpeel(i--);
} }
else else
drawpeel(curpeel); drawpeel(r_curpeel);
bglDisable(GL_TEXTURE_RECTANGLE_NV); bglDisable(GL_TEXTURE_RECTANGLE);
bglEnable(GL_TEXTURE_2D); bglEnable(GL_TEXTURE_2D);
// restore the polymost projection // restore the polymost projection
@ -6429,6 +6226,10 @@ else
bglDeleteLists(1, 1); bglDeleteLists(1, 1);
} }
#endif
indrawroomsandmasks = 0;
enddrawing(); //}}}
} }
// //
@ -7603,8 +7404,8 @@ if (searchx < 0) { searchx = halfxdimen; searchy = (ydimen>>1); }
#if defined(POLYMOST) && defined(USE_OPENGL) #if defined(POLYMOST) && defined(USE_OPENGL)
if (rendmode == 3) if (rendmode == 3)
{ {
polymost_glinit();
polymost_glreset(); polymost_glreset();
polymost_glinit();
} }
if (rendmode == 4) if (rendmode == 4)
polymer_glinit(); polymer_glinit();

24
polymer/build/src/glbuild.c
View file

@ -117,10 +117,18 @@ void (APIENTRY * bglStencilFunc)(GLenum func, GLint ref, GLuint mask);
void (APIENTRY * bglGenProgramsARB)(GLsizei, GLuint *); void (APIENTRY * bglGenProgramsARB)(GLsizei, GLuint *);
void (APIENTRY * bglBindProgramARB)(GLenum, GLuint); void (APIENTRY * bglBindProgramARB)(GLenum, GLuint);
void (APIENTRY * bglProgramStringARB)(GLenum, GLenum, GLsizei, const GLvoid *); void (APIENTRY * bglProgramStringARB)(GLenum, GLenum, GLsizei, const GLvoid *);
void (APIENTRY * bglDeleteProgramsARB)(GLsizei n, const GLuint *programs);
// Multitexturing // Multitexturing
void (APIENTRY * bglActiveTextureARB)(GLenum texture); void (APIENTRY * bglActiveTextureARB)(GLenum texture);
// Frame Buffer Objects
void (APIENTRY * bglGenFramebuffersEXT)(GLsizei n, GLuint *framebuffers);
void (APIENTRY * bglBindFramebufferEXT)(GLenum target, GLuint framebuffer);
void (APIENTRY * bglFramebufferTexture2DEXT)(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level);
GLenum (APIENTRY * bglCheckFramebufferStatusEXT)(GLenum target);
void (APIENTRY * bglDeleteFramebuffersEXT)(GLsizei n, const GLuint *framebuffers);
#ifdef RENDERTYPEWIN #ifdef RENDERTYPEWIN
// Windows // Windows
HGLRC (WINAPI * bwglCreateContext)(HDC); HGLRC (WINAPI * bwglCreateContext)(HDC);
@ -320,10 +328,18 @@ int loadglextensions(void)
bglGenProgramsARB = GETPROCEXTSOFT("glGenProgramsARB"); bglGenProgramsARB = GETPROCEXTSOFT("glGenProgramsARB");
bglBindProgramARB = GETPROCEXTSOFT("glBindProgramARB"); bglBindProgramARB = GETPROCEXTSOFT("glBindProgramARB");
bglProgramStringARB = GETPROCEXTSOFT("glProgramStringARB"); bglProgramStringARB = GETPROCEXTSOFT("glProgramStringARB");
bglDeleteProgramsARB= GETPROCEXTSOFT("glDeleteProgramsARB");
// Multitexturing // Multitexturing
bglActiveTextureARB = GETPROCEXTSOFT("glActiveTextureARB"); bglActiveTextureARB = GETPROCEXTSOFT("glActiveTextureARB");
// Frame Buffer Objects
bglGenFramebuffersEXT = GETPROCEXTSOFT("glGenFramebuffersEXT");
bglBindFramebufferEXT = GETPROCEXTSOFT("glBindFramebufferEXT");
bglFramebufferTexture2DEXT = GETPROCEXTSOFT("glFramebufferTexture2DEXT");
bglCheckFramebufferStatusEXT = GETPROCEXTSOFT("glCheckFramebufferStatusEXT");
bglDeleteFramebuffersEXT = GETPROCEXTSOFT("glDeleteFramebuffersEXT");
return err; return err;
} }
@ -440,10 +456,18 @@ int unloadgldriver(void)
bglGenProgramsARB = NULL; bglGenProgramsARB = NULL;
bglBindProgramARB = NULL; bglBindProgramARB = NULL;
bglProgramStringARB = NULL; bglProgramStringARB = NULL;
bglDeleteProgramsARB= NULL;
// Multitexturing // Multitexturing
bglActiveTextureARB = NULL; bglActiveTextureARB = NULL;
// Frame Buffer Objects
bglGenFramebuffersEXT = NULL;
bglBindFramebufferEXT = NULL;
bglFramebufferTexture2DEXT = NULL;
bglCheckFramebufferStatusEXT = NULL;
bglDeleteFramebuffersEXT = NULL;
#ifdef RENDERTYPEWIN #ifdef RENDERTYPEWIN
bwglCreateContext = NULL; bwglCreateContext = NULL;
bwglDeleteContext = NULL; bwglDeleteContext = NULL;

11
polymer/build/src/mdsprite.c
View file

@ -1411,13 +1411,14 @@ if (tspr->cstat&2) { if (!(tspr->cstat&512)) pc[3] = 0.66; else pc[3] = 0.33; }
float al = 0.0; float al = 0.0;
if (alphahackarray[globalpicnum] != 0) if (alphahackarray[globalpicnum] != 0)
al=alphahackarray[globalpicnum]; al=alphahackarray[globalpicnum];
if (!peelcompiling)
bglEnable(GL_BLEND); bglEnable(GL_BLEND);
bglEnable(GL_ALPHA_TEST); bglEnable(GL_ALPHA_TEST);
bglAlphaFunc(GL_GREATER,al); bglAlphaFunc(GL_GREATER,al);
} }
else else
{ {
if (tspr->cstat&2) bglEnable(GL_BLEND); else bglDisable(GL_BLEND); if (tspr->cstat&2 && (!peelcompiling)) bglEnable(GL_BLEND); //else bglDisable(GL_BLEND);
} }
bglColor4f(pc[0],pc[1],pc[2],pc[3]); bglColor4f(pc[0],pc[1],pc[2],pc[3]);
//if (m->head.flags == 1337) //if (m->head.flags == 1337)
@ -1489,7 +1490,7 @@ if (tspr->cstat&2) { if (!(tspr->cstat&512)) pc[3] = 0.66; else pc[3] = 0.33; }
bglBindTexture(GL_TEXTURE_2D, i); bglBindTexture(GL_TEXTURE_2D, i);
//PLAG: delayed polygon-level sorted rendering //PLAG: delayed polygon-level sorted rendering
if (m->usesalpha && !(tspr->cstat & 1024) && !usegoodalpha) if (m->usesalpha && !(tspr->cstat & 1024) && !r_depthpeeling)
{ {
indexes = malloc(sizeof(unsigned short) * s->numtris); indexes = malloc(sizeof(unsigned short) * s->numtris);
maxdepths = malloc(sizeof(float) * s->numtris); maxdepths = malloc(sizeof(float) * s->numtris);
@ -1622,7 +1623,7 @@ if (tspr->cstat&2) { if (!(tspr->cstat&512)) pc[3] = 0.66; else pc[3] = 0.33; }
bglPopAttrib(); bglPopAttrib();
if (tspr->cstat&1024) if (tspr->cstat&1024)
{ {
bglDepthFunc(GL_LEQUAL); //NEVER,LESS,(,L)EQUAL,GREATER,(NOT,G)EQUAL,ALWAYS bglDepthFunc(GL_LESS); //NEVER,LESS,(,L)EQUAL,GREATER,(NOT,G)EQUAL,ALWAYS
bglDepthRange(0.0,0.99999); bglDepthRange(0.0,0.99999);
} }
bglLoadIdentity(); bglLoadIdentity();
@ -2413,7 +2414,7 @@ if (grhalfxdown10x < 0) { mat[0] = -mat[0]; mat[4] = -mat[4]; mat[8] = -mat[8];
pc[1] *= (float)hictinting[globalpal].g / 255.0; pc[1] *= (float)hictinting[globalpal].g / 255.0;
pc[2] *= (float)hictinting[globalpal].b / 255.0; pc[2] *= (float)hictinting[globalpal].b / 255.0;
if (tspr->cstat&2) { if (!(tspr->cstat&512)) pc[3] = 0.66; else pc[3] = 0.33; } else pc[3] = 1.0; if (tspr->cstat&2) { if (!(tspr->cstat&512)) pc[3] = 0.66; else pc[3] = 0.33; } else pc[3] = 1.0;
if (tspr->cstat&2) bglEnable(GL_BLEND); else bglDisable(GL_BLEND); if (tspr->cstat&2 && (!peelcompiling)) bglEnable(GL_BLEND); //else bglDisable(GL_BLEND);
//------------ //------------
//transform to Build coords //transform to Build coords
@ -2471,7 +2472,7 @@ if (tspr->cstat&2) { if (!(tspr->cstat&512)) pc[3] = 0.66; else pc[3] = 0.33; }
bglPopAttrib(); bglPopAttrib();
if (tspr->cstat&1024) if (tspr->cstat&1024)
{ {
bglDepthFunc(GL_LEQUAL); //NEVER,LESS,(,L)EQUAL,GREATER,(NOT,G)EQUAL,ALWAYS bglDepthFunc(GL_LESS); //NEVER,LESS,(,L)EQUAL,GREATER,(NOT,G)EQUAL,ALWAYS
bglDepthRange(0.0,0.99999); bglDepthRange(0.0,0.99999);
} }
bglLoadIdentity(); bglLoadIdentity();

182
polymer/build/src/polymost.c
View file

@ -127,10 +127,6 @@ static long lastglpolygonmode = 0; //FUK
long glpolygonmode = 0; // 0:GL_FILL,1:GL_LINE,2:GL_POINT //FUK long glpolygonmode = 0; // 0:GL_FILL,1:GL_LINE,2:GL_POINT //FUK
long glwidescreen = 0; long glwidescreen = 0;
long glprojectionhacks = 1; long glprojectionhacks = 1;
long usegoodalpha = 0;
long peelcompiling = 0;
long numpeels = 10;
long curpeel = -1;
static GLuint polymosttext = 0; static GLuint polymosttext = 0;
extern char nofog; extern char nofog;
@ -139,6 +135,20 @@ long fullbrightloadingpass = 0;
long fullbrightdrawingpass = 0; long fullbrightdrawingpass = 0;
long shadeforfullbrightpass; long shadeforfullbrightpass;
// Depth peeling control
long r_depthpeeling = 0; // cvar toggling general depth peeling usage
long r_peelscount = 5; // cvar controlling the number of peeling layers
long r_curpeel = -1; // cvar controlling the display of independant peeling layers
float curpolygonoffset; // internal polygon offset stack for drawing flat sprites to avoid depth fighting
long peelcompiling = 0; // internal control var to disable blending when compiling the peeling display list
long newpeelscount = 0; // temporary var for peels count changing during the game
// Depth peeling data
GLuint ztexture[2]; // secondary Z-buffer identifier
GLuint *peels; // peels identifiers
GLuint *peelfbos; // peels FBOs identifiers
GLuint peelprogram; // ARBfp peeling fragment program
float fogresult; float fogresult;
void fogcalc (const signed char *shade, const char *vis) void fogcalc (const signed char *shade, const char *vis)
@ -596,11 +606,20 @@ void polymost_glreset ()
memset(gltexcachead,0,sizeof(gltexcachead)); memset(gltexcachead,0,sizeof(gltexcachead));
glox1 = -1; glox1 = -1;
}
GLuint ztexture; // Depth peeling cleanup
GLuint *peels; if (peels)
GLuint peelprogram; {
bglDeleteProgramsARB(1, &peelprogram);
bglDeleteFramebuffersEXT(r_peelscount, peelfbos);
bglDeleteTextures(r_peelscount, peels);
bglDeleteTextures(2, ztexture);
free(peels);
free(peelfbos);
peels = NULL;
}
}
// one-time initialisation of OpenGL for polymost // one-time initialisation of OpenGL for polymost
void polymost_glinit() void polymost_glinit()
@ -609,11 +628,13 @@ void polymost_glinit()
int i; int i;
char peelprogramstring[] = char peelprogramstring[] =
"!!ARBfp1.0\n" "!!ARBfp1.0\n"
"OPTION ARB_fog_exp2;\n"
"OPTION ARB_fragment_program_shadow;\n"
"TEMP texsample;\n" "TEMP texsample;\n"
"TEMP depthresult;\n" "TEMP depthresult;\n"
"TEMP tempresult;\n" "TEMP tempresult;\n"
"TEX texsample, fragment.texcoord[0], texture[0], 2D;\n" "TEX texsample, fragment.texcoord[0], texture[0], 2D;\n"
"TEX depthresult, fragment.position, texture[1], RECT;\n" "TEX depthresult, fragment.position, texture[1], SHADOWRECT;\n"
"MUL tempresult, fragment.color, texsample;\n" "MUL tempresult, fragment.color, texsample;\n"
"MUL tempresult.a, tempresult.a, depthresult.a;\n" "MUL tempresult.a, tempresult.a, depthresult.a;\n"
"MOV result.color, tempresult;\n" "MOV result.color, tempresult;\n"
@ -652,33 +673,67 @@ void polymost_glinit()
bglEnable(GL_MULTISAMPLE_ARB); bglEnable(GL_MULTISAMPLE_ARB);
} }
//depth peeling init if (!glinfo.arbfp || !glinfo.depthtex || !glinfo.shadow || !glinfo.fbos || !glinfo.rect)
if (usegoodalpha)
{ {
// create the secondary Z-buffer OSD_Printf("Your OpenGL implementation doesn't support depth peeling. Forcing it off...\n", i);
bglGenTextures(1, &ztexture); r_depthpeeling = 0;
bglBindTexture(GL_TEXTURE_RECTANGLE_NV, ztexture); }
bglCopyTexImage2D(GL_TEXTURE_RECTANGLE_NV, 0, GL_DEPTH_COMPONENT, 0, 0, xdim, ydim, 0);
bglTexParameteri(GL_TEXTURE_RECTANGLE_NV, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
bglTexParameteri(GL_TEXTURE_RECTANGLE_NV, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
bglTexParameteri(GL_TEXTURE_RECTANGLE_NV, GL_TEXTURE_WRAP_S, GL_CLAMP);
bglTexParameteri(GL_TEXTURE_RECTANGLE_NV, GL_TEXTURE_WRAP_T, GL_CLAMP);
bglTexParameteri(GL_TEXTURE_RECTANGLE_NV, GL_TEXTURE_COMPARE_MODE_ARB, GL_COMPARE_R_TO_TEXTURE_ARB);
bglTexParameteri(GL_TEXTURE_RECTANGLE_NV, GL_TEXTURE_COMPARE_FUNC_ARB, GL_GREATER);
bglTexParameteri(GL_TEXTURE_RECTANGLE_NV, GL_DEPTH_TEXTURE_MODE_ARB, GL_ALPHA);
// create the various peeling layers //depth peeling initialization
peels = malloc(numpeels * sizeof(GLuint)); if (r_depthpeeling)
bglGenTextures(numpeels, peels);
i = 0;
while (i < numpeels)
{ {
bglBindTexture(GL_TEXTURE_RECTANGLE_NV, peels[i]); if (newpeelscount)
bglCopyTexImage2D(GL_TEXTURE_RECTANGLE_NV, 0, GL_RGBA8, 0, 0, xdim, ydim, 0); {
bglTexParameteri(GL_TEXTURE_RECTANGLE_NV, GL_TEXTURE_MIN_FILTER, GL_NEAREST); r_peelscount = newpeelscount;
bglTexParameteri(GL_TEXTURE_RECTANGLE_NV, GL_TEXTURE_MAG_FILTER, GL_NEAREST); newpeelscount = 0;
bglTexParameteri(GL_TEXTURE_RECTANGLE_NV, GL_TEXTURE_WRAP_S, GL_CLAMP); }
bglTexParameteri(GL_TEXTURE_RECTANGLE_NV, GL_TEXTURE_WRAP_T, GL_CLAMP); // create the secondary Z-buffer
bglGenTextures(2, ztexture);
i = 0;
while (i < 2)
{
bglBindTexture(GL_TEXTURE_RECTANGLE, ztexture[i]);
bglCopyTexImage2D(GL_TEXTURE_RECTANGLE, 0, GL_DEPTH_COMPONENT, 0, 0, xdim, ydim, 0);
bglTexParameteri(GL_TEXTURE_RECTANGLE, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
bglTexParameteri(GL_TEXTURE_RECTANGLE, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
bglTexParameteri(GL_TEXTURE_RECTANGLE, GL_TEXTURE_WRAP_S, GL_CLAMP);
bglTexParameteri(GL_TEXTURE_RECTANGLE, GL_TEXTURE_WRAP_T, GL_CLAMP);
bglTexParameteri(GL_TEXTURE_RECTANGLE, GL_TEXTURE_COMPARE_MODE_ARB, GL_COMPARE_R_TO_TEXTURE_ARB);
bglTexParameteri(GL_TEXTURE_RECTANGLE, GL_TEXTURE_COMPARE_FUNC_ARB, GL_GREATER);
bglTexParameteri(GL_TEXTURE_RECTANGLE, GL_DEPTH_TEXTURE_MODE_ARB, GL_ALPHA);
i++;
}
// create the various peeling layers as well as the FBOs to render to them
peels = malloc(r_peelscount * sizeof(GLuint));
bglGenTextures(r_peelscount, peels);
peelfbos = malloc(r_peelscount * sizeof(GLuint));
bglGenFramebuffersEXT(r_peelscount, peelfbos);
i = 0;
while (i < r_peelscount)
{
bglBindTexture(GL_TEXTURE_RECTANGLE, peels[i]);
bglCopyTexImage2D(GL_TEXTURE_RECTANGLE, 0, GL_RGBA, 0, 0, xdim, ydim, 0);
bglTexParameteri(GL_TEXTURE_RECTANGLE, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
bglTexParameteri(GL_TEXTURE_RECTANGLE, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
bglTexParameteri(GL_TEXTURE_RECTANGLE, GL_TEXTURE_WRAP_S, GL_CLAMP);
bglTexParameteri(GL_TEXTURE_RECTANGLE, GL_TEXTURE_WRAP_T, GL_CLAMP);
bglBindFramebufferEXT(GL_FRAMEBUFFER_EXT, peelfbos[i]);
bglFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_RECTANGLE, peels[i], 0);
if (i < (r_peelscount - 1))
bglFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_TEXTURE_RECTANGLE, ztexture[i % 2], 0);
if (bglCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT) != GL_FRAMEBUFFER_COMPLETE_EXT)
{
OSD_Printf("FBO #%d initialization failed.\n", i);
}
bglBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
i++; i++;
} }
@ -1556,7 +1611,7 @@ void drawpoly (double *dpx, double *dpy, long n, long method)
} }
if ((!(method&3)) && (!fullbrightdrawingpass)) { if ((!(method&3)) && (!fullbrightdrawingpass)) {
bglDisable(GL_BLEND); //bglDisable(GL_BLEND);
if (!peelcompiling) if (!peelcompiling)
bglDisable(GL_ALPHA_TEST); bglDisable(GL_ALPHA_TEST);
} else { } else {
@ -1753,11 +1808,12 @@ void drawpoly (double *dpx, double *dpy, long n, long method)
{ {
fullbrightdrawingpass = 2; fullbrightdrawingpass = 2;
shadeforfullbrightpass = globalshade; // save the current shade shadeforfullbrightpass = globalshade; // save the current shade
bglFogf(GL_FOG_DENSITY,0.0f); // no fog
globalshade = -128; // fullbright globalshade = -128; // fullbright
bglDisable(GL_FOG); // no fog
drawpoly(dpx, dpy, n_, method_); // draw them afterwards, then. :) drawpoly(dpx, dpy, n_, method_); // draw them afterwards, then. :)
bglEnable(GL_FOG);
globalshade = shadeforfullbrightpass; globalshade = shadeforfullbrightpass;
fogcalc(&globalshade, &globalvisibility);
bglFogf(GL_FOG_DENSITY, fogresult);
fullbrightdrawingpass = 0; fullbrightdrawingpass = 0;
} }
return; return;
@ -3510,6 +3566,12 @@ void polymost_drawrooms ()
#ifdef USE_OPENGL #ifdef USE_OPENGL
if (rendmode >= 3) if (rendmode >= 3)
{ {
if (r_depthpeeling)
{
bglNewList(1, GL_COMPILE);
peelcompiling = 1;
}
resizeglcheck(); resizeglcheck();
//bglClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT); //bglClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
@ -3723,7 +3785,7 @@ void polymost_drawrooms ()
#ifdef USE_OPENGL #ifdef USE_OPENGL
if (rendmode >= 3) if (rendmode >= 3)
{ {
bglDepthFunc(GL_LEQUAL); //NEVER,LESS,(,L)EQUAL,GREATER,(NOT,G)EQUAL,ALWAYS bglDepthFunc(GL_LESS); //NEVER,LESS,(,L)EQUAL,GREATER,(NOT,G)EQUAL,ALWAYS
//bglPolygonOffset(0,0); //bglPolygonOffset(0,0);
bglDepthRange(0.0,0.99999); //<- this is more widely supported than glPolygonOffset bglDepthRange(0.0,0.99999); //<- this is more widely supported than glPolygonOffset
@ -3959,9 +4021,13 @@ if (tspr->cstat&2) { if (!(tspr->cstat&512)) method = 2+4; else method = 3+4; }
} }
break; break;
} }
//if (((tspr->cstat&2) || (gltexmayhavealpha(tspr->picnum,tspr->pal))) && ((tspr->cstat&48) != 0)) if (((tspr->cstat&2) || (gltexmayhavealpha(tspr->picnum,tspr->pal))) && (peelcompiling))
// if (((tspr->cstat&2) || (gltexmayhavealpha(tspr->picnum,tspr->pal))) && ((tspr->cstat&48) != 0)) {
// bglDepthMask(0); curpolygonoffset += 0.01f;
bglEnable(GL_POLYGON_OFFSET_FILL);
bglPolygonOffset(-curpolygonoffset, -curpolygonoffset);
//bglDepthMask(0);
}
#endif #endif
switch ((globalorientation>>4)&3) switch ((globalorientation>>4)&3)
@ -5020,19 +5086,31 @@ static int osdcmd_polymostvars(const osdfuncparm_t *parm)
else gltexmiplevel = val; else gltexmiplevel = val;
return OSDCMD_OK; return OSDCMD_OK;
} }
else if (!Bstrcasecmp(parm->name, "usegoodalpha")) { else if (!Bstrcasecmp(parm->name, "r_depthpeeling")) {
if (showval) { OSD_Printf("usegoodalpha is %d\n", usegoodalpha); } if (showval) { OSD_Printf("r_depthpeeling is %d\n", r_depthpeeling); }
else usegoodalpha = (val != 0); else {
r_depthpeeling = (val != 0);
resetvideomode();
if (setgamemode(fullscreen,xdim,ydim,bpp))
OSD_Printf("restartvid: Reset failed...\n");
}
return OSDCMD_OK; return OSDCMD_OK;
} }
else if (!Bstrcasecmp(parm->name, "numpeels")) { else if (!Bstrcasecmp(parm->name, "r_peelscount")) {
if (showval) { OSD_Printf("numpeels is %d\n", numpeels); } if (showval) { OSD_Printf("r_peelscount is %d\n", r_peelscount); }
else numpeels = val; else if (val < 1) { OSD_Printf("Value out of range.\n"); }
else {
newpeelscount = val;
resetvideomode();
if (setgamemode(fullscreen,xdim,ydim,bpp))
OSD_Printf("restartvid: Reset failed...\n");
}
return OSDCMD_OK; return OSDCMD_OK;
} }
else if (!Bstrcasecmp(parm->name, "curpeel")) { else if (!Bstrcasecmp(parm->name, "r_curpeel")) {
if (showval) { OSD_Printf("curpeel is %d\n", curpeel); } if (showval) { OSD_Printf("r_curpeel is %d\n", r_curpeel); }
else curpeel = val; else if ((val < -1) || (val >= r_peelscount)) { OSD_Printf("Value out of range.\n"); }
else r_curpeel = val;
return OSDCMD_OK; return OSDCMD_OK;
} }
else if (!Bstrcasecmp(parm->name, "glpolygonmode")) { else if (!Bstrcasecmp(parm->name, "glpolygonmode")) {
@ -5110,15 +5188,15 @@ void polymost_initosdfuncs(void)
OSD_RegisterFunction("gltextureanisotropy", "gltextureanisotropy: changes the OpenGL texture anisotropy setting", gltextureanisotropy); OSD_RegisterFunction("gltextureanisotropy", "gltextureanisotropy: changes the OpenGL texture anisotropy setting", gltextureanisotropy);
OSD_RegisterFunction("gltexturemaxsize","gltexturemaxsize: changes the maximum OpenGL texture size limit",osdcmd_polymostvars); OSD_RegisterFunction("gltexturemaxsize","gltexturemaxsize: changes the maximum OpenGL texture size limit",osdcmd_polymostvars);
OSD_RegisterFunction("gltexturemiplevel","gltexturemiplevel: changes the highest OpenGL mipmap level used",osdcmd_polymostvars); OSD_RegisterFunction("gltexturemiplevel","gltexturemiplevel: changes the highest OpenGL mipmap level used",osdcmd_polymostvars);
OSD_RegisterFunction("usegoodalpha","usegoodalpha: [OBSOLETE] enable/disable better looking OpenGL alpha hack",osdcmd_polymostvars);
OSD_RegisterFunction("numpeels","numpeels",osdcmd_polymostvars);
OSD_RegisterFunction("curpeel","curpeel: [OBSOLETE] enable/disable better looking OpenGL alpha hack",osdcmd_polymostvars);
OSD_RegisterFunction("glpolygonmode","glpolygonmode: debugging feature",osdcmd_polymostvars); //FUK OSD_RegisterFunction("glpolygonmode","glpolygonmode: debugging feature",osdcmd_polymostvars); //FUK
OSD_RegisterFunction("glusetexcache","glusetexcache: enable/disable OpenGL compressed texture cache",osdcmd_polymostvars); OSD_RegisterFunction("glusetexcache","glusetexcache: enable/disable OpenGL compressed texture cache",osdcmd_polymostvars);
OSD_RegisterFunction("glusetexcachecompression","usetexcachecompression: enable/disable compression of files in the OpenGL compressed texture cache",osdcmd_polymostvars); OSD_RegisterFunction("glusetexcachecompression","usetexcachecompression: enable/disable compression of files in the OpenGL compressed texture cache",osdcmd_polymostvars);
OSD_RegisterFunction("glmultisample","glmultisample: sets the number of samples used for antialiasing (0 = off)",osdcmd_polymostvars); OSD_RegisterFunction("glmultisample","glmultisample: sets the number of samples used for antialiasing (0 = off)",osdcmd_polymostvars);
OSD_RegisterFunction("glnvmultisamplehint","glnvmultisamplehint: enable/disable Nvidia multisampling hinting",osdcmd_polymostvars); OSD_RegisterFunction("glnvmultisamplehint","glnvmultisamplehint: enable/disable Nvidia multisampling hinting",osdcmd_polymostvars);
OSD_RegisterFunction("r_shadescale","r_shadescale: multiplier for lighting",osdcmd_polymostvars); OSD_RegisterFunction("r_shadescale","r_shadescale: multiplier for lighting",osdcmd_polymostvars);
OSD_RegisterFunction("r_depthpeeling","r_depthpeeling: enable/disable order-independant transparency",osdcmd_polymostvars);
OSD_RegisterFunction("r_peelscount","r_peelscount: sets the number of depth layers for depth peeling",osdcmd_polymostvars);
OSD_RegisterFunction("r_curpeel","r_curpeel: allows to display one depth layer at a time (for development purposes)",osdcmd_polymostvars);
#endif #endif
OSD_RegisterFunction("usemodels","usemodels: enable/disable model rendering in >8-bit mode",osdcmd_polymostvars); OSD_RegisterFunction("usemodels","usemodels: enable/disable model rendering in >8-bit mode",osdcmd_polymostvars);
OSD_RegisterFunction("usehightile","usehightile: enable/disable hightile texture rendering in >8-bit mode",osdcmd_polymostvars); OSD_RegisterFunction("usehightile","usehightile: enable/disable hightile texture rendering in >8-bit mode",osdcmd_polymostvars);

21
polymer/build/src/sdlayer.c
View file

@ -1049,6 +1049,27 @@ int setvideomode(int x, int y, int c, int fs)
// supports nvidia's multisample hint extension // supports nvidia's multisample hint extension
glinfo.nvmultisamplehint = 1; glinfo.nvmultisamplehint = 1;
} }
else if (!Bstrcmp((char *)p2, "GL_ARB_fragment_program"))
{
glinfo.arbfp = 1;
}
else if (!Bstrcmp((char *)p2, "GL_ARB_depth_texture"))
{
glinfo.depthtex = 1;
}
else if (!Bstrcmp((char *)p2, "GL_ARB_shadow"))
{
glinfo.shadow = 1;
}
else if (!Bstrcmp((char *)p2, "GL_EXT_framebuffer_object"))
{
glinfo.fbos = 1;
}
else if (!Bstrcmp((char *)p2, "GL_NV_texture_rectangle") ||
!Bstrcmp((char *)p2, "GL_EXT_texture_rectangle"))
{
glinfo.rect = 1;
}
} }
Bfree(p); Bfree(p);
} }

11
polymer/build/src/winlayer.c
View file

@ -2882,6 +2882,17 @@ static int SetupOpenGL(int width, int height, int bitspp)
nofog = 1; nofog = 1;
if (!(warnonce&1)) initprintf("3dfx card detected: OpenGL fog disabled\n"); if (!(warnonce&1)) initprintf("3dfx card detected: OpenGL fog disabled\n");
warnonce |= 1; warnonce |= 1;
} else if (!Bstrcmp((char *)p2, "GL_ARB_fragment_program")) {
glinfo.arbfp = 1;
} else if (!Bstrcmp((char *)p2, "GL_ARB_depth_texture")) {
glinfo.depthtex = 1;
} else if (!Bstrcmp((char *)p2, "GL_ARB_shadow")) {
glinfo.shadow = 1;
} else if (!Bstrcmp((char *)p2, "GL_EXT_framebuffer_object")) {
glinfo.fbos = 1;
} else if (!Bstrcmp((char *)p2, "GL_NV_texture_rectangle") ||
!Bstrcmp((char *)p2, "GL_EXT_texture_rectangle")) {
glinfo.rect = 1;
} }
} }
Bfree(p); Bfree(p);

5
polymer/eduke32/source/config.c
View file

@ -639,6 +639,9 @@ int32 CONFIG_ReadSetup(void)
SCRIPT_GetNumber(scripthandle, "Screen Setup", "GLUseCompressedTextureCache", &glusetexcache); SCRIPT_GetNumber(scripthandle, "Screen Setup", "GLUseCompressedTextureCache", &glusetexcache);
SCRIPT_GetNumber(scripthandle, "Screen Setup", "GLUseTextureCacheCompression", &glusetexcachecompression); SCRIPT_GetNumber(scripthandle, "Screen Setup", "GLUseTextureCacheCompression", &glusetexcachecompression);
SCRIPT_GetNumber(scripthandle, "Screen Setup", "GLDepthPeeling", &r_depthpeeling);
SCRIPT_GetNumber(scripthandle, "Screen Setup", "GLPeelsCount", &r_peelscount);
dummy = usemodels; dummy = usemodels;
SCRIPT_GetNumber(scripthandle, "Screen Setup", "UseModels",&dummy); SCRIPT_GetNumber(scripthandle, "Screen Setup", "UseModels",&dummy);
usemodels = dummy != 0; usemodels = dummy != 0;
@ -784,6 +787,8 @@ void CONFIG_WriteSetup(void)
SCRIPT_PutNumber(scripthandle, "Screen Setup", "GLUseTextureCacheCompression", glusetexcachecompression,false,false); SCRIPT_PutNumber(scripthandle, "Screen Setup", "GLUseTextureCacheCompression", glusetexcachecompression,false,false);
SCRIPT_PutNumber(scripthandle, "Screen Setup", "GLUseTextureCompr",glusetexcompr,false,false); SCRIPT_PutNumber(scripthandle, "Screen Setup", "GLUseTextureCompr",glusetexcompr,false,false);
SCRIPT_PutNumber(scripthandle, "Screen Setup", "GLWidescreen",glwidescreen,false,false); SCRIPT_PutNumber(scripthandle, "Screen Setup", "GLWidescreen",glwidescreen,false,false);
SCRIPT_PutNumber(scripthandle, "Screen Setup", "GLDepthPeeling",r_depthpeeling,false,false);
SCRIPT_PutNumber(scripthandle, "Screen Setup", "GLPeelsCount",r_peelscount,false,false);
#endif #endif
#ifdef RENDERTYPEWIN #ifdef RENDERTYPEWIN
SCRIPT_PutNumber(scripthandle, "Screen Setup", "MaxRefreshFreq",maxrefreshfreq,false,false); SCRIPT_PutNumber(scripthandle, "Screen Setup", "MaxRefreshFreq",maxrefreshfreq,false,false);