#include "cl_video.h"
#include "jpeg.h"
#include "cl_collision.h"
-
-cvar_t scr_viewsize = {CVAR_SAVE, "viewsize","100"};
-cvar_t scr_fov = {CVAR_SAVE, "fov","90"}; // 1 - 170
-cvar_t scr_conspeed = {CVAR_SAVE, "scr_conspeed","900"}; // LordHavoc: quake used 300
-cvar_t scr_conalpha = {CVAR_SAVE, "scr_conalpha", "1"};
-cvar_t scr_conbrightness = {CVAR_SAVE, "scr_conbrightness", "0.2"};
-cvar_t scr_conforcewhiledisconnected = {CVAR_SAVE, "scr_conforcewhiledisconnected", "1"};
-cvar_t scr_centertime = {0, "scr_centertime","2"};
-cvar_t scr_showram = {CVAR_SAVE, "showram","1"};
-cvar_t scr_showturtle = {CVAR_SAVE, "showturtle","0"};
-cvar_t scr_showpause = {CVAR_SAVE, "showpause","1"};
-cvar_t scr_showbrand = {0, "showbrand","0"};
-cvar_t scr_printspeed = {0, "scr_printspeed","8"};
-cvar_t vid_conwidth = {CVAR_SAVE, "vid_conwidth", "640"};
-cvar_t vid_conheight = {CVAR_SAVE, "vid_conheight", "480"};
-cvar_t vid_pixelaspect = {CVAR_SAVE, "vid_pixelaspect", "1"};
-cvar_t scr_screenshot_jpeg = {CVAR_SAVE, "scr_screenshot_jpeg","1"};
-cvar_t scr_screenshot_jpeg_quality = {CVAR_SAVE, "scr_screenshot_jpeg_quality","0.9"};
-cvar_t scr_screenshot_gamma = {CVAR_SAVE, "scr_screenshot_gamma","2.2"};
+#include "csprogs.h"
+
+cvar_t scr_viewsize = {CVAR_SAVE, "viewsize","100", "how large the view should be, 110 disables inventory bar, 120 disables status bar"};
+cvar_t scr_fov = {CVAR_SAVE, "fov","90", "field of vision, 1-170 degrees, default 90, some players use 110-130"}; // 1 - 170
+cvar_t scr_conspeed = {CVAR_SAVE, "scr_conspeed","900", "speed of console open/close"}; // LordHavoc: quake used 300
+cvar_t scr_conalpha = {CVAR_SAVE, "scr_conalpha", "1", "opacity of console background"};
+cvar_t scr_conbrightness = {CVAR_SAVE, "scr_conbrightness", "0.2", "brightness of console background (0 = black, 1 = image)"};
+cvar_t scr_conforcewhiledisconnected = {CVAR_SAVE, "scr_conforcewhiledisconnected", "1", "forces fullscreen console while disconnected"};
+cvar_t scr_centertime = {0, "scr_centertime","2", "how long centerprint messages show"};
+cvar_t scr_showram = {CVAR_SAVE, "showram","1", "show ram icon if low on surface cache memory (not used)"};
+cvar_t scr_showturtle = {CVAR_SAVE, "showturtle","0", "show turtle icon when framerate is too low (not used)"};
+cvar_t scr_showpause = {CVAR_SAVE, "showpause","1" "show pause icon when game is paused"};
+cvar_t scr_showbrand = {0, "showbrand","0", "shows gfx/brand.tga in a corner of the screen (different values select different positions, including centered)"};
+cvar_t scr_printspeed = {0, "scr_printspeed","8", "speed of intermission printing (episode end texts)"};
+cvar_t vid_conwidth = {CVAR_SAVE, "vid_conwidth", "640", "virtual width of 2D graphics system"};
+cvar_t vid_conheight = {CVAR_SAVE, "vid_conheight", "480", "virtual height of 2D graphics system"};
+cvar_t vid_pixelheight = {CVAR_SAVE, "vid_pixelheight", "1", "adjusts vertical field of vision to account for non-square pixels (1280x1024 on a CRT monitor for example)"};
+cvar_t scr_screenshot_jpeg = {CVAR_SAVE, "scr_screenshot_jpeg","1", "save jpeg instead of targa"};
+cvar_t scr_screenshot_jpeg_quality = {CVAR_SAVE, "scr_screenshot_jpeg_quality","0.9", "image quality of saved jpeg"};
+cvar_t scr_screenshot_gamma = {CVAR_SAVE, "scr_screenshot_gamma","2.2", "gamma correction on saved screenshots and videos, 1.0 saves unmodified images"};
// scr_screenshot_name is defined in fs.c
-cvar_t cl_capturevideo = {0, "cl_capturevideo", "0"};
-cvar_t cl_capturevideo_sound = {0, "cl_capturevideo_sound", "0"};
-cvar_t cl_capturevideo_fps = {0, "cl_capturevideo_fps", "30"};
-cvar_t cl_capturevideo_rawrgb = {0, "cl_capturevideo_rawrgb", "0"};
-cvar_t cl_capturevideo_rawyv12 = {0, "cl_capturevideo_rawyv12", "0"};
-cvar_t r_textshadow = {0, "r_textshadow", "0"};
-cvar_t r_letterbox = {0, "r_letterbox", "0"};
+cvar_t cl_capturevideo = {0, "cl_capturevideo", "0", "enables saving of video to a file or files (default is .tga files, if scr_screenshot_jpeg is on it saves .jpg files (VERY SLOW), if any rawrgb or rawyv12 are on it saves those formats instead, note that scr_screenshot_gamma affects the brightness of the output)"};
+cvar_t cl_capturevideo_sound = {0, "cl_capturevideo_sound", "0", "enables saving of sound to a .wav file (warning: this requires exact sync, if your hard drive can't keep up it will abort, if your graphics can't keep up it will save duplicate frames to maintain sound sync)"};
+cvar_t cl_capturevideo_fps = {0, "cl_capturevideo_fps", "30", "how many frames per second to save (29.97 for NTSC, 30 for typical PC video, 15 can be useful)"};
+cvar_t cl_capturevideo_rawrgb = {0, "cl_capturevideo_rawrgb", "0", "saves a single .rgb video file containing raw RGB images (you'll need special processing tools to encode this to something more useful)"};
+cvar_t cl_capturevideo_rawyv12 = {0, "cl_capturevideo_rawyv12", "0", "saves a single .yv12 video file containing raw YV12 (luma plane, then half resolution chroma planes, first chroma blue then chroma red, this is the format used internally by many encoders, some tools can read it directly)"};
+cvar_t r_textshadow = {0, "r_textshadow", "0" "draws a shadow on all text to improve readability"};
+cvar_t r_letterbox = {0, "r_letterbox", "0", "reduces vertical height of view to simulate a letterboxed movie effect (can be used by mods for cutscenes)"};
int jpeg_supported = false;
===============================================================================
*/
-char scr_centerstring[1024];
+char scr_centerstring[MAX_INPUTLINE];
float scr_centertime_start; // for slow victory printing
float scr_centertime_off;
int scr_center_lines;
scr_erase_center = 0;
start = scr_centerstring;
+ if (remaining < 1)
+ return;
+
if (scr_center_lines <= 4)
y = vid_conheight.integer*0.35;
else
if (count < 3)
return;
- DrawQ_Pic (0, 0, "gfx/turtle", 0, 0, 1, 1, 1, 1, 0);
+ DrawQ_Pic (0, 0, Draw_CachePic("gfx/turtle", false), 0, 0, 1, 1, 1, 1, 0);
}
/*
if (cls.demoplayback)
return;
- DrawQ_Pic (64, 0, "gfx/net", 0, 0, 1, 1, 1, 1, 0);
+ DrawQ_Pic (64, 0, Draw_CachePic("gfx/net", false), 0, 0, 1, 1, 1, 1, 0);
}
/*
return;
pic = Draw_CachePic ("gfx/pause", true);
- DrawQ_Pic ((vid_conwidth.integer - pic->width)/2, (vid_conheight.integer - pic->height)/2, "gfx/pause", 0, 0, 1, 1, 1, 1, 0);
+ DrawQ_Pic ((vid_conwidth.integer - pic->width)/2, (vid_conheight.integer - pic->height)/2, pic, 0, 0, 1, 1, 1, 1, 0);
}
/*
return;
}
- DrawQ_Pic (x, y, "gfx/brand", 0, 0, 1, 1, 1, 1, 0);
+ DrawQ_Pic (x, y, pic, 0, 0, 1, 1, 1, 1, 0);
+}
+
+/*
+==============
+SCR_DrawDownload
+==============
+*/
+static void SCR_DrawDownload(void)
+{
+ int len;
+ float x, y;
+ float size = 8;
+ char temp[256];
+ if (!cls.qw_downloadname[0])
+ return;
+ dpsnprintf(temp, sizeof(temp), "Downloading %s ... %3i%%\n", cls.qw_downloadname, cls.qw_downloadpercent);
+ len = (int)strlen(temp);
+ x = (vid_conwidth.integer - len*size) / 2;
+ y = vid_conheight.integer - size;
+ DrawQ_Pic(0, y, NULL, vid_conwidth.integer, size, 0, 0, 0, 0.5, 0);
+ DrawQ_String(x, y, temp, len, size, size, 1, 1, 1, 1, 0);
}
//=============================================================================
*/
void SCR_BeginLoadingPlaque (void)
{
+ // save console log up to this point to log_file if it was set by configs
+ Log_Start();
+
Host_StartVideo();
S_StopAllSounds();
SCR_UpdateLoadingScreen();
int length;
int t;
- if (!r_timereport_active || r_showtrispass)
+ if (r_speeds.integer < 2 || !r_timereport_active || r_showtrispass)
return;
qglFinish();
r_timereport_current = Sys_DoubleTime();
t = (int) ((r_timereport_current - r_timereport_temp) * 1000000.0);
- dpsnprintf(tempbuf, sizeof(tempbuf), "%8i %s", t, desc);
+ dpsnprintf(tempbuf, sizeof(tempbuf), "%8i %-11s", t, desc);
length = (int)strlen(tempbuf);
- while (length < 20)
- tempbuf[length++] = ' ';
- tempbuf[length] = 0;
if (speedstringcount + length > (vid_conwidth.integer / 8))
{
strlcat(r_speeds_string, "\n", sizeof(r_speeds_string));
}
}
-void R_TimeReport_Start(void)
+void R_TimeReport_Frame(void)
{
- r_timereport_active = r_speeds.integer && cls.signon == SIGNONS && cls.state == ca_connected;
- r_speeds_string[0] = 0;
- if (r_timereport_active)
- {
- speedstringcount = 0;
- sprintf(r_speeds_string + strlen(r_speeds_string), "org:'%+8.2f %+8.2f %+8.2f' dir:'%+2.3f %+2.3f %+2.3f'\n", r_vieworigin[0], r_vieworigin[1], r_vieworigin[2], r_viewforward[0], r_viewforward[1], r_viewforward[2]);
- sprintf(r_speeds_string + strlen(r_speeds_string), "world:%6i faces%6i nodes%6i leafs%6i dlitwalls\n", c_faces, c_nodes, c_leafs, c_light_polys);
- sprintf(r_speeds_string + strlen(r_speeds_string), "%5i models%5i bmodels%5i sprites%6i particles%4i dlights\n", c_models, c_bmodels, c_sprites, c_particles, c_dlights);
- sprintf(r_speeds_string + strlen(r_speeds_string), "%6i modeltris%6i meshs%6i meshtris\n", c_alias_polys, c_meshs, c_meshelements / 3);
- sprintf(r_speeds_string + strlen(r_speeds_string), "bloom %s: %i copies (%i pixels) %i draws (%i pixels)\n", c_bloom ? "active" : "inactive", c_bloomcopies, c_bloomcopypixels, c_bloomdraws, c_bloomdrawpixels);
- sprintf(r_speeds_string + strlen(r_speeds_string), "realtime lighting:%4i lights%4i clears%4i scissored\n", c_rt_lights, c_rt_clears, c_rt_scissored);
- sprintf(r_speeds_string + strlen(r_speeds_string), "dynamic: %6i shadowmeshes%6i shadowtris%6i lightmeshes%6i lighttris\n", c_rt_shadowmeshes, c_rt_shadowtris, c_rt_lightmeshes, c_rt_lighttris);
- sprintf(r_speeds_string + strlen(r_speeds_string), "precomputed: %6i shadowmeshes%6i shadowtris\n", c_rtcached_shadowmeshes, c_rtcached_shadowtris);
-
- c_alias_polys = 0;
- c_light_polys = 0;
- c_faces = 0;
- c_nodes = 0;
- c_leafs = 0;
- c_models = 0;
- c_bmodels = 0;
- c_sprites = 0;
- c_particles = 0;
- c_dlights = 0;
- c_meshs = 0;
- c_meshelements = 0;
- c_rt_lights = 0;
- c_rt_clears = 0;
- c_rt_scissored = 0;
- c_rt_shadowmeshes = 0;
- c_rt_shadowtris = 0;
- c_rt_lightmeshes = 0;
- c_rt_lighttris = 0;
- c_rtcached_shadowmeshes = 0;
- c_rtcached_shadowtris = 0;
- c_bloom = 0;
- c_bloomcopies = 0;
- c_bloomcopypixels = 0;
- c_bloomdraws = 0;
- c_bloomdrawpixels = 0;
-
- r_timereport_start = Sys_DoubleTime();
- }
-}
+ int i, j, lines, y;
-void R_TimeReport_End(void)
-{
- r_timereport_current = r_timereport_start;
- R_TimeReport("total");
-
- if (r_timereport_active)
+ if (r_speeds_string[0])
{
- int i, j, lines, y;
+ if (r_timereport_active)
+ R_TimeReport("total");
+
+ r_timereport_current = r_timereport_start;
+ if (r_speeds_string[strlen(r_speeds_string)-1] == '\n')
+ r_speeds_string[strlen(r_speeds_string)-1] = 0;
lines = 1;
for (i = 0;r_speeds_string[i];i++)
if (r_speeds_string[i] == '\n')
lines++;
y = vid_conheight.integer - sb_lines - lines * 8;
i = j = 0;
- DrawQ_Fill(0, y, vid_conwidth.integer, lines * 8, 0, 0, 0, 0.5, 0);
+ DrawQ_Pic(0, y, NULL, vid_conwidth.integer, lines * 8, 0, 0, 0, 0.5, 0);
while (r_speeds_string[i])
{
j = i;
i++;
y += 8;
}
+ r_speeds_string[0] = 0;
+ r_timereport_active = false;
+ }
+ if (r_speeds.integer && cls.signon == SIGNONS && cls.state == ca_connected)
+ {
+ speedstringcount = 0;
+ r_speeds_string[0] = 0;
+ r_timereport_active = false;
+ sprintf(r_speeds_string + strlen(r_speeds_string), "org:'%+8.2f %+8.2f %+8.2f' dir:'%+2.3f %+2.3f %+2.3f'\n", r_vieworigin[0], r_vieworigin[1], r_vieworigin[2], r_viewforward[0], r_viewforward[1], r_viewforward[2]);
+ sprintf(r_speeds_string + strlen(r_speeds_string), "%5i entities%6i surfaces%6i triangles%5i leafs%5i portals%6i particles\n", renderstats.entities, renderstats.entities_surfaces, renderstats.entities_triangles, renderstats.world_leafs, renderstats.world_portals, renderstats.particles);
+ sprintf(r_speeds_string + strlen(r_speeds_string), "%4i lights%4i clears%4i scissored%7i light%7i shadow%7i dynamic\n", renderstats.lights, renderstats.lights_clears, renderstats.lights_scissored, renderstats.lights_lighttriangles, renderstats.lights_shadowtriangles, renderstats.lights_dynamicshadowtriangles);
+ if (renderstats.bloom)
+ sprintf(r_speeds_string + strlen(r_speeds_string), "rendered%6i meshes%8i triangles bloompixels%8i copied%8i drawn\n", renderstats.meshes, renderstats.meshes_elements / 3, renderstats.bloom_copypixels, renderstats.bloom_drawpixels);
+ else
+ sprintf(r_speeds_string + strlen(r_speeds_string), "rendered%6i meshes%8i triangles\n", renderstats.meshes, renderstats.meshes_elements / 3);
+
+ memset(&renderstats, 0, sizeof(renderstats));
+
+ if (r_speeds.integer >= 2)
+ {
+ r_timereport_active = true;
+ r_timereport_start = Sys_DoubleTime();
+ }
}
}
Cvar_RegisterVariable (&scr_printspeed);
Cvar_RegisterVariable (&vid_conwidth);
Cvar_RegisterVariable (&vid_conheight);
- Cvar_RegisterVariable (&vid_pixelaspect);
+ Cvar_RegisterVariable (&vid_pixelheight);
Cvar_RegisterVariable (&scr_screenshot_jpeg);
Cvar_RegisterVariable (&scr_screenshot_jpeg_quality);
Cvar_RegisterVariable (&scr_screenshot_gamma);
Cvar_RegisterVariable (&r_textshadow);
Cvar_RegisterVariable (&r_letterbox);
- Cmd_AddCommand ("sizeup",SCR_SizeUp_f);
- Cmd_AddCommand ("sizedown",SCR_SizeDown_f);
- Cmd_AddCommand ("screenshot",SCR_ScreenShot_f);
- Cmd_AddCommand ("envmap", R_Envmap_f);
+ Cmd_AddCommand ("sizeup",SCR_SizeUp_f, "increase view size (increases viewsize cvar)");
+ Cmd_AddCommand ("sizedown",SCR_SizeDown_f, "decrease view size (decreases viewsize cvar)");
+ Cmd_AddCommand ("screenshot",SCR_ScreenShot_f, "takes a screenshot of the next rendered frame");
+ Cmd_AddCommand ("envmap", R_Envmap_f, "render a cubemap (skybox) of the current scene");
scr_initialized = true;
}
}
static int picelements[6] = {0, 1, 2, 0, 2, 3};
-void DrawQ_Pic(float x, float y, const char *picname, float width, float height, float red, float green, float blue, float alpha, int flags)
+void DrawQ_Pic(float x, float y, cachepic_t *pic, float width, float height, float red, float green, float blue, float alpha, int flags)
{
- DrawQ_SuperPic(x,y,picname,width,height,0,0,red,green,blue,alpha,1,0,red,green,blue,alpha,0,1,red,green,blue,alpha,1,1,red,green,blue,alpha,flags);
+ DrawQ_SuperPic(x,y,pic,width,height,0,0,red,green,blue,alpha,1,0,red,green,blue,alpha,0,1,red,green,blue,alpha,1,1,red,green,blue,alpha,flags);
}
void DrawQ_String_Real(float x, float y, const char *string, int maxlen, float scalex, float scaley, float red, float green, float blue, float alpha, int flags)
green = bound(0, green, 1);
blue = bound(0, blue, 1);
alpha = bound(0, alpha, 1);
- dq = (void *)(r_refdef.drawqueue + r_refdef.drawqueuesize);
+ dq = (drawqueue_t *)(r_refdef.drawqueue + r_refdef.drawqueuesize);
dq->size = size;
dq->command = DRAWQUEUE_STRING;
dq->flags = flags;
DrawQ_String_Real(x,y,string,maxlen,scalex,scaley,red,green,blue,alpha,flags);
}
-
-
-void DrawQ_Fill (float x, float y, float w, float h, float red, float green, float blue, float alpha, int flags)
-{
- DrawQ_SuperPic(x,y,NULL,w,h,0,0,red,green,blue,alpha,1,0,red,green,blue,alpha,0,1,red,green,blue,alpha,1,1,red,green,blue,alpha,flags);
-}
-
-void DrawQ_SuperPic(float x, float y, const char *picname, float width, float height, float s1, float t1, float r1, float g1, float b1, float a1, float s2, float t2, float r2, float g2, float b2, float a2, float s3, float t3, float r3, float g3, float b3, float a3, float s4, float t4, float r4, float g4, float b4, float a4, int flags)
+void DrawQ_SuperPic(float x, float y, cachepic_t *pic, float width, float height, float s1, float t1, float r1, float g1, float b1, float a1, float s2, float t2, float r2, float g2, float b2, float a2, float s3, float t3, float r3, float g3, float b3, float a3, float s4, float t4, float r4, float g4, float b4, float a4, int flags)
{
float floats[36];
- cachepic_t *pic;
drawqueuemesh_t mesh;
memset(&mesh, 0, sizeof(mesh));
- if (picname && picname[0])
+ if (pic)
{
- pic = Draw_CachePic(picname, false);
if (width == 0)
width = pic->width;
if (height == 0)
size += sizeof(float[4]) * mesh->num_vertices;
if (r_refdef.drawqueuesize + size > r_refdef.maxdrawqueuesize)
return;
- dq = (void *)(r_refdef.drawqueue + r_refdef.drawqueuesize);
+ dq = (drawqueue_t *)(r_refdef.drawqueue + r_refdef.drawqueuesize);
dq->size = size;
dq->command = DRAWQUEUE_MESH;
dq->flags = flags;
dq->scalex = 0;
dq->scaley = 0;
p = (void *)(dq + 1);
- m = p;p = (qbyte*)p + sizeof(drawqueuemesh_t);
+ m = (drawqueuemesh_t *)p;p = (unsigned char*)p + sizeof(drawqueuemesh_t);
+ m->num_triangles = mesh->num_triangles;
+ m->num_vertices = mesh->num_vertices;
+ m->texture = mesh->texture;
+ m->data_element3i = (int *)p;memcpy(m->data_element3i , mesh->data_element3i , m->num_triangles * sizeof(int[3]));p = (unsigned char*)p + m->num_triangles * sizeof(int[3]);
+ m->data_vertex3f = (float *)p;memcpy(m->data_vertex3f , mesh->data_vertex3f , m->num_vertices * sizeof(float[3]));p = (unsigned char*)p + m->num_vertices * sizeof(float[3]);
+ m->data_texcoord2f = (float *)p;memcpy(m->data_texcoord2f, mesh->data_texcoord2f, m->num_vertices * sizeof(float[2]));p = (unsigned char*)p + m->num_vertices * sizeof(float[2]);
+ m->data_color4f = (float *)p;memcpy(m->data_color4f , mesh->data_color4f , m->num_vertices * sizeof(float[4]));p = (unsigned char*)p + m->num_vertices * sizeof(float[4]);
+ r_refdef.drawqueuesize += dq->size;
+}
+
+void DrawQ_LineLoop (drawqueuemesh_t *mesh, int flags)
+{
+ int size;
+ void *p;
+ drawqueue_t *dq;
+ drawqueuemesh_t *m;
+ size = sizeof(*dq);
+ size += sizeof(drawqueuemesh_t);
+ size += sizeof(int[3]) * mesh->num_triangles;
+ size += sizeof(float[3]) * mesh->num_vertices;
+ size += sizeof(float[2]) * mesh->num_vertices;
+ size += sizeof(float[4]) * mesh->num_vertices;
+ if (r_refdef.drawqueuesize + size > r_refdef.maxdrawqueuesize)
+ return;
+ dq = (void *)(r_refdef.drawqueue + r_refdef.drawqueuesize);
+ dq->size = size;
+ dq->command = DRAWQUEUE_LINES;
+ dq->flags = flags;
+ dq->color = 0;
+ dq->x = 0;
+ dq->y = 0;
+ dq->scalex = 0;
+ dq->scaley = 0;
+ p = (void *)(dq + 1);
+ m = p;p = (unsigned char*)p + sizeof(drawqueuemesh_t);
m->num_triangles = mesh->num_triangles;
m->num_vertices = mesh->num_vertices;
m->texture = mesh->texture;
- m->data_element3i = p;memcpy(m->data_element3i , mesh->data_element3i , m->num_triangles * sizeof(int[3]));p = (qbyte*)p + m->num_triangles * sizeof(int[3]);
- m->data_vertex3f = p;memcpy(m->data_vertex3f , mesh->data_vertex3f , m->num_vertices * sizeof(float[3]));p = (qbyte*)p + m->num_vertices * sizeof(float[3]);
- m->data_texcoord2f = p;memcpy(m->data_texcoord2f, mesh->data_texcoord2f, m->num_vertices * sizeof(float[2]));p = (qbyte*)p + m->num_vertices * sizeof(float[2]);
- m->data_color4f = p;memcpy(m->data_color4f , mesh->data_color4f , m->num_vertices * sizeof(float[4]));p = (qbyte*)p + m->num_vertices * sizeof(float[4]);
+ m->data_element3i = p;memcpy(m->data_element3i , mesh->data_element3i , m->num_triangles * sizeof(int[3]));p = (unsigned char*)p + m->num_triangles * sizeof(int[3]);
+ m->data_vertex3f = p;memcpy(m->data_vertex3f , mesh->data_vertex3f , m->num_vertices * sizeof(float[3]));p = (unsigned char*)p + m->num_vertices * sizeof(float[3]);
+ m->data_texcoord2f = p;memcpy(m->data_texcoord2f, mesh->data_texcoord2f, m->num_vertices * sizeof(float[2]));p = (unsigned char*)p + m->num_vertices * sizeof(float[2]);
+ m->data_color4f = p;memcpy(m->data_color4f , mesh->data_color4f , m->num_vertices * sizeof(float[4]));p = (unsigned char*)p + m->num_vertices * sizeof(float[4]);
+ r_refdef.drawqueuesize += dq->size;
+}
+
+//LordHavoc: FIXME: this is nasty!
+void DrawQ_LineWidth (float width)
+{
+ drawqueue_t *dq;
+ static int linewidth = 1;
+ if(width == linewidth)
+ return;
+ linewidth = width;
+ if(r_refdef.drawqueuesize + (int)sizeof(*dq) > r_refdef.maxdrawqueuesize)
+ {
+ Con_DPrint("DrawQueue full !\n");
+ return;
+ }
+ dq = (void*) (r_refdef.drawqueue + r_refdef.drawqueuesize);
+ dq->size = sizeof(*dq);
+ dq->command = DRAWQUEUE_LINEWIDTH;
+ dq->x = width;
+
+ r_refdef.drawqueuesize += dq->size;
+}
+
+//[515]: this is old, delete
+void DrawQ_Line (float width, float x1, float y1, float x2, float y2, float r, float g, float b, float alpha, int flags)
+{
+ drawqueue_t *dq;
+ if(width > 0)
+ DrawQ_LineWidth(width);
+ if(r_refdef.drawqueuesize + (int)sizeof(*dq) > r_refdef.maxdrawqueuesize)
+ {
+ Con_DPrint("DrawQueue full !\n");
+ return;
+ }
+ dq = (void*) (r_refdef.drawqueue + r_refdef.drawqueuesize);
+ dq->size = sizeof(*dq);
+ dq->command = DRAWQUEUE_LINES;
+ dq->x = x1;
+ dq->y = y1;
+ dq->scalex = x2;
+ dq->scaley = y2;
+ dq->flags = flags;
+ dq->color = ((unsigned int) (r * 255.0f) << 24) | ((unsigned int) (g * 255.0f) << 16) | ((unsigned int) (b * 255.0f) << 8) | ((unsigned int) (alpha * 255.0f));
+
r_refdef.drawqueuesize += dq->size;
}
Con_DPrint("DrawQueue full !\n");
return;
}
- dq = (void*) (r_refdef.drawqueue + r_refdef.drawqueuesize);
+ dq = (drawqueue_t *) (r_refdef.drawqueue + r_refdef.drawqueuesize);
dq->size = sizeof(*dq);
dq->command = DRAWQUEUE_SETCLIP;
dq->x = x;
Con_DPrint("DrawQueue full !\n");
return;
}
- dq = (void*) (r_refdef.drawqueue + r_refdef.drawqueuesize);
+ dq = (drawqueue_t *) (r_refdef.drawqueue + r_refdef.drawqueuesize);
dq->size = sizeof(*dq);
dq->command = DRAWQUEUE_RESETCLIP;
dq->x = 0;
static char oldname[MAX_QPATH];
char base[MAX_QPATH];
char filename[MAX_QPATH];
- qbyte *buffer1;
- qbyte *buffer2;
- qbyte *buffer3;
+ unsigned char *buffer1;
+ unsigned char *buffer2;
+ unsigned char *buffer3;
qboolean jpeg = (scr_screenshot_jpeg.integer != 0);
sprintf (base, "screenshots/%s", scr_screenshot_name.string);
sprintf(filename, "%s%06d.%s", base, shotnumber, jpeg ? "jpg" : "tga");
- buffer1 = Mem_Alloc(tempmempool, vid.width * vid.height * 3);
- buffer2 = Mem_Alloc(tempmempool, vid.width * vid.height * 3);
- buffer3 = Mem_Alloc(tempmempool, vid.width * vid.height * 3 + 18);
+ buffer1 = (unsigned char *)Mem_Alloc(tempmempool, vid.width * vid.height * 3);
+ buffer2 = (unsigned char *)Mem_Alloc(tempmempool, vid.width * vid.height * 3);
+ buffer3 = (unsigned char *)Mem_Alloc(tempmempool, vid.width * vid.height * 3 + 18);
if (SCR_ScreenShot (filename, buffer1, buffer2, buffer3, 0, 0, vid.width, vid.height, false, false, false, jpeg, true))
Con_Printf("Wrote %s\n", filename);
shotnumber++;
}
-typedef enum capturevideoformat_e
-{
- CAPTUREVIDEOFORMAT_TARGA,
- CAPTUREVIDEOFORMAT_JPEG,
- CAPTUREVIDEOFORMAT_RAWRGB,
- CAPTUREVIDEOFORMAT_RAWYV12
-}
-capturevideoformat_t;
-
-qboolean cl_capturevideo_active = false;
-capturevideoformat_t cl_capturevideo_format;
-static double cl_capturevideo_starttime = 0;
-double cl_capturevideo_framerate = 0;
-static int cl_capturevideo_soundrate = 0;
-static int cl_capturevideo_frame = 0;
-static qbyte *cl_capturevideo_buffer = NULL;
-static qfile_t *cl_capturevideo_videofile = NULL;
-qfile_t *cl_capturevideo_soundfile = NULL;
-static short cl_capturevideo_rgbtoyuvscaletable[3][3][256];
-static unsigned char cl_capturevideo_yuvnormalizetable[3][256];
-//static unsigned char cl_capturevideo_rgbgammatable[3][256];
-
void SCR_CaptureVideo_BeginVideo(void)
{
double gamma, g;
unsigned int i;
- qbyte out[44];
- if (cl_capturevideo_active)
+ unsigned char out[44];
+ if (cls.capturevideo_active)
return;
// soundrate is figured out on the first SoundFrame
- cl_capturevideo_active = true;
- cl_capturevideo_starttime = Sys_DoubleTime();
- cl_capturevideo_framerate = bound(1, cl_capturevideo_fps.value, 1000);
- cl_capturevideo_soundrate = 0;
- cl_capturevideo_frame = 0;
- cl_capturevideo_buffer = Mem_Alloc(tempmempool, vid.width * vid.height * (3+3+3) + 18);
+ cls.capturevideo_active = true;
+ cls.capturevideo_starttime = Sys_DoubleTime();
+ cls.capturevideo_framerate = bound(1, cl_capturevideo_fps.value, 1000);
+ cls.capturevideo_soundrate = 0;
+ cls.capturevideo_frame = 0;
+ cls.capturevideo_buffer = (unsigned char *)Mem_Alloc(tempmempool, vid.width * vid.height * (3+3+3) + 18);
gamma = 1.0/scr_screenshot_gamma.value;
/*
for (i = 0;i < 256;i++)
{
unsigned char j = (unsigned char)bound(0, 255*pow(i/255.0, gamma), 255);
- cl_capturevideo_rgbgammatable[0][i] = j;
- cl_capturevideo_rgbgammatable[1][i] = j;
- cl_capturevideo_rgbgammatable[2][i] = j;
+ cls.capturevideo_rgbgammatable[0][i] = j;
+ cls.capturevideo_rgbgammatable[1][i] = j;
+ cls.capturevideo_rgbgammatable[2][i] = j;
}
*/
/*
{
g = 255*pow(i/255.0, gamma);
// Y weights from RGB
- cl_capturevideo_rgbtoyuvscaletable[0][0][i] = (short)(g * 0.299);
- cl_capturevideo_rgbtoyuvscaletable[0][1][i] = (short)(g * 0.587);
- cl_capturevideo_rgbtoyuvscaletable[0][2][i] = (short)(g * 0.114);
+ cls.capturevideo_rgbtoyuvscaletable[0][0][i] = (short)(g * 0.299);
+ cls.capturevideo_rgbtoyuvscaletable[0][1][i] = (short)(g * 0.587);
+ cls.capturevideo_rgbtoyuvscaletable[0][2][i] = (short)(g * 0.114);
// Cb weights from RGB
- cl_capturevideo_rgbtoyuvscaletable[1][0][i] = (short)(g * -0.169);
- cl_capturevideo_rgbtoyuvscaletable[1][1][i] = (short)(g * -0.332);
- cl_capturevideo_rgbtoyuvscaletable[1][2][i] = (short)(g * 0.500);
+ cls.capturevideo_rgbtoyuvscaletable[1][0][i] = (short)(g * -0.169);
+ cls.capturevideo_rgbtoyuvscaletable[1][1][i] = (short)(g * -0.332);
+ cls.capturevideo_rgbtoyuvscaletable[1][2][i] = (short)(g * 0.500);
// Cr weights from RGB
- cl_capturevideo_rgbtoyuvscaletable[2][0][i] = (short)(g * 0.500);
- cl_capturevideo_rgbtoyuvscaletable[2][1][i] = (short)(g * -0.419);
- cl_capturevideo_rgbtoyuvscaletable[2][2][i] = (short)(g * -0.0813);
+ cls.capturevideo_rgbtoyuvscaletable[2][0][i] = (short)(g * 0.500);
+ cls.capturevideo_rgbtoyuvscaletable[2][1][i] = (short)(g * -0.419);
+ cls.capturevideo_rgbtoyuvscaletable[2][2][i] = (short)(g * -0.0813);
// range reduction of YCbCr to valid signal range
- cl_capturevideo_yuvnormalizetable[0][i] = 16 + i * (236-16) / 256;
- cl_capturevideo_yuvnormalizetable[1][i] = 16 + i * (240-16) / 256;
- cl_capturevideo_yuvnormalizetable[2][i] = 16 + i * (240-16) / 256;
+ cls.capturevideo_yuvnormalizetable[0][i] = 16 + i * (236-16) / 256;
+ cls.capturevideo_yuvnormalizetable[1][i] = 16 + i * (240-16) / 256;
+ cls.capturevideo_yuvnormalizetable[2][i] = 16 + i * (240-16) / 256;
}
if (cl_capturevideo_rawrgb.integer)
{
- cl_capturevideo_format = CAPTUREVIDEOFORMAT_RAWRGB;
- cl_capturevideo_videofile = FS_Open ("video/dpvideo.rgb", "wb", false, true);
+ cls.capturevideo_format = CAPTUREVIDEOFORMAT_RAWRGB;
+ cls.capturevideo_videofile = FS_Open ("video/dpvideo.rgb", "wb", false, true);
}
else if (cl_capturevideo_rawyv12.integer)
{
- cl_capturevideo_format = CAPTUREVIDEOFORMAT_RAWYV12;
- cl_capturevideo_videofile = FS_Open ("video/dpvideo.yv12", "wb", false, true);
+ cls.capturevideo_format = CAPTUREVIDEOFORMAT_RAWYV12;
+ cls.capturevideo_videofile = FS_Open ("video/dpvideo.yv12", "wb", false, true);
}
else if (scr_screenshot_jpeg.integer)
{
- cl_capturevideo_format = CAPTUREVIDEOFORMAT_JPEG;
- cl_capturevideo_videofile = NULL;
+ cls.capturevideo_format = CAPTUREVIDEOFORMAT_JPEG;
+ cls.capturevideo_videofile = NULL;
}
else
{
- cl_capturevideo_format = CAPTUREVIDEOFORMAT_TARGA;
- cl_capturevideo_videofile = NULL;
+ cls.capturevideo_format = CAPTUREVIDEOFORMAT_TARGA;
+ cls.capturevideo_videofile = NULL;
}
if (cl_capturevideo_sound.integer)
{
- cl_capturevideo_soundfile = FS_Open ("video/dpvideo.wav", "wb", false, true);
+ cls.capturevideo_soundfile = FS_Open ("video/dpvideo.wav", "wb", false, true);
// wave header will be filled out when video ends
memset(out, 0, 44);
- FS_Write (cl_capturevideo_soundfile, out, 44);
+ FS_Write (cls.capturevideo_soundfile, out, 44);
}
else
- cl_capturevideo_soundfile = NULL;
+ cls.capturevideo_soundfile = NULL;
}
void SCR_CaptureVideo_EndVideo(void)
{
int i, n;
- qbyte out[44];
- if (!cl_capturevideo_active)
+ unsigned char out[44];
+ if (!cls.capturevideo_active)
return;
- cl_capturevideo_active = false;
+ cls.capturevideo_active = false;
- if (cl_capturevideo_videofile)
+ if (cls.capturevideo_videofile)
{
- FS_Close(cl_capturevideo_videofile);
- cl_capturevideo_videofile = NULL;
+ FS_Close(cls.capturevideo_videofile);
+ cls.capturevideo_videofile = NULL;
}
// finish the wave file
- if (cl_capturevideo_soundfile)
+ if (cls.capturevideo_soundfile)
{
- i = (int)FS_Tell (cl_capturevideo_soundfile);
+ i = (int)FS_Tell (cls.capturevideo_soundfile);
//"RIFF", (int) unknown (chunk size), "WAVE",
//"fmt ", (int) 16 (chunk size), (short) format 1 (uncompressed PCM), (short) 2 channels, (int) unknown rate, (int) unknown bytes per second, (short) 4 bytes per sample (channels * bytes per channel), (short) 16 bits per channel
//"data", (int) unknown (chunk size)
out[6] = (n >> 16) & 0xFF;
out[7] = (n >> 24) & 0xFF;
// rate
- n = cl_capturevideo_soundrate;
+ n = cls.capturevideo_soundrate;
out[24] = (n) & 0xFF;
out[25] = (n >> 8) & 0xFF;
out[26] = (n >> 16) & 0xFF;
out[27] = (n >> 24) & 0xFF;
// bytes per second (rate * channels * bytes per channel)
- n = cl_capturevideo_soundrate * 2 * 2;
+ n = cls.capturevideo_soundrate * 2 * 2;
out[28] = (n) & 0xFF;
out[29] = (n >> 8) & 0xFF;
out[30] = (n >> 16) & 0xFF;
out[41] = (n >> 8) & 0xFF;
out[42] = (n >> 16) & 0xFF;
out[43] = (n >> 24) & 0xFF;
- FS_Seek (cl_capturevideo_soundfile, 0, SEEK_SET);
- FS_Write (cl_capturevideo_soundfile, out, 44);
- FS_Close (cl_capturevideo_soundfile);
- cl_capturevideo_soundfile = NULL;
+ FS_Seek (cls.capturevideo_soundfile, 0, SEEK_SET);
+ FS_Write (cls.capturevideo_soundfile, out, 44);
+ FS_Close (cls.capturevideo_soundfile);
+ cls.capturevideo_soundfile = NULL;
}
- if (cl_capturevideo_buffer)
+ if (cls.capturevideo_buffer)
{
- Mem_Free (cl_capturevideo_buffer);
- cl_capturevideo_buffer = NULL;
+ Mem_Free (cls.capturevideo_buffer);
+ cls.capturevideo_buffer = NULL;
}
- cl_capturevideo_starttime = 0;
- cl_capturevideo_framerate = 0;
- cl_capturevideo_frame = 0;
+ cls.capturevideo_starttime = 0;
+ cls.capturevideo_framerate = 0;
+ cls.capturevideo_frame = 0;
}
qboolean SCR_CaptureVideo_VideoFrame(int newframenum)
unsigned char *b, *out;
char filename[32];
int outoffset = (width/2)*(height/2);
- //return SCR_ScreenShot(filename, cl_capturevideo_buffer, cl_capturevideo_buffer + vid.width * vid.height * 3, cl_capturevideo_buffer + vid.width * vid.height * 6, 0, 0, vid.width, vid.height, false, false, false, jpeg, true);
+ //return SCR_ScreenShot(filename, cls.capturevideo_buffer, cls.capturevideo_buffer + vid.width * vid.height * 3, cls.capturevideo_buffer + vid.width * vid.height * 6, 0, 0, vid.width, vid.height, false, false, false, jpeg, true);
// speed is critical here, so do saving as directly as possible
- switch (cl_capturevideo_format)
+ switch (cls.capturevideo_format)
{
case CAPTUREVIDEOFORMAT_RAWYV12:
// FIXME: width/height must be multiple of 2, enforce this?
- qglReadPixels (x, y, width, height, GL_RGB, GL_UNSIGNED_BYTE, cl_capturevideo_buffer);
+ qglReadPixels (x, y, width, height, GL_RGB, GL_UNSIGNED_BYTE, cls.capturevideo_buffer);
CHECKGLERROR
// process one line at a time, and CbCr every other line at 2 pixel intervals
for (y = 0;y < height;y++)
{
// 1x1 Y
- for (b = cl_capturevideo_buffer + (height-1-y)*width*3, out = cl_capturevideo_buffer + width*height*3 + y*width, x = 0;x < width;x++, b += 3, out++)
- *out = cl_capturevideo_yuvnormalizetable[0][cl_capturevideo_rgbtoyuvscaletable[0][0][b[0]] + cl_capturevideo_rgbtoyuvscaletable[0][1][b[1]] + cl_capturevideo_rgbtoyuvscaletable[0][2][b[2]]];
+ for (b = cls.capturevideo_buffer + (height-1-y)*width*3, out = cls.capturevideo_buffer + width*height*3 + y*width, x = 0;x < width;x++, b += 3, out++)
+ *out = cls.capturevideo_yuvnormalizetable[0][cls.capturevideo_rgbtoyuvscaletable[0][0][b[0]] + cls.capturevideo_rgbtoyuvscaletable[0][1][b[1]] + cls.capturevideo_rgbtoyuvscaletable[0][2][b[2]]];
if ((y & 1) == 0)
{
// 2x2 Cb and Cr planes
#if 1
// low quality, no averaging
- for (b = cl_capturevideo_buffer + (height-2-y)*width*3, out = cl_capturevideo_buffer + width*height*3 + width*height + (y/2)*(width/2), x = 0;x < width/2;x++, b += 6, out++)
+ for (b = cls.capturevideo_buffer + (height-2-y)*width*3, out = cls.capturevideo_buffer + width*height*3 + width*height + (y/2)*(width/2), x = 0;x < width/2;x++, b += 6, out++)
{
// Cr
- out[0 ] = cl_capturevideo_yuvnormalizetable[2][cl_capturevideo_rgbtoyuvscaletable[2][0][b[0]] + cl_capturevideo_rgbtoyuvscaletable[2][1][b[1]] + cl_capturevideo_rgbtoyuvscaletable[2][2][b[2]] + 128];
+ out[0 ] = cls.capturevideo_yuvnormalizetable[2][cls.capturevideo_rgbtoyuvscaletable[2][0][b[0]] + cls.capturevideo_rgbtoyuvscaletable[2][1][b[1]] + cls.capturevideo_rgbtoyuvscaletable[2][2][b[2]] + 128];
// Cb
- out[outoffset] = cl_capturevideo_yuvnormalizetable[1][cl_capturevideo_rgbtoyuvscaletable[1][0][b[0]] + cl_capturevideo_rgbtoyuvscaletable[1][1][b[1]] + cl_capturevideo_rgbtoyuvscaletable[1][2][b[2]] + 128];
+ out[outoffset] = cls.capturevideo_yuvnormalizetable[1][cls.capturevideo_rgbtoyuvscaletable[1][0][b[0]] + cls.capturevideo_rgbtoyuvscaletable[1][1][b[1]] + cls.capturevideo_rgbtoyuvscaletable[1][2][b[2]] + 128];
}
#else
// high quality, averaging
int inpitch = width*3;
- for (b = cl_capturevideo_buffer + (height-2-y)*width*3, out = cl_capturevideo_buffer + width*height*3 + width*height + (y/2)*(width/2), x = 0;x < width/2;x++, b += 6, out++)
+ for (b = cls.capturevideo_buffer + (height-2-y)*width*3, out = cls.capturevideo_buffer + width*height*3 + width*height + (y/2)*(width/2), x = 0;x < width/2;x++, b += 6, out++)
{
int blockr, blockg, blockb;
blockr = (b[0] + b[3] + b[inpitch+0] + b[inpitch+3]) >> 2;
blockg = (b[1] + b[4] + b[inpitch+1] + b[inpitch+4]) >> 2;
blockb = (b[2] + b[5] + b[inpitch+2] + b[inpitch+5]) >> 2;
// Cr
- out[0 ] = cl_capturevideo_yuvnormalizetable[2][cl_capturevideo_rgbtoyuvscaletable[2][0][blockr] + cl_capturevideo_rgbtoyuvscaletable[2][1][blockg] + cl_capturevideo_rgbtoyuvscaletable[2][2][blockb] + 128];
+ out[0 ] = cls.capturevideo_yuvnormalizetable[2][cls.capturevideo_rgbtoyuvscaletable[2][0][blockr] + cls.capturevideo_rgbtoyuvscaletable[2][1][blockg] + cls.capturevideo_rgbtoyuvscaletable[2][2][blockb] + 128];
// Cb
- out[outoffset] = cl_capturevideo_yuvnormalizetable[1][cl_capturevideo_rgbtoyuvscaletable[1][0][blockr] + cl_capturevideo_rgbtoyuvscaletable[1][1][blockg] + cl_capturevideo_rgbtoyuvscaletable[1][2][blockb] + 128];
+ out[outoffset] = cls.capturevideo_yuvnormalizetable[1][cls.capturevideo_rgbtoyuvscaletable[1][0][blockr] + cls.capturevideo_rgbtoyuvscaletable[1][1][blockg] + cls.capturevideo_rgbtoyuvscaletable[1][2][blockb] + 128];
}
#endif
}
}
- for (;cl_capturevideo_frame < newframenum;cl_capturevideo_frame++)
- if (!FS_Write (cl_capturevideo_videofile, cl_capturevideo_buffer + width*height*3, width*height+(width/2)*(height/2)*2))
+ for (;cls.capturevideo_frame < newframenum;cls.capturevideo_frame++)
+ if (!FS_Write (cls.capturevideo_videofile, cls.capturevideo_buffer + width*height*3, width*height+(width/2)*(height/2)*2))
return false;
return true;
case CAPTUREVIDEOFORMAT_RAWRGB:
- qglReadPixels (x, y, width, height, GL_RGB, GL_UNSIGNED_BYTE, cl_capturevideo_buffer);
+ qglReadPixels (x, y, width, height, GL_RGB, GL_UNSIGNED_BYTE, cls.capturevideo_buffer);
CHECKGLERROR
- for (;cl_capturevideo_frame < newframenum;cl_capturevideo_frame++)
- if (!FS_Write (cl_capturevideo_videofile, cl_capturevideo_buffer, width*height*3))
+ for (;cls.capturevideo_frame < newframenum;cls.capturevideo_frame++)
+ if (!FS_Write (cls.capturevideo_videofile, cls.capturevideo_buffer, width*height*3))
return false;
return true;
case CAPTUREVIDEOFORMAT_JPEG:
- qglReadPixels (x, y, width, height, GL_RGB, GL_UNSIGNED_BYTE, cl_capturevideo_buffer);
+ qglReadPixels (x, y, width, height, GL_RGB, GL_UNSIGNED_BYTE, cls.capturevideo_buffer);
CHECKGLERROR
- for (;cl_capturevideo_frame < newframenum;cl_capturevideo_frame++)
+ for (;cls.capturevideo_frame < newframenum;cls.capturevideo_frame++)
{
- sprintf(filename, "video/dp%06d.jpg", cl_capturevideo_frame);
- if (!JPEG_SaveImage_preflipped (filename, width, height, cl_capturevideo_buffer))
+ sprintf(filename, "video/dp%06d.jpg", cls.capturevideo_frame);
+ if (!JPEG_SaveImage_preflipped (filename, width, height, cls.capturevideo_buffer))
return false;
}
return true;
case CAPTUREVIDEOFORMAT_TARGA:
- //return Image_WriteTGARGB_preflipped (filename, width, height, cl_capturevideo_buffer, cl_capturevideo_buffer + vid.width * vid.height * 3, );
- memset (cl_capturevideo_buffer, 0, 18);
- cl_capturevideo_buffer[2] = 2; // uncompressed type
- cl_capturevideo_buffer[12] = (width >> 0) & 0xFF;
- cl_capturevideo_buffer[13] = (width >> 8) & 0xFF;
- cl_capturevideo_buffer[14] = (height >> 0) & 0xFF;
- cl_capturevideo_buffer[15] = (height >> 8) & 0xFF;
- cl_capturevideo_buffer[16] = 24; // pixel size
- qglReadPixels (x, y, width, height, GL_BGR, GL_UNSIGNED_BYTE, cl_capturevideo_buffer + 18);
+ //return Image_WriteTGARGB_preflipped (filename, width, height, cls.capturevideo_buffer, cls.capturevideo_buffer + vid.width * vid.height * 3, );
+ memset (cls.capturevideo_buffer, 0, 18);
+ cls.capturevideo_buffer[2] = 2; // uncompressed type
+ cls.capturevideo_buffer[12] = (width >> 0) & 0xFF;
+ cls.capturevideo_buffer[13] = (width >> 8) & 0xFF;
+ cls.capturevideo_buffer[14] = (height >> 0) & 0xFF;
+ cls.capturevideo_buffer[15] = (height >> 8) & 0xFF;
+ cls.capturevideo_buffer[16] = 24; // pixel size
+ qglReadPixels (x, y, width, height, GL_BGR, GL_UNSIGNED_BYTE, cls.capturevideo_buffer + 18);
CHECKGLERROR
- for (;cl_capturevideo_frame < newframenum;cl_capturevideo_frame++)
+ for (;cls.capturevideo_frame < newframenum;cls.capturevideo_frame++)
{
- sprintf(filename, "video/dp%06d.tga", cl_capturevideo_frame);
- if (!FS_WriteFile (filename, cl_capturevideo_buffer, width*height*3 + 18))
+ sprintf(filename, "video/dp%06d.tga", cls.capturevideo_frame);
+ if (!FS_WriteFile (filename, cls.capturevideo_buffer, width*height*3 + 18))
return false;
}
return true;
}
}
-void SCR_CaptureVideo_SoundFrame(qbyte *bufstereo16le, size_t length, int rate)
+void SCR_CaptureVideo_SoundFrame(unsigned char *bufstereo16le, size_t length, int rate)
{
- if (!cl_capturevideo_soundfile)
+ if (!cls.capturevideo_soundfile)
return;
- cl_capturevideo_soundrate = rate;
- if (FS_Write (cl_capturevideo_soundfile, bufstereo16le, 4 * length) < (fs_offset_t)(4 * length))
+ cls.capturevideo_soundrate = rate;
+ if (FS_Write (cls.capturevideo_soundfile, bufstereo16le, 4 * length) < (fs_offset_t)(4 * length))
{
Cvar_SetValueQuick(&cl_capturevideo, 0);
- Con_Printf("video sound saving failed on frame %i, out of disk space? stopping video capture.\n", cl_capturevideo_frame);
+ Con_Printf("video sound saving failed on frame %i, out of disk space? stopping video capture.\n", cls.capturevideo_frame);
SCR_CaptureVideo_EndVideo();
}
}
int newframenum;
if (cl_capturevideo.integer && r_render.integer)
{
- if (!cl_capturevideo_active)
+ if (!cls.capturevideo_active)
SCR_CaptureVideo_BeginVideo();
- if (cl_capturevideo_framerate != cl_capturevideo_fps.value)
+ if (cls.capturevideo_framerate != cl_capturevideo_fps.value)
{
Con_Printf("You can not change the video framerate while recording a video.\n");
- Cvar_SetValueQuick(&cl_capturevideo_fps, cl_capturevideo_framerate);
+ Cvar_SetValueQuick(&cl_capturevideo_fps, cls.capturevideo_framerate);
}
- if (cl_capturevideo_soundfile)
+ if (cls.capturevideo_soundfile)
{
// preserve sound sync by duplicating frames when running slow
- newframenum = (Sys_DoubleTime() - cl_capturevideo_starttime) * cl_capturevideo_framerate;
+ newframenum = (Sys_DoubleTime() - cls.capturevideo_starttime) * cls.capturevideo_framerate;
}
else
- newframenum = cl_capturevideo_frame + 1;
+ newframenum = cls.capturevideo_frame + 1;
// if falling behind more than one second, stop
- if (newframenum - cl_capturevideo_frame > (int)ceil(cl_capturevideo_framerate))
+ if (newframenum - cls.capturevideo_frame > (int)ceil(cls.capturevideo_framerate))
{
Cvar_SetValueQuick(&cl_capturevideo, 0);
- Con_Printf("video saving failed on frame %i, your machine is too slow for this capture speed.\n", cl_capturevideo_frame);
+ Con_Printf("video saving failed on frame %i, your machine is too slow for this capture speed.\n", cls.capturevideo_frame);
SCR_CaptureVideo_EndVideo();
return;
}
if (!SCR_CaptureVideo_VideoFrame(newframenum))
{
Cvar_SetValueQuick(&cl_capturevideo, 0);
- Con_Printf("video saving failed on frame %i, out of disk space? stopping video capture.\n", cl_capturevideo_frame);
+ Con_Printf("video saving failed on frame %i, out of disk space? stopping video capture.\n", cls.capturevideo_frame);
SCR_CaptureVideo_EndVideo();
}
}
- else if (cl_capturevideo_active)
+ else if (cls.capturevideo_active)
SCR_CaptureVideo_EndVideo();
}
Grab six views for environment mapping tests
===============
*/
-struct
+struct envmapinfo_s
{
float angles[3];
char *name;
static void R_Envmap_f (void)
{
int j, size;
- char filename[256], basename[256];
- qbyte *buffer1;
- qbyte *buffer2;
- qbyte *buffer3;
+ char filename[MAX_QPATH], basename[MAX_QPATH];
+ unsigned char *buffer1;
+ unsigned char *buffer2;
+ unsigned char *buffer3;
if (Cmd_Argc() != 3)
{
r_refdef.width = size;
r_refdef.height = size;
- r_refdef.fov_x = 90;
- r_refdef.fov_y = 90;
+ r_refdef.frustum_x = tan(90 * M_PI / 360.0);
+ r_refdef.frustum_y = tan(90 * M_PI / 360.0);
- buffer1 = Mem_Alloc(tempmempool, size * size * 3);
- buffer2 = Mem_Alloc(tempmempool, size * size * 3);
- buffer3 = Mem_Alloc(tempmempool, size * size * 3 + 18);
+ buffer1 = (unsigned char *)Mem_Alloc(tempmempool, size * size * 3);
+ buffer2 = (unsigned char *)Mem_Alloc(tempmempool, size * size * 3);
+ buffer3 = (unsigned char *)Mem_Alloc(tempmempool, size * size * 3 + 18);
for (j = 0;j < 12;j++)
{
void SHOWLMP_decodehide(void)
{
int i;
- qbyte *lmplabel;
+ char *lmplabel;
lmplabel = MSG_ReadString();
for (i = 0;i < SHOWLMP_MAXLABELS;i++)
if (showlmp[i].isactive && strcmp(showlmp[i].label, lmplabel) == 0)
void SHOWLMP_decodeshow(void)
{
int i, k;
- qbyte lmplabel[256], picname[256];
+ char lmplabel[256], picname[256];
float x, y;
strlcpy (lmplabel,MSG_ReadString(), sizeof (lmplabel));
strlcpy (picname, MSG_ReadString(), sizeof (picname));
int i;
for (i = 0;i < SHOWLMP_MAXLABELS;i++)
if (showlmp[i].isactive)
- DrawQ_Pic(showlmp[i].x, showlmp[i].y, showlmp[i].pic, 0, 0, 1, 1, 1, 1, 0);
+ DrawQ_Pic(showlmp[i].x, showlmp[i].y, Draw_CachePic(showlmp[i].pic, false), 0, 0, 1, 1, 1, 1, 0);
}
void SHOWLMP_clear(void)
SCR_CaptureVideo();
- if (cls.signon == SIGNONS)
+ if (r_timereport_active)
R_TimeReport("other");
CL_SetupScreenSize();
DrawQ_Clear();
- if (cls.signon == SIGNONS)
+ if (r_timereport_active)
R_TimeReport("setup");
//FIXME: force menu if nothing else to look at?
SCR_CheckDrawCenterString();
}
MR_Draw();
- UI_Callback_Draw();
CL_DrawVideo();
- //ui_draw();
if (cls.signon == SIGNONS)
{
- R_TimeReport("2d");
- R_TimeReport_End();
- R_TimeReport_Start();
+ if (r_timereport_active)
+ R_TimeReport("2d");
+ R_TimeReport_Frame();
}
R_Shadow_EditLights_DrawSelectedLightProperties();
- SCR_DrawConsole();
+ if(!csqc_loaded)
+ SCR_DrawConsole();
SCR_DrawBrand();
+ SCR_DrawDownload();
+
+ if (r_timereport_active)
+ R_TimeReport("start");
+
SCR_UpdateScreen();
}
projects / xonotic / darkplaces.git / blobdiff