float r_farclip;
// view origin
-vec3_t r_origin;
-vec3_t vpn;
-vec3_t vright;
-vec3_t vup;
+vec3_t r_vieworigin;
+vec3_t r_viewforward;
+vec3_t r_viewleft;
+vec3_t r_viewright;
+vec3_t r_viewup;
//
// screen size info
cvar_t r_drawentities = {0, "r_drawentities","1"};
cvar_t r_drawviewmodel = {0, "r_drawviewmodel","1"};
-cvar_t r_shadows = {CVAR_SAVE, "r_shadows", "0"};
cvar_t r_shadow_staticworldlights = {0, "r_shadow_staticworldlights", "1"};
cvar_t r_speeds = {0, "r_speeds","0"};
cvar_t r_fullbright = {0, "r_fullbright","0"};
static void R_TimeRefresh_f (void)
{
int i;
- float start, stop, time;
+ float timestart, timedelta, oldangles[3];
intimerefresh = 1;
- start = Sys_DoubleTime ();
+ VectorCopy(cl.viewangles, oldangles);
+ VectorClear(cl.viewangles);
+
+ timestart = Sys_DoubleTime();
for (i = 0;i < 128;i++)
{
- r_refdef.viewangles[0] = 0;
- r_refdef.viewangles[1] = i/128.0*360.0;
- r_refdef.viewangles[2] = 0;
+ Matrix4x4_CreateFromQuakeEntity(&r_refdef.viewentitymatrix, r_vieworigin[0], r_vieworigin[1], r_vieworigin[2], 0, i / 128.0 * 360.0, 0, 1);
CL_UpdateScreen();
}
+ timedelta = Sys_DoubleTime() - timestart;
- stop = Sys_DoubleTime ();
+ VectorCopy(oldangles, cl.viewangles);
intimerefresh = 0;
- time = stop-start;
- Con_Printf ("%f seconds (%f fps)\n", time, 128/time);
+ Con_Printf ("%f seconds (%f fps)\n", timedelta, 128/timedelta);
}
vec3_t fogcolor;
Cmd_AddCommand("timerefresh", R_TimeRefresh_f);
Cvar_RegisterVariable(&r_drawentities);
Cvar_RegisterVariable(&r_drawviewmodel);
- Cvar_RegisterVariable(&r_shadows);
Cvar_RegisterVariable(&r_shadow_staticworldlights);
Cvar_RegisterVariable(&r_speeds);
Cvar_RegisterVariable(&r_fullbrights);
R_Light_Init();
R_Particles_Init();
R_Explosion_Init();
- ui_init();
+ //ui_init();
+ UI_Init();
Sbar_Init();
R_LightningBeams_Init();
}
R_LerpAnimation(ent);
R_UpdateEntLights(ent);
if ((chase_active.integer || !(ent->flags & RENDER_EXTERIORMODEL))
- && !VIS_CullBox(ent->mins, ent->maxs))
+ && !VIS_CullBox(ent->mins, ent->maxs)
+ && (!envmap || !(ent->flags & (RENDER_VIEWMODEL | RENDER_EXTERIORMODEL))))
{
ent->visframe = r_framecount;
R_FarClip_Box(ent->mins, ent->maxs);
}
}
-void R_DrawFakeShadows(void)
-{
- int i;
- entity_render_t *ent;
-
- ent = &cl_entities[0].render;
- if (ent->model && ent->model->DrawFakeShadow)
- ent->model->DrawFakeShadow(ent);
-
- if (!r_drawentities.integer)
- return;
- for (i = 0;i < r_refdef.numentities;i++)
- {
- ent = r_refdef.entities[i];
- if ((ent->flags & RENDER_SHADOW) && ent->model && ent->model->DrawFakeShadow)
- ent->model->DrawFakeShadow(ent);
- }
-}
-
#include "r_shadow.h"
int shadowframecount = 0;
void R_Shadow_DrawWorldLightShadowVolume(matrix4x4_t *matrix, worldlight_t *light);
-extern void R_Model_Brush_DrawLightForSurfaceList(entity_render_t *ent, vec3_t relativelightorigin, vec3_t relativeeyeorigin, float lightradius, float *lightcolor, msurface_t **surflist, int numsurfaces, const matrix4x4_t *matrix_modeltofilter, const matrix4x4_t *matrix_modeltoattenuationxyz, const matrix4x4_t *matrix_modeltoattenuationz);
void R_ShadowVolumeLighting(int visiblevolumes)
{
int i;
VectorScale(lightcolor, f, lightcolor);
}
- if (wl->castshadows && (gl_stencil || visiblevolumes))
+ if (r_shadow_worldshadows.integer && wl->castshadows && (gl_stencil || visiblevolumes))
{
if (!visiblevolumes)
R_Shadow_Stage_ShadowVolumes();
ent = &cl_entities[0].render;
- if (wl->shadowvolume && r_shadow_staticworldlights.integer)
- R_Shadow_DrawWorldLightShadowVolume(&ent->matrix, wl);
+ if (r_shadow_staticworldlights.integer)
+ R_Shadow_DrawStaticWorldLight_Shadow(wl, &ent->matrix);
else
R_TestAndDrawShadowVolume(ent, wl->origin, cullradius, lightradius, wl->mins, wl->maxs, clipmins, clipmaxs, true);
if (r_drawentities.integer)
if (!visiblevolumes)
{
- if (wl->castshadows && gl_stencil)
+ if (r_shadow_worldshadows.integer && wl->castshadows && gl_stencil)
R_Shadow_Stage_LightWithShadows();
else
R_Shadow_Stage_LightWithoutShadows();
if (ent->model && ent->model->DrawLight)
{
Matrix4x4_Transform(&ent->inversematrix, wl->origin, relativelightorigin);
- Matrix4x4_Transform(&ent->inversematrix, r_origin, relativeeyeorigin);
+ Matrix4x4_Transform(&ent->inversematrix, r_vieworigin, relativeeyeorigin);
Matrix4x4_Concat(&matrix_modeltofilter, &matrix_worldtofilter, &ent->matrix);
Matrix4x4_Concat(&matrix_modeltoattenuationxyz, &matrix_worldtoattenuationxyz, &ent->matrix);
Matrix4x4_Concat(&matrix_modeltoattenuationz, &matrix_worldtoattenuationz, &ent->matrix);
- if (wl->numsurfaces)
- R_Model_Brush_DrawLightForSurfaceList(ent, relativelightorigin, relativeeyeorigin, lightradius, lightcolor, wl->surfaces, wl->numsurfaces, &matrix_modeltofilter, &matrix_modeltoattenuationxyz, &matrix_modeltoattenuationz);
+ if (r_shadow_staticworldlights.integer)
+ R_Shadow_DrawStaticWorldLight_Light(wl, &ent->matrix, relativelightorigin, relativeeyeorigin, lightradius, lightcolor, &matrix_modeltofilter, &matrix_modeltoattenuationxyz, &matrix_modeltoattenuationz);
else
ent->model->DrawLight(ent, relativelightorigin, relativeeyeorigin, lightradius / ent->scale, lightcolor, &matrix_modeltofilter, &matrix_modeltoattenuationxyz, &matrix_modeltoattenuationz);
}
&& !(ent->effects & EF_ADDITIVE) && ent->alpha == 1)
{
Matrix4x4_Transform(&ent->inversematrix, wl->origin, relativelightorigin);
- Matrix4x4_Transform(&ent->inversematrix, r_origin, relativeeyeorigin);
+ Matrix4x4_Transform(&ent->inversematrix, r_vieworigin, relativeeyeorigin);
Matrix4x4_Concat(&matrix_modeltofilter, &matrix_worldtofilter, &ent->matrix);
Matrix4x4_Concat(&matrix_modeltoattenuationxyz, &matrix_worldtoattenuationxyz, &ent->matrix);
Matrix4x4_Concat(&matrix_modeltoattenuationz, &matrix_worldtoattenuationz, &ent->matrix);
cullradius = RadiusFromBoundsAndOrigin(clipmins, clipmaxs, rd->origin);
VectorScale(rd->light, (1.0f / 4096.0f), lightcolor);
- if (gl_stencil || visiblevolumes)
+ if (r_shadow_dlightshadows.integer && (gl_stencil || visiblevolumes))
{
if (!visiblevolumes)
R_Shadow_Stage_ShadowVolumes();
if (!visiblevolumes)
{
- if (gl_stencil)
+ if (r_shadow_dlightshadows.integer && gl_stencil)
R_Shadow_Stage_LightWithShadows();
else
R_Shadow_Stage_LightWithoutShadows();
if (ent->model && ent->model->DrawLight)
{
Matrix4x4_Transform(&ent->inversematrix, rd->origin, relativelightorigin);
- Matrix4x4_Transform(&ent->inversematrix, r_origin, relativeeyeorigin);
+ Matrix4x4_Transform(&ent->inversematrix, r_vieworigin, relativeeyeorigin);
Matrix4x4_Concat(&matrix_modeltofilter, &matrix_worldtofilter, &ent->matrix);
Matrix4x4_Concat(&matrix_modeltoattenuationxyz, &matrix_worldtoattenuationxyz, &ent->matrix);
Matrix4x4_Concat(&matrix_modeltoattenuationz, &matrix_worldtoattenuationz, &ent->matrix);
&& !(ent->effects & EF_ADDITIVE) && ent->alpha == 1)
{
Matrix4x4_Transform(&ent->inversematrix, rd->origin, relativelightorigin);
- Matrix4x4_Transform(&ent->inversematrix, r_origin, relativeeyeorigin);
+ Matrix4x4_Transform(&ent->inversematrix, r_vieworigin, relativeeyeorigin);
Matrix4x4_Concat(&matrix_modeltofilter, &matrix_worldtofilter, &ent->matrix);
Matrix4x4_Concat(&matrix_modeltoattenuationxyz, &matrix_worldtoattenuationxyz, &ent->matrix);
Matrix4x4_Concat(&matrix_modeltoattenuationz, &matrix_worldtoattenuationz, &ent->matrix);
}
if (visiblevolumes)
+ {
qglEnable(GL_CULL_FACE);
+ qglDisable(GL_SCISSOR_TEST);
+ }
else
R_Shadow_Stage_End();
- qglDisable(GL_SCISSOR_TEST);
}
static void R_SetFrustum (void)
// degrees assumed a square view (wrong), so I removed it, Quake2 has it
// disabled as well.
- // rotate VPN right by FOV_X/2 degrees
- RotatePointAroundVector( frustum[0].normal, vup, vpn, -(90-r_refdef.fov_x / 2 ) );
- frustum[0].dist = DotProduct (r_origin, frustum[0].normal);
+ // rotate R_VIEWFORWARD right by FOV_X/2 degrees
+ RotatePointAroundVector( frustum[0].normal, r_viewup, r_viewforward, -(90 - r_refdef.fov_x / 2));
+ frustum[0].dist = DotProduct (r_vieworigin, frustum[0].normal);
PlaneClassify(&frustum[0]);
- // rotate VPN left by FOV_X/2 degrees
- RotatePointAroundVector( frustum[1].normal, vup, vpn, 90-r_refdef.fov_x / 2 );
- frustum[1].dist = DotProduct (r_origin, frustum[1].normal);
+ // rotate R_VIEWFORWARD left by FOV_X/2 degrees
+ RotatePointAroundVector( frustum[1].normal, r_viewup, r_viewforward, (90 - r_refdef.fov_x / 2));
+ frustum[1].dist = DotProduct (r_vieworigin, frustum[1].normal);
PlaneClassify(&frustum[1]);
- // rotate VPN up by FOV_X/2 degrees
- RotatePointAroundVector( frustum[2].normal, vright, vpn, 90-r_refdef.fov_y / 2 );
- frustum[2].dist = DotProduct (r_origin, frustum[2].normal);
+ // rotate R_VIEWFORWARD up by FOV_X/2 degrees
+ RotatePointAroundVector( frustum[2].normal, r_viewleft, r_viewforward, -(90 - r_refdef.fov_y / 2));
+ frustum[2].dist = DotProduct (r_vieworigin, frustum[2].normal);
PlaneClassify(&frustum[2]);
- // rotate VPN down by FOV_X/2 degrees
- RotatePointAroundVector( frustum[3].normal, vright, vpn, -( 90 - r_refdef.fov_y / 2 ) );
- frustum[3].dist = DotProduct (r_origin, frustum[3].normal);
+ // rotate R_VIEWFORWARD down by FOV_X/2 degrees
+ RotatePointAroundVector( frustum[3].normal, r_viewleft, r_viewforward, (90 - r_refdef.fov_y / 2));
+ frustum[3].dist = DotProduct (r_vieworigin, frustum[3].normal);
PlaneClassify(&frustum[3]);
}
r_framecount++;
-// build the transformation matrix for the given view angles
- VectorCopy (r_refdef.vieworg, r_origin);
+ // break apart the viewentity matrix into vectors for various purposes
+ Matrix4x4_ToVectors(&r_refdef.viewentitymatrix, r_viewforward, r_viewleft, r_viewup, r_vieworigin);
+ VectorNegate(r_viewleft, r_viewright);
- AngleVectors (r_refdef.viewangles, vpn, vright, vup);
+ GL_SetupView_ViewPort(r_refdef.x, r_refdef.y, r_refdef.width, r_refdef.height);
- R_AnimateLight ();
+ R_AnimateLight();
}
GL_DepthTest(false); // magic
GL_VertexPointer(vertex3f);
GL_Color(r_refdef.viewblend[0], r_refdef.viewblend[1], r_refdef.viewblend[2], r_refdef.viewblend[3]);
- r = 64000;
- vertex3f[0] = r_origin[0] + vpn[0] * 1.5 - vright[0] * r - vup[0] * r;
- vertex3f[1] = r_origin[1] + vpn[1] * 1.5 - vright[1] * r - vup[1] * r;
- vertex3f[2] = r_origin[2] + vpn[2] * 1.5 - vright[2] * r - vup[2] * r;
- vertex3f[3] = r_origin[0] + vpn[0] * 1.5 - vright[0] * r + vup[0] * r * 3;
- vertex3f[4] = r_origin[1] + vpn[1] * 1.5 - vright[1] * r + vup[1] * r * 3;
- vertex3f[5] = r_origin[2] + vpn[2] * 1.5 - vright[2] * r + vup[2] * r * 3;
- vertex3f[6] = r_origin[0] + vpn[0] * 1.5 + vright[0] * r * 3 - vup[0] * r;
- vertex3f[7] = r_origin[1] + vpn[1] * 1.5 + vright[1] * r * 3 - vup[1] * r;
- vertex3f[8] = r_origin[2] + vpn[2] * 1.5 + vright[2] * r * 3 - vup[2] * r;
+ r = 64;
+ vertex3f[0] = r_vieworigin[0] + r_viewforward[0] * 1.5 + r_viewleft[0] * r - r_viewup[0] * r;
+ vertex3f[1] = r_vieworigin[1] + r_viewforward[1] * 1.5 + r_viewleft[1] * r - r_viewup[1] * r;
+ vertex3f[2] = r_vieworigin[2] + r_viewforward[2] * 1.5 + r_viewleft[2] * r - r_viewup[2] * r;
+ vertex3f[3] = r_vieworigin[0] + r_viewforward[0] * 1.5 + r_viewleft[0] * r + r_viewup[0] * r * 3;
+ vertex3f[4] = r_vieworigin[1] + r_viewforward[1] * 1.5 + r_viewleft[1] * r + r_viewup[1] * r * 3;
+ vertex3f[5] = r_vieworigin[2] + r_viewforward[2] * 1.5 + r_viewleft[2] * r + r_viewup[2] * r * 3;
+ vertex3f[6] = r_vieworigin[0] + r_viewforward[0] * 1.5 - r_viewleft[0] * r * 3 - r_viewup[0] * r;
+ vertex3f[7] = r_vieworigin[1] + r_viewforward[1] * 1.5 - r_viewleft[1] * r * 3 - r_viewup[1] * r;
+ vertex3f[8] = r_vieworigin[2] + r_viewforward[2] * 1.5 - r_viewleft[2] * r * 3 - r_viewup[2] * r;
R_Mesh_Draw(3, 1, polygonelements);
}
{
if (!gl_stencil)
{
- Con_Printf("Stencil not enabled, turning off r_shadow_realtime_world, please type vid_stencil 1;vid_bitsperpixel 32;vid_restart and try again\n");
+ Con_Printf("Realtime world lighting requires 32bit color turning off r_shadow_realtime_world, please type vid_bitsperpixel 32;vid_restart and try again\n");
Cvar_SetValueQuick(&r_shadow_realtime_world, 0);
}
}
R_MoveExplosions();
R_TimeReport("mexplosion");
+ qglPolygonOffset(0, 0);
+ qglEnable(GL_POLYGON_OFFSET_FILL);
+
R_Textures_Frame();
R_SetupFrame();
R_SetFrustum();
R_TimeReport("setup");
if (cl.worldmodel && cl.worldmodel->brush.FatPVS)
- cl.worldmodel->brush.FatPVS(cl.worldmodel, r_origin, 2, r_pvsbits, sizeof(r_pvsbits));
+ cl.worldmodel->brush.FatPVS(cl.worldmodel, r_vieworigin, 2, r_pvsbits, sizeof(r_pvsbits));
R_WorldVisibility(world);
R_TimeReport("worldvis");
- R_FarClip_Start(r_origin, vpn, 768.0f);
+ R_FarClip_Start(r_vieworigin, r_viewforward, 768.0f);
R_MarkEntities();
r_farclip = R_FarClip_Finish() + 256.0f;
- R_TimeReport("markentity");
-
- GL_SetupView_ViewPort(r_refdef.x, r_refdef.y, r_refdef.width, r_refdef.height);
- if (r_shadow_realtime_world.integer || gl_stencil)
+ if (gl_stencil && ((r_shadow_realtime_world.integer && r_shadow_worldshadows.integer) || ((r_shadow_realtime_world.integer || r_shadow_realtime_dlight.integer) && r_shadow_dlightshadows.integer)))
GL_SetupView_Mode_PerspectiveInfiniteFarClip(r_refdef.fov_x, r_refdef.fov_y, 1.0f);
else
GL_SetupView_Mode_Perspective(r_refdef.fov_x, r_refdef.fov_y, 1.0f, r_farclip);
- GL_SetupView_Orientation_FromEntity (r_refdef.vieworg, r_refdef.viewangles);
+ GL_SetupView_Orientation_FromEntity(&r_refdef.viewentitymatrix);
+ R_TimeReport("markentity");
+
qglDepthFunc(GL_LEQUAL);
R_Mesh_Start();
R_DrawModels();
R_TimeReport("models");
- if (r_shadows.integer == 1 && !r_shadow_realtime_world.integer)
- {
- R_DrawFakeShadows();
- R_TimeReport("fakeshadow");
- }
-
- if (r_shadow_realtime_world.integer || r_shadow_realtime_dlight.integer)
- {
- R_ShadowVolumeLighting(false);
- R_TimeReport("dynlight");
- }
+ R_ShadowVolumeLighting(false);
+ R_TimeReport("rtlights");
R_DrawLightningBeams();
R_TimeReport("lightning");
R_Mesh_Finish();
R_TimeReport("meshfinish");
+
+ qglPolygonOffset(0, 0);
+ qglDisable(GL_POLYGON_OFFSET_FILL);
}
/*
{
for (i = 0, v = vertex, c = color;i < 8;i++, v += 4, c += 4)
{
- VectorSubtract(v, r_origin, diff);
+ VectorSubtract(v, r_vieworigin, diff);
f2 = exp(fogdensity/DotProduct(diff, diff));
f1 = 1 - f2;
c[0] = c[0] * f1 + fogcolor[0] * f2;
{
memcpy(color4f, nomodelcolor4f, sizeof(float[6*4]));
GL_ColorPointer(color4f);
- VectorSubtract(ent->origin, r_origin, diff);
+ VectorSubtract(ent->origin, r_vieworigin, diff);
f2 = exp(fogdensity/DotProduct(diff, diff));
f1 = 1 - f2;
for (i = 0, c = color4f;i < 6;i++, c += 4)
VectorNormalizeFast (normal);
// calculate 'right' vector for start
- VectorSubtract (r_origin, org1, diff);
+ VectorSubtract (r_vieworigin, org1, diff);
VectorNormalizeFast (diff);
CrossProduct (normal, diff, right1);
// calculate 'right' vector for end
- VectorSubtract (r_origin, org2, diff);
+ VectorSubtract (r_vieworigin, org2, diff);
VectorNormalizeFast (diff);
CrossProduct (normal, diff, right2);
if (fogenabled)
{
- VectorSubtract(origin, r_origin, diff);
+ VectorSubtract(origin, r_vieworigin, diff);
ca *= 1 - exp(fogdensity/DotProduct(diff,diff));
}
projects / xonotic / darkplaces.git / blobdiff