team-fte
/
fteqw
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

d3d compiles again (yes, your poking does work Moodles). 

Fixed particle beam/torch weirdness (rjlan poked me for this one!).
tiny optimisation in the gl renderer.
offsetmapping info is loaded even with bumpmapping disabled.
Fixed some hexen2 annoyances.

git-svn-id: https://svn.code.sf.net/p/fteqw/code/trunk@3960 fc73d0e0-1445-4013-8a0c-d673dee63da5
This commit is contained in:
Spoike 2012-01-21 07:53:49 +00:00
parent 1cb10f78d6
commit 770948a320
16 changed files with 370 additions and 344 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
engine/client/cl_screen.c
View File

@ -513,7 +513,7 @@ void SCR_DrawCenterString (vrect_t *rect, cprint_t *p)
py = ( y * vid.height) / (float)vid.pixelheight;
pw = rect->width+8;
if (*p->titleimage)
R2D_ScalePic (px-16, py-16, pw + 16, linecount*8 + 32, pic);
R2D_ScalePic (rect->x + ((int)rect->width - pic->width)/2, rect->y + ((int)rect->height - pic->height)/2, pic->width, pic->height, pic);
else
Draw_TextBox(px-16, py-8-8, pw/8, linecount+2);
}

7
engine/client/r_surf.c
View File

@ -2088,7 +2088,12 @@ void Surf_DrawWorld (void)
}
}
CL_LinkStaticEntities(vis);
if (!(r_refdef.flags & Q2RDF_NOWORLDMODEL))
{
CL_LinkStaticEntities(vis);
TRACE(("dbg: calling R_DrawParticles\n"));
P_DrawParticles ();
}
RSpeedEnd(RSPEED_WORLDNODE);
TRACE(("dbg: calling BE_DrawWorld\n"));

1
engine/client/render.h
View File

@ -410,6 +410,7 @@ extern cvar_t r_speeds;
extern cvar_t r_waterwarp;
extern cvar_t r_fullbright;
extern cvar_t r_lightmap;
extern cvar_t r_glsl_offsetmapping;
extern cvar_t r_shadow_realtime_dlight, r_shadow_realtime_dlight_shadows;
extern cvar_t r_shadow_realtime_world,r_shadow_realtime_world_shadows;
extern cvar_t r_mirroralpha;

2
engine/client/sys_linux.c
View File

@ -612,7 +612,7 @@ int main (int c, const char **v)
COM_InitArgv(parms.argc, parms.argv);
TL_InitLanguages();
parms.memsize = 16*1024*1024;
parms.memsize = 64*1024*1024;
j = COM_CheckParm("-mem");
if (j && j+1 < com_argc)

2
engine/common/net_wins.c
View File

@ -3029,7 +3029,7 @@ int TCP_OpenStream (netadr_t remoteaddr)
int newsocket;
int temp;
struct sockaddr_qstorage qs;
struct sockaddr_qstorage loc;
// struct sockaddr_qstorage loc;
temp = NetadrToSockadr(&remoteaddr, &qs);

16
engine/d3d/d3d_shader.c
View File

@ -154,10 +154,11 @@ void D3DShader_Init(void)
return;
}
void D3DShader_CreateProgram (program_t *prog, int permu, char **precompilerconstants, char *vert, char *frag)
qboolean D3DShader_CreateProgram (program_t *prog, int permu, char **precompilerconstants, char *vert, char *frag)
{
D3DXMACRO defines[64];
LPD3DXBUFFER code = NULL, errors = NULL;
qboolean success = false;
prog->handle[permu].hlsl.vert = NULL;
prog->handle[permu].hlsl.frag = NULL;
@ -168,7 +169,7 @@ void D3DShader_CreateProgram (program_t *prog, int permu, char **precompilercons
for (consts = 2; precompilerconstants[consts]; consts++)
;
if (consts >= sizeof(defines) / sizeof(defines[0]))
return;
return success;
consts = 0;
defines[consts].Name = NULL; /*shader type*/
@ -189,8 +190,12 @@ void D3DShader_CreateProgram (program_t *prog, int permu, char **precompilercons
defines[consts].Name = NULL;
defines[consts].Definition = NULL;
success = true;
defines[0].Name = "VERTEX_SHADER";
if (!FAILED(pD3DXCompileShader(vert, strlen(vert), defines, NULL, "main", "vs_2_0", 0, &code, &errors, (LPD3DXCONSTANTTABLE*)&prog->handle[permu].hlsl.ctabv)))
if (FAILED(pD3DXCompileShader(vert, strlen(vert), defines, NULL, "main", "vs_2_0", 0, &code, &errors, (LPD3DXCONSTANTTABLE*)&prog->handle[permu].hlsl.ctabv)))
success = false;
else
{
IDirect3DDevice9_CreateVertexShader(pD3DDev9, code->lpVtbl->GetBufferPointer(code), (IDirect3DVertexShader9**)&prog->handle[permu].hlsl.vert);
code->lpVtbl->Release(code);
@ -203,7 +208,9 @@ void D3DShader_CreateProgram (program_t *prog, int permu, char **precompilercons
}
defines[0].Name = "FRAGMENT_SHADER";
if (!FAILED(pD3DXCompileShader(frag, strlen(frag), defines, NULL, "main", "ps_2_0", 0, &code, &errors, (LPD3DXCONSTANTTABLE*)&prog->handle[permu].hlsl.ctabf)))
if (FAILED(pD3DXCompileShader(frag, strlen(frag), defines, NULL, "main", "ps_2_0", 0, &code, &errors, (LPD3DXCONSTANTTABLE*)&prog->handle[permu].hlsl.ctabf)))
success = false;
else
{
IDirect3DDevice9_CreatePixelShader(pD3DDev9, code->lpVtbl->GetBufferPointer(code), (IDirect3DPixelShader9**)&prog->handle[permu].hlsl.frag);
code->lpVtbl->Release(code);
@ -215,6 +222,7 @@ void D3DShader_CreateProgram (program_t *prog, int permu, char **precompilercons
errors->lpVtbl->Release(errors);
}
}
return success;
}
static int D3DShader_FindUniform_(LPD3DXCONSTANTTABLE ct, char *name)

572
engine/gl/gl_backend.c
View File

@ -127,6 +127,7 @@ struct {
unsigned int shaderbits;
unsigned int sha_attr;
int currentprogram;
int lastuniform; /*program which was last set, so using the same prog for multiple surfaces on the same ent (ie: world) does not require lots of extra uniform chnges*/
vbo_t dummyvbo;
int colourarraytype;
@ -2228,287 +2229,310 @@ static void DrawPass(const shaderpass_t *pass)
BE_SubmitMeshChain();
}
static unsigned int BE_Program_Set_Attribute(const shaderprogparm_t *p, unsigned int perm)
static unsigned int BE_Program_Set_Attributes(const program_t *prog, unsigned int perm, qboolean entunchanged)
{
vec3_t param3;
int r, g, b;
int i;
unsigned int attr = 0;
const shaderprogparm_t *p;
switch(p->type)
for (i = 0; i < prog->numparams; i++)
{
case SP_ATTR_VERTEX:
/*we still do vertex transforms for billboards and shadows and such*/
GL_SelectVBO(shaderstate.pendingvertexvbo);
qglVertexAttribPointer(p->handle[perm], 3, GL_FLOAT, GL_FALSE, sizeof(vecV_t), shaderstate.pendingvertexpointer);
return 1u<<p->handle[perm];
case SP_ATTR_COLOUR:
if (shaderstate.sourcevbo->colours.gl.addr)
{
GL_SelectVBO(shaderstate.sourcevbo->colours.gl.vbo);
qglVertexAttribPointer(p->handle[perm], 4, shaderstate.colourarraytype, GL_FALSE, 0, shaderstate.sourcevbo->colours.gl.addr);
return 1u<<p->handle[perm];
}
/* else if (shaderstate.sourcevbo->colours4ub)
{
GL_SelectVBO(shaderstate.sourcevbo->colours.gl.vbo);
qglVertexAttribPointer(p->handle[perm], 4, GL_UNSIGNED_BYTE, GL_TRUE, sizeof(byte_vec4_t), shaderstate.sourcevbo->colours.gl.addr);
return 1u<<p->handle[perm];
}*/
break;
case SP_ATTR_TEXCOORD:
GL_SelectVBO(shaderstate.sourcevbo->texcoord.gl.vbo);
qglVertexAttribPointer(p->handle[perm], 2, GL_FLOAT, GL_FALSE, sizeof(vec2_t), shaderstate.sourcevbo->texcoord.gl.addr);
return 1u<<p->handle[perm];
case SP_ATTR_LMCOORD:
GL_SelectVBO(shaderstate.sourcevbo->lmcoord.gl.vbo);
qglVertexAttribPointer(p->handle[perm], 2, GL_FLOAT, GL_FALSE, sizeof(vec2_t), shaderstate.sourcevbo->lmcoord.gl.addr);
return 1u<<p->handle[perm];
case SP_ATTR_NORMALS:
if (!shaderstate.sourcevbo->normals.gl.addr)
return 0;
GL_SelectVBO(shaderstate.sourcevbo->normals.gl.vbo);
qglVertexAttribPointer(p->handle[perm], 3, GL_FLOAT, GL_FALSE, sizeof(vec3_t), shaderstate.sourcevbo->normals.gl.addr);
return 1u<<p->handle[perm];
case SP_ATTR_SNORMALS:
if (!shaderstate.sourcevbo->svector.gl.addr)
return 0;
GL_SelectVBO(shaderstate.sourcevbo->svector.gl.vbo);
qglVertexAttribPointer(p->handle[perm], 3, GL_FLOAT, GL_FALSE, sizeof(vec3_t), shaderstate.sourcevbo->svector.gl.addr);
return 1u<<p->handle[perm];
case SP_ATTR_TNORMALS:
if (!shaderstate.sourcevbo->tvector.gl.addr)
return 0;
GL_SelectVBO(shaderstate.sourcevbo->tvector.gl.vbo);
qglVertexAttribPointer(p->handle[perm], 3, GL_FLOAT, GL_FALSE, sizeof(vec3_t), shaderstate.sourcevbo->tvector.gl.addr);
return 1u<<p->handle[perm];
case SP_ATTR_BONENUMS:
GL_SelectVBO(shaderstate.sourcevbo->bonenums.gl.vbo);
qglVertexAttribPointer(p->handle[perm], 4, GL_UNSIGNED_BYTE, GL_FALSE, sizeof(byte_vec4_t), shaderstate.sourcevbo->bonenums.gl.addr);
return 1u<<p->handle[perm];
case SP_ATTR_BONEWEIGHTS:
GL_SelectVBO(shaderstate.sourcevbo->boneweights.gl.vbo);
qglVertexAttribPointer(p->handle[perm], 4, GL_FLOAT, GL_FALSE, sizeof(vec4_t), shaderstate.sourcevbo->boneweights.gl.addr);
return 1u<<p->handle[perm];
p = &prog->parm[i];
if (p->handle[perm] == -1)
continue; /*not in this permutation*/
case SP_M_VIEW:
qglUniformMatrix4fvARB(p->handle[perm], 1, false, r_refdef.m_view);
break;
case SP_M_PROJECTION:
qglUniformMatrix4fvARB(p->handle[perm], 1, false, r_refdef.m_projection);
break;
case SP_M_MODELVIEW:
qglUniformMatrix4fvARB(p->handle[perm], 1, false, shaderstate.modelviewmatrix);
break;
case SP_M_MODELVIEWPROJECTION:
{
float m16[16];
Matrix4_Multiply(r_refdef.m_projection, shaderstate.modelviewmatrix, m16);
qglUniformMatrix4fvARB(p->handle[perm], 1, false, m16);
}
break;
case SP_M_INVMODELVIEWPROJECTION:
{
float m16[16], inv[16];
Matrix4_Multiply(r_refdef.m_projection, shaderstate.modelviewmatrix, m16);
Matrix4_Invert(m16, inv);
qglUniformMatrix4fvARB(p->handle[perm], 1, false, inv);
}
break;
case SP_M_MODEL:
qglUniformMatrix4fvARB(p->handle[perm], 1, false, shaderstate.modelmatrix);
break;
case SP_M_ENTBONES:
{
qglUniformMatrix3x4fv(p->handle[perm], shaderstate.sourcevbo->numbones, false, shaderstate.sourcevbo->bones);
}
break;
case SP_M_INVVIEWPROJECTION:
{
float m16[16], inv[16];
Matrix4_Multiply(r_refdef.m_projection, r_refdef.m_view, m16);
Matrix4_Invert(m16, inv);
qglUniformMatrix4fvARB(p->handle[perm], 1, false, inv);
}
break;
/*don't bother setting it if the ent properties are unchanged (but do if the mesh changed)*/
if (entunchanged && p->type >= SP_FIRSTUNIFORM)
break;
case SP_E_LMSCALE:
switch(p->type)
{
vec4_t colscale;
if (shaderstate.mode == BEM_DEPTHDARK)
case SP_ATTR_VERTEX:
/*we still do vertex transforms for billboards and shadows and such*/
GL_SelectVBO(shaderstate.pendingvertexvbo);
qglVertexAttribPointer(p->handle[perm], 3, GL_FLOAT, GL_FALSE, sizeof(vecV_t), shaderstate.pendingvertexpointer);
attr |= 1u<<p->handle[perm];
break;
case SP_ATTR_COLOUR:
if (shaderstate.sourcevbo->colours.gl.addr)
{
VectorClear(colscale);
GL_SelectVBO(shaderstate.sourcevbo->colours.gl.vbo);
qglVertexAttribPointer(p->handle[perm], 4, shaderstate.colourarraytype, GL_FALSE, 0, shaderstate.sourcevbo->colours.gl.addr);
attr |= 1u<<p->handle[perm];
break;
}
else if (shaderstate.curentity->model && shaderstate.curentity->model->engineflags & MDLF_NEEDOVERBRIGHT)
/* else if (shaderstate.sourcevbo->colours4ub)
{
float sc = 1<<bound(0, gl_overbright.ival, 2);
VectorScale(shaderstate.curentity->shaderRGBAf, sc, colscale);
GL_SelectVBO(shaderstate.sourcevbo->colours.gl.vbo);
qglVertexAttribPointer(p->handle[perm], 4, GL_UNSIGNED_BYTE, GL_TRUE, sizeof(byte_vec4_t), shaderstate.sourcevbo->colours.gl.addr);
return 1u<<p->handle[perm];
}*/
break;
case SP_ATTR_TEXCOORD:
GL_SelectVBO(shaderstate.sourcevbo->texcoord.gl.vbo);
qglVertexAttribPointer(p->handle[perm], 2, GL_FLOAT, GL_FALSE, sizeof(vec2_t), shaderstate.sourcevbo->texcoord.gl.addr);
attr |= 1u<<p->handle[perm];
break;
case SP_ATTR_LMCOORD:
GL_SelectVBO(shaderstate.sourcevbo->lmcoord.gl.vbo);
qglVertexAttribPointer(p->handle[perm], 2, GL_FLOAT, GL_FALSE, sizeof(vec2_t), shaderstate.sourcevbo->lmcoord.gl.addr);
attr |= 1u<<p->handle[perm];
break;
case SP_ATTR_NORMALS:
if (!shaderstate.sourcevbo->normals.gl.addr)
break;
GL_SelectVBO(shaderstate.sourcevbo->normals.gl.vbo);
qglVertexAttribPointer(p->handle[perm], 3, GL_FLOAT, GL_FALSE, sizeof(vec3_t), shaderstate.sourcevbo->normals.gl.addr);
attr |= 1u<<p->handle[perm];
break;
case SP_ATTR_SNORMALS:
if (!shaderstate.sourcevbo->svector.gl.addr)
break;
GL_SelectVBO(shaderstate.sourcevbo->svector.gl.vbo);
qglVertexAttribPointer(p->handle[perm], 3, GL_FLOAT, GL_FALSE, sizeof(vec3_t), shaderstate.sourcevbo->svector.gl.addr);
attr |= 1u<<p->handle[perm];
break;
case SP_ATTR_TNORMALS:
if (!shaderstate.sourcevbo->tvector.gl.addr)
break;
GL_SelectVBO(shaderstate.sourcevbo->tvector.gl.vbo);
qglVertexAttribPointer(p->handle[perm], 3, GL_FLOAT, GL_FALSE, sizeof(vec3_t), shaderstate.sourcevbo->tvector.gl.addr);
attr |= 1u<<p->handle[perm];
break;
case SP_ATTR_BONENUMS:
GL_SelectVBO(shaderstate.sourcevbo->bonenums.gl.vbo);
qglVertexAttribPointer(p->handle[perm], 4, GL_UNSIGNED_BYTE, GL_FALSE, sizeof(byte_vec4_t), shaderstate.sourcevbo->bonenums.gl.addr);
attr |= 1u<<p->handle[perm];
break;
case SP_ATTR_BONEWEIGHTS:
GL_SelectVBO(shaderstate.sourcevbo->boneweights.gl.vbo);
qglVertexAttribPointer(p->handle[perm], 4, GL_FLOAT, GL_FALSE, sizeof(vec4_t), shaderstate.sourcevbo->boneweights.gl.addr);
attr |= 1u<<p->handle[perm];
break;
case SP_M_VIEW:
qglUniformMatrix4fvARB(p->handle[perm], 1, false, r_refdef.m_view);
break;
case SP_M_PROJECTION:
qglUniformMatrix4fvARB(p->handle[perm], 1, false, r_refdef.m_projection);
break;
case SP_M_MODELVIEW:
qglUniformMatrix4fvARB(p->handle[perm], 1, false, shaderstate.modelviewmatrix);
break;
case SP_M_MODELVIEWPROJECTION:
{
float m16[16];
Matrix4_Multiply(r_refdef.m_projection, shaderstate.modelviewmatrix, m16);
qglUniformMatrix4fvARB(p->handle[perm], 1, false, m16);
}
break;
case SP_M_INVMODELVIEWPROJECTION:
{
float m16[16], inv[16];
Matrix4_Multiply(r_refdef.m_projection, shaderstate.modelviewmatrix, m16);
Matrix4_Invert(m16, inv);
qglUniformMatrix4fvARB(p->handle[perm], 1, false, inv);
}
break;
case SP_M_MODEL:
qglUniformMatrix4fvARB(p->handle[perm], 1, false, shaderstate.modelmatrix);
break;
case SP_M_ENTBONES:
{
qglUniformMatrix3x4fv(p->handle[perm], shaderstate.sourcevbo->numbones, false, shaderstate.sourcevbo->bones);
}
break;
case SP_M_INVVIEWPROJECTION:
{
float m16[16], inv[16];
Matrix4_Multiply(r_refdef.m_projection, r_refdef.m_view, m16);
Matrix4_Invert(m16, inv);
qglUniformMatrix4fvARB(p->handle[perm], 1, false, inv);
}
break;
case SP_E_LMSCALE:
{
vec4_t colscale;
if (shaderstate.mode == BEM_DEPTHDARK)
{
VectorClear(colscale);
}
else if (shaderstate.curentity->model && shaderstate.curentity->model->engineflags & MDLF_NEEDOVERBRIGHT)
{
float sc = 1<<bound(0, gl_overbright.ival, 2);
VectorScale(shaderstate.curentity->shaderRGBAf, sc, colscale);
}
else
{
VectorCopy(shaderstate.curentity->shaderRGBAf, colscale);
}
colscale[3] = shaderstate.curentity->shaderRGBAf[3];
qglUniform4fvARB(p->handle[perm], 1, (GLfloat*)colscale);
}
break;
case SP_E_GLOWMOD:
qglUniform3fvARB(p->handle[perm], 1, (GLfloat*)shaderstate.curentity->glowmod);
break;
case SP_E_ORIGIN:
qglUniform3fvARB(p->handle[perm], 1, (GLfloat*)shaderstate.curentity->origin);
break;
case SP_E_COLOURS:
qglUniform4fvARB(p->handle[perm], 1, (GLfloat*)shaderstate.curentity->shaderRGBAf);
break;
case SP_E_COLOURSIDENT:
if (shaderstate.flags & BEF_FORCECOLOURMOD)
qglUniform4fvARB(p->handle[perm], 1, (GLfloat*)shaderstate.curentity->shaderRGBAf);
else
qglUniform4fARB(p->handle[perm], 1, 1, 1, shaderstate.curentity->shaderRGBAf[3]);
break;
case SP_E_TOPCOLOURS:
R_FetchTopColour(&r, &g, &b);
param3[0] = r/255.0f;
param3[1] = g/255.0f;
param3[2] = b/255.0f;
qglUniform3fvARB(p->handle[perm], 1, param3);
break;
case SP_E_BOTTOMCOLOURS:
R_FetchBottomColour(&r, &g, &b);
param3[0] = r/255.0f;
param3[1] = g/255.0f;
param3[2] = b/255.0f;
qglUniform3fvARB(p->handle[perm], 1, param3);
break;
case SP_RENDERTEXTURESCALE:
if (gl_config.arb_texture_non_power_of_two)
{
param3[0] = 1;
param3[1] = 1;
}
else
{
VectorCopy(shaderstate.curentity->shaderRGBAf, colscale);
}
colscale[3] = shaderstate.curentity->shaderRGBAf[3];
qglUniform4fvARB(p->handle[perm], 1, (GLfloat*)colscale);
}
break;
case SP_E_GLOWMOD:
qglUniform3fvARB(p->handle[perm], 1, (GLfloat*)shaderstate.curentity->glowmod);
break;
case SP_E_ORIGIN:
qglUniform3fvARB(p->handle[perm], 1, (GLfloat*)shaderstate.curentity->origin);
break;
case SP_E_COLOURS:
qglUniform4fvARB(p->handle[perm], 1, (GLfloat*)shaderstate.curentity->shaderRGBAf);
break;
case SP_E_COLOURSIDENT:
if (shaderstate.flags & BEF_FORCECOLOURMOD)
qglUniform4fvARB(p->handle[perm], 1, (GLfloat*)shaderstate.curentity->shaderRGBAf);
else
qglUniform4fARB(p->handle[perm], 1, 1, 1, shaderstate.curentity->shaderRGBAf[3]);
break;
case SP_E_TOPCOLOURS:
R_FetchTopColour(&r, &g, &b);
param3[0] = r/255.0f;
param3[1] = g/255.0f;
param3[2] = b/255.0f;
qglUniform3fvARB(p->handle[perm], 1, param3);
break;
case SP_E_BOTTOMCOLOURS:
R_FetchBottomColour(&r, &g, &b);
param3[0] = r/255.0f;
param3[1] = g/255.0f;
param3[2] = b/255.0f;
qglUniform3fvARB(p->handle[perm], 1, param3);
break;
case SP_RENDERTEXTURESCALE:
if (gl_config.arb_texture_non_power_of_two)
{
param3[0] = 1;
param3[1] = 1;
}
else
{
r = 1;
g = 1;
while (r < vid.pixelwidth)
r *= 2;
while (g < vid.pixelheight)
g *= 2;
param3[0] = vid.pixelwidth/(float)r;
param3[1] = vid.pixelheight/(float)g;
}
param3[2] = 1;
qglUniform3fvARB(p->handle[perm], 1, param3);
break;
case SP_LIGHTSCREEN:
{
float v[4], tempv[4];
v[0] = shaderstate.lightorg[0];
v[1] = shaderstate.lightorg[1];
v[2] = shaderstate.lightorg[2];
v[3] = 1;
Matrix4x4_CM_Transform4(shaderstate.modelviewmatrix, v, tempv);
Matrix4x4_CM_Transform4(r_refdef.m_projection, tempv, v);
v[3] *= 2;
v[0] = (v[0]/v[3]) + 0.5;
v[1] = (v[1]/v[3]) + 0.5;
v[2] = (v[2]/v[3]) + 0.5;
qglUniform3fvARB(p->handle[perm], 1, v);
}
break;
case SP_LIGHTRADIUS:
qglUniform1fARB(p->handle[perm], shaderstate.lightradius);
break;
case SP_LIGHTCOLOUR:
qglUniform3fvARB(p->handle[perm], 1, shaderstate.lightcolours);
break;
case SP_W_FOG:
qglUniform4fvARB(p->handle[perm], 1, r_refdef.gfog_rgbd);
break;
case SP_V_EYEPOS:
qglUniform3fvARB(p->handle[perm], 1, r_origin);
break;
case SP_E_EYEPOS:
{
/*eye position in model space*/
vec3_t t2;
Matrix4x4_CM_Transform3(shaderstate.modelmatrixinv, r_origin, t2);
qglUniform3fvARB(p->handle[perm], 1, t2);
}
break;
case SP_LIGHTPOSITION:
{
/*light position in model space*/
vec3_t t2;
Matrix4x4_CM_Transform3(shaderstate.modelmatrixinv, shaderstate.lightorg, t2);
qglUniform3fvARB(p->handle[perm], 1, t2);
}
break;
case SP_LIGHTCOLOURSCALE:
qglUniform3fvARB(p->handle[perm], 1, shaderstate.lightcolourscale);
break;
case SP_LIGHTPROJMATRIX:
/*light's texture projection matrix*/
{
float t[16];
Matrix4_Multiply(shaderstate.lightprojmatrix, shaderstate.modelmatrix, t);
qglUniformMatrix4fvARB(p->handle[perm], 1, false, t);
}
break;
/*static lighting info*/
case SP_E_L_DIR:
qglUniform3fvARB(p->handle[perm], 1, (float*)shaderstate.curentity->light_dir);
break;
case SP_E_L_MUL:
qglUniform3fvARB(p->handle[perm], 1, (float*)shaderstate.curentity->light_range);
break;
case SP_E_L_AMBIENT:
qglUniform3fvARB(p->handle[perm], 1, (float*)shaderstate.curentity->light_avg);
break;
case SP_E_TIME:
qglUniform1fARB(p->handle[perm], shaderstate.curtime);
break;
case SP_CONSTI:
case SP_TEXTURE:
qglUniform1iARB(p->handle[perm], p->ival);
break;
case SP_CONSTF:
qglUniform1fARB(p->handle[perm], p->fval);
break;
case SP_CVARI:
qglUniform1iARB(p->handle[perm], ((cvar_t*)p->pval)->ival);
break;
case SP_CVARF:
qglUniform1fARB(p->handle[perm], ((cvar_t*)p->pval)->value);
break;
case SP_CVAR3F:
{
cvar_t *var = (cvar_t*)p->pval;
char *vs = var->string;
vs = COM_Parse(vs);
param3[0] = atof(com_token);
vs = COM_Parse(vs);
param3[1] = atof(com_token);
vs = COM_Parse(vs);
param3[2] = atof(com_token);
r = 1;
g = 1;
while (r < vid.pixelwidth)
r *= 2;
while (g < vid.pixelheight)
g *= 2;
param3[0] = vid.pixelwidth/(float)r;
param3[1] = vid.pixelheight/(float)g;
}
param3[2] = 1;
qglUniform3fvARB(p->handle[perm], 1, param3);
}
break;
break;
default:
Host_EndGame("Bad shader program parameter type (%i)", p->type);
break;
case SP_LIGHTSCREEN:
{
float v[4], tempv[4];
v[0] = shaderstate.lightorg[0];
v[1] = shaderstate.lightorg[1];
v[2] = shaderstate.lightorg[2];
v[3] = 1;
Matrix4x4_CM_Transform4(shaderstate.modelviewmatrix, v, tempv);
Matrix4x4_CM_Transform4(r_refdef.m_projection, tempv, v);
v[3] *= 2;
v[0] = (v[0]/v[3]) + 0.5;
v[1] = (v[1]/v[3]) + 0.5;
v[2] = (v[2]/v[3]) + 0.5;
qglUniform3fvARB(p->handle[perm], 1, v);
}
break;
case SP_LIGHTRADIUS:
qglUniform1fARB(p->handle[perm], shaderstate.lightradius);
break;
case SP_LIGHTCOLOUR:
qglUniform3fvARB(p->handle[perm], 1, shaderstate.lightcolours);
break;
case SP_W_FOG:
qglUniform4fvARB(p->handle[perm], 1, r_refdef.gfog_rgbd);
break;
case SP_V_EYEPOS:
qglUniform3fvARB(p->handle[perm], 1, r_origin);
break;
case SP_E_EYEPOS:
{
/*eye position in model space*/
vec3_t t2;
Matrix4x4_CM_Transform3(shaderstate.modelmatrixinv, r_origin, t2);
qglUniform3fvARB(p->handle[perm], 1, t2);
}
break;
case SP_LIGHTPOSITION:
{
/*light position in model space*/
vec3_t t2;
Matrix4x4_CM_Transform3(shaderstate.modelmatrixinv, shaderstate.lightorg, t2);
qglUniform3fvARB(p->handle[perm], 1, t2);
}
break;
case SP_LIGHTCOLOURSCALE:
qglUniform3fvARB(p->handle[perm], 1, shaderstate.lightcolourscale);
break;
case SP_LIGHTPROJMATRIX:
/*light's texture projection matrix*/
{
float t[16];
Matrix4_Multiply(shaderstate.lightprojmatrix, shaderstate.modelmatrix, t);
qglUniformMatrix4fvARB(p->handle[perm], 1, false, t);
}
break;
/*static lighting info*/
case SP_E_L_DIR:
qglUniform3fvARB(p->handle[perm], 1, (float*)shaderstate.curentity->light_dir);
break;
case SP_E_L_MUL:
qglUniform3fvARB(p->handle[perm], 1, (float*)shaderstate.curentity->light_range);
break;
case SP_E_L_AMBIENT:
qglUniform3fvARB(p->handle[perm], 1, (float*)shaderstate.curentity->light_avg);
break;
case SP_E_TIME:
qglUniform1fARB(p->handle[perm], shaderstate.curtime);
break;
case SP_CONSTI:
case SP_TEXTURE:
qglUniform1iARB(p->handle[perm], p->ival);
break;
case SP_CONSTF:
qglUniform1fARB(p->handle[perm], p->fval);
break;
case SP_CVARI:
qglUniform1iARB(p->handle[perm], ((cvar_t*)p->pval)->ival);
break;
case SP_CVARF:
qglUniform1fARB(p->handle[perm], ((cvar_t*)p->pval)->value);
break;
case SP_CVAR3F:
{
cvar_t *var = (cvar_t*)p->pval;
char *vs = var->string;
vs = COM_Parse(vs);
param3[0] = atof(com_token);
vs = COM_Parse(vs);
param3[1] = atof(com_token);
vs = COM_Parse(vs);
param3[2] = atof(com_token);
qglUniform3fvARB(p->handle[perm], 1, param3);
}
break;
default:
Host_EndGame("Bad shader program parameter type (%i)", p->type);
break;
}
}
return 0;
return attr;
}
static void BE_RenderMeshProgram(const shader_t *shader, const shaderpass_t *pass)
@ -2541,16 +2565,18 @@ static void BE_RenderMeshProgram(const shader_t *shader, const shaderpass_t *pas
perm |= PERMUTATION_FOG;
if (r_glsl_offsetmapping.ival && TEXVALID(shaderstate.curtexnums->bump) && p->handle[perm|PERMUTATION_OFFSET].glsl)
perm |= PERMUTATION_OFFSET;
GL_SelectProgram(p->handle[perm].glsl);
if (shaderstate.lastuniform == p->handle[perm].glsl)
i = true;
else
{
i = false;
shaderstate.lastuniform = p->handle[perm].glsl;
}
attr = BE_Program_Set_Attributes(p, perm, i);
BE_SendPassBlendDepthMask(pass->shaderbits);
for (i = 0; i < p->numparams; i++)
{
if (p->parm[i].handle[perm] == -1)
continue; /*not in this permutation*/
attr |= BE_Program_Set_Attribute(&p->parm[i], perm);
}
if (p->nofixedcompat)
{
qglDisableClientState(GL_COLOR_ARRAY);
@ -2767,6 +2793,8 @@ void GLBE_SelectEntity(entity_t *ent)
qglLoadMatrixf(shaderstate.modelviewmatrix);
if (shaderstate.curentity->flags & Q2RF_DEPTHHACK && qglDepthRange)
qglDepthRange (gldepthmin, gldepthmin + 0.3*(gldepthmax-gldepthmin));
shaderstate.lastuniform = 0;
}
void BE_SelectFog(vec3_t colour, float alpha, float density)
@ -2815,6 +2843,8 @@ void GLBE_SelectDLight(dlight_t *dl, vec3_t colour)
#ifdef RTLIGHTS
shaderstate.lightcubemap = dl->cubetexture;
#endif
shaderstate.lastuniform = 0;
}
void BE_PushOffsetShadow(qboolean pushdepth)

6
engine/gl/gl_rmain.c
View File

@ -462,12 +462,6 @@ void R_RenderScene (void)
RQ_BeginFrame();
if (!(r_refdef.flags & Q2RDF_NOWORLDMODEL))
{
TRACE(("dbg: calling R_DrawParticles\n"));
P_DrawParticles ();
}
if (!(r_refdef.flags & Q2RDF_NOWORLDMODEL))
{
TRACE(("dbg: calling R_DrawWorld\n"));

2
engine/gl/gl_rmisc.c
View File

@ -550,7 +550,7 @@ TRACE(("dbg: GLR_NewMap: tp\n"));
void GLR_PreNewMap(void)
{
r_loadbumpmapping = r_deluxemapping.ival || r_shadow_realtime_world.ival || r_shadow_realtime_dlight.ival;
r_loadbumpmapping = r_deluxemapping.ival || r_shadow_realtime_world.ival || r_shadow_realtime_dlight.ival || r_glsl_offsetmapping.ival;
}

68
engine/gl/gl_shader.c
View File

@ -2507,40 +2507,6 @@ static void Shader_ProgAutoFields(program_t *prog, char **cvarnames, int *cvarty
if (gl_config.nofixedfunc)
prog->nofixedcompat = true;
/*set cvar unirforms*/
for (i = 0; cvarnames[i]; i++)
{
if (prog->numparams == SHADER_PROGPARMS_MAX)
{
Con_Printf("Too many cvar paramters for program\n");
break;
}
for (p = 0; cvarnames[i][p] && (unsigned char)cvarnames[i][p] > 32 && p < sizeof(tmpname)-1; p++)
tmpname[p] = cvarnames[i][p];
tmpname[p] = 0;
cvar = Cvar_Get(tmpname, "0", CVAR_SHADERSYSTEM, "glsl cvars");
if (!cvar)
continue;
cvar->flags |= CVAR_SHADERSYSTEM;
prog->parm[prog->numparams].type = cvartypes[i];
prog->parm[prog->numparams].pval = cvar;
found = false;
for (p = 0; p < PERMUTATIONS; p++)
{
if (!prog->handle[p].glsl)
continue;
GL_SelectProgram(prog->handle[p].glsl);
uniformloc = qglGetUniformLocationARB(prog->handle[p].glsl, va("cvar_%s", tmpname));
if (uniformloc != -1)
{
qglUniform1fARB(uniformloc, cvar->value);
found = true;
}
prog->parm[prog->numparams].handle[p] = uniformloc;
}
if (found)
prog->numparams++;
}
for (i = 0; shader_field_names[i].name; i++)
{
found = false;
@ -2577,6 +2543,40 @@ static void Shader_ProgAutoFields(program_t *prog, char **cvarnames, int *cvarty
}
}
}
/*set cvar unirforms*/
for (i = 0; cvarnames[i]; i++)
{
if (prog->numparams == SHADER_PROGPARMS_MAX)
{
Con_Printf("Too many cvar paramters for program\n");
break;
}
for (p = 0; cvarnames[i][p] && (unsigned char)cvarnames[i][p] > 32 && p < sizeof(tmpname)-1; p++)
tmpname[p] = cvarnames[i][p];
tmpname[p] = 0;
cvar = Cvar_Get(tmpname, "0", CVAR_SHADERSYSTEM, "glsl cvars");
if (!cvar)
continue;
cvar->flags |= CVAR_SHADERSYSTEM;
prog->parm[prog->numparams].type = cvartypes[i];
prog->parm[prog->numparams].pval = cvar;
found = false;
for (p = 0; p < PERMUTATIONS; p++)
{
if (!prog->handle[p].glsl)
continue;
GL_SelectProgram(prog->handle[p].glsl);
uniformloc = qglGetUniformLocationARB(prog->handle[p].glsl, va("cvar_%s", tmpname));
if (uniformloc != -1)
{
qglUniform1fARB(uniformloc, cvar->value);
found = true;
}
prog->parm[prog->numparams].handle[p] = uniformloc;
}
if (found)
prog->numparams++;
}
/*set texture uniforms*/
for (p = 0; p < PERMUTATIONS; p++)
{

2
engine/gl/shader.h
View File

@ -492,7 +492,7 @@ qboolean D3DBE_LightCullModel(vec3_t org, model_t *model);
void D3DBE_SelectEntity(entity_t *ent);
void D3DBE_SelectDLight(dlight_t *dl, vec3_t colour);
void D3DShader_CreateProgram (program_t *prog, int permu, char **precompilerconstants, char *vert, char *frag);
qboolean D3DShader_CreateProgram (program_t *prog, int permu, char **precompilerconstants, char *vert, char *frag);
int D3DShader_FindUniform(union programhandle_u *h, int type, char *name);
void D3DShader_Init(void);
void D3DBE_Reset(qboolean before);

14
engine/http/iweb.h
View File

@ -5,10 +5,10 @@
#ifdef WEBSVONLY
typedef unsigned char qbyte;
#include <stdlib.h>
#include <stdio.h>
#include <malloc.h>
#include "quakedef.h"
#ifdef _WIN32
#include "winquake.h"
#endif
#define Con_TPrintf IWebPrintf
#define TL_NETBINDINTERFACE "binding to %s"
@ -24,12 +24,6 @@ typedef unsigned char qbyte;
#define IWebFree free
#endif
#include "quakedef.h"
#ifdef _WIN32
#include "winquake.h"
#endif
#define IWEBACC_READ 1
#define IWEBACC_WRITE 2
#define IWEBACC_FULL 4

8
engine/http/iwebiface.c
View File

@ -1,11 +1,5 @@
#include "quakedef.h"
#ifdef WEBSVONLY
#define WEBSERVER
#else
#include "bothdefs.h"
#endif
#ifdef WEBSERVER
#include "iweb.h"
@ -102,7 +96,7 @@ int main(int argc, char **argv)
while(1)
{
FTP_ServerRun(1, 21);
// FTP_ServerRun(1, 21);
HTTP_ServerPoll(1, 80);
Sleep(1);
}

7
engine/server/pr_cmds.c
View File

@ -2159,8 +2159,11 @@ static void QCBUILTIN PF_setsize (progfuncs_t *prinst, struct globalvars_s *pr_g
e = G_EDICT(prinst, OFS_PARM0);
if (e->isfree)
{
Con_TPrintf(STL_EDICTWASFREE, "setsize");
(*prinst->pr_trace) = 1;
if (progstype != PROG_H2)
{
Con_TPrintf(STL_EDICTWASFREE, "setsize");
(*prinst->pr_trace) = 1;
}
return;
}
min = G_VECTOR(OFS_PARM1);

3
engine/server/savegame.c
View File

@ -766,9 +766,6 @@ qboolean SV_LoadLevelCache(char *savename, char *level, char *startspot, qboolea
pr_global_struct->time = 0.1;
pr_global_struct->self = EDICT_TO_PROG(svprogfuncs, ent);
f = PR_FindFunction(svprogfuncs, PR_GetString(svprogfuncs, ent->v->classname), PR_ANY);
svprogfuncs->ToggleBreak(svprogfuncs, PR_GetString(svprogfuncs, ent->v->classname), 0, 1);
svprogfuncs->ToggleBreak(svprogfuncs, "trigger_crosslevel_target_think", 0, 1);
if (f)
PR_ExecuteProgram(svprogfuncs, f);

2
engine/server/sv_sys_unix.c
View File

@ -700,7 +700,7 @@ int main(int argc, char *argv[])
}
#endif
parms.memsize = 16*1024*1024;
parms.memsize = 64*1024*1024;
j = COM_CheckParm("-mem");
if (j)