Doom 3 Timedemo Download Adobe
We've posted the definitive guide to benchmarking with DOOM 3 which includes information on exactly how to benchmark the game and the issues to look out for. (download it here) to measure. The Doom reboot is a gift to the PC Master Race. The 4K visuals are amazing, excellent high resolution textures cover every surface, the lighting and shadows are on point and this all comes.
PermalinkJoin GitHub today
GitHub is home to over 40 million developers working together to host and review code, manage projects, and build software together.
Sign up0 contributors
| /* |
| Doom 3 BFG Edition GPL Source Code |
| Copyright (C) 1993-2012 id Software LLC, a ZeniMax Media company. |
| This file is part of the Doom 3 BFG Edition GPL Source Code ('Doom 3 BFG Edition Source Code'). |
| Doom 3 BFG Edition Source Code is free software: you can redistribute it and/or modify |
| it under the terms of the GNU General Public License as published by |
| the Free Software Foundation, either version 3 of the License, or |
| (at your option) any later version. |
| Doom 3 BFG Edition Source Code is distributed in the hope that it will be useful, |
| but WITHOUT ANY WARRANTY; without even the implied warranty of |
| MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| GNU General Public License for more details. |
| You should have received a copy of the GNU General Public License |
| along with Doom 3 BFG Edition Source Code. If not, see <http://www.gnu.org/licenses/>. |
| In addition, the Doom 3 BFG Edition Source Code is also subject to certain additional terms. You should have received a copy of these additional terms immediately following the terms and conditions of the GNU General Public License which accompanied the Doom 3 BFG Edition Source Code. If not, please request a copy in writing from id Software at the address below. |
| If you have questions concerning this license or the applicable additional terms, you may contact in writing id Software LLC, c/o ZeniMax Media Inc., Suite 120, Rockville, Maryland 20850 USA. |
| */ |
| #include'Precompiled.h' |
| #include'globaldata.h' |
| #include<stdio.h> |
| #include<stdlib.h> |
| #include<sys/types.h> |
| #include<sys/stat.h> |
| #include<fcntl.h> |
| #include'doomdef.h' |
| #include'doomstat.h' |
| #include'dstrings.h' |
| #include'sounds.h' |
| #include'z_zone.h' |
| #include'w_wad.h' |
| #include's_sound.h' |
| #include'v_video.h' |
| #include'f_finale.h' |
| #include'f_wipe.h' |
| #include'm_argv.h' |
| #include'm_misc.h' |
| #include'm_menu.h' |
| #include'i_system.h' |
| #include'i_sound.h' |
| #include'i_video.h' |
| #include'g_game.h' |
| #include'hu_stuff.h' |
| #include'wi_stuff.h' |
| #include'st_stuff.h' |
| #include'am_map.h' |
| #include'p_setup.h' |
| #include'r_local.h' |
| #include'd_main.h' |
| //#include '../idLib/precompiled.h' |
| //#include '../Main/PlayerProfile.h' |
| //#include '../Main/PSN/PS3_Session.h' |
| #include'd3xp/Game_local.h' |
| // |
| // D-DoomLoop() |
| // Not a globally visible function, |
| // just included for source reference, |
| // called by D_DoomMain, never exits. |
| // Manages timing and IO, |
| // calls all ?_Responder, ?_Ticker, and ?_Drawer, |
| // calls I_GetTime, I_StartFrame, and I_StartTic |
| // |
| voidD_DoomLoop (void); |
| voidR_ExecuteSetViewSize (void); |
| voidD_CheckNetGame (void); |
| boolD_PollNetworkStart(); |
| voidD_ProcessEvents (void); |
| voidD_DoAdvanceDemo (void); |
| constchar* wadfiles[MAXWADFILES] = |
| { |
| 0 |
| }; |
| constchar* extraWad = 0; |
| // |
| // EVENT HANDLING |
| // |
| // Events are asynchronous inputs generally generated by the game user. |
| // Events can be discarded if no responder claims them |
| // |
| // |
| // D_PostEvent |
| // Called by the I/O functions when input is detected |
| // |
| voidD_PostEvent (event_t* ev) |
| { |
| ::g->events[::g->eventhead] = *ev; |
| ::g->eventhead = (++::g->eventhead)&(MAXEVENTS-1); |
| } |
| // |
| // D_ProcessEvents |
| // Send all the ::g->events of the given timestamp down the responder chain |
| // |
| voidD_ProcessEvents (void) |
| { |
| event_t* ev; |
| // IF STORE DEMO, DO NOT ACCEPT INPUT |
| if ( ( ::g->gamemode commercial ) |
| && (W_CheckNumForName('map01')<0) ) |
| return; |
| for ( ; ::g->eventtail != ::g->eventhead ; ::g->eventtail = (++::g->eventtail)&(MAXEVENTS-1) ) |
| { |
| ev = &::g->events[::g->eventtail]; |
| if (M_Responder (ev)) |
| continue; // menu ate the event |
| G_Responder (ev); |
| } |
| } |
| // |
| // D_Display |
| // draw current display, possibly wiping it from the previous |
| // |
| // ::g->wipegamestate can be set to -1 to force a ::g->wipe on the next draw |
| externbool waitingForWipe; |
| voidD_Wipe() |
| { |
| int nowtime, tics; |
| nowtime = I_GetTime(); |
| tics = nowtime - ::g->wipestart; |
| if (tics != 0) |
| { |
| ::g->wipestart = nowtime; |
| ::g->wipedone = wipe_ScreenWipe( 0, 0, SCREENWIDTH, SCREENHEIGHT, tics ); |
| // DHM - Nerve :: Demo recording :: Stop large hitch on first frame after the wipe |
| if ( ::g->wipedone ) { |
| ::g->oldtrt_entertics = nowtime / ::g->ticdup; |
| ::g->gametime = nowtime; |
| ::g->wipe = false; |
| waitingForWipe = false; |
| } |
| } |
| } |
| voidD_Display (void) |
| { |
| qboolean redrawsbar; |
| if (::g->nodrawers) |
| return; // for comparative timing / profiling |
| redrawsbar = false; |
| // change the view size if needed |
| if (::g->setsizeneeded) |
| { |
| R_ExecuteSetViewSize(); |
| ::g->oldgamestate = (gamestate_t)-1; // force background redraw |
| ::g->borderdrawcount = 3; |
| } |
| // save the current screen if about to ::g->wipe |
| if (::g->gamestate != ::g->wipegamestate) |
| { |
| ::g->wipe = true; |
| wipe_StartScreen(0, 0, SCREENWIDTH, SCREENHEIGHT); |
| } |
| else |
| ::g->wipe = false; |
| if (::g->gamestate GS_LEVEL && ::g->gametic) |
| HU_Erase(); |
| // do buffered drawing |
| switch (::g->gamestate) |
| { |
| case GS_LEVEL: |
| if (!::g->gametic) |
| break; |
| if (::g->automapactive) |
| AM_Drawer (); |
| if (::g->wipe || (::g->viewheight != 200 * GLOBAL_IMAGE_SCALER && ::g->fullscreen) ) |
| redrawsbar = true; |
| if (::g->inhelpscreensstate && !::g->inhelpscreens) |
| redrawsbar = true; // just put away the help screen |
| ST_Drawer ( ::g->viewheight200 * GLOBAL_IMAGE_SCALER, redrawsbar ); |
| ::g->fullscreen = ::g->viewheight200 * GLOBAL_IMAGE_SCALER; |
| break; |
| case GS_INTERMISSION: |
| WI_Drawer (); |
| break; |
| case GS_FINALE: |
| F_Drawer (); |
| break; |
| case GS_DEMOSCREEN: |
| D_PageDrawer (); |
| break; |
| } |
| // draw buffered stuff to screen |
| I_UpdateNoBlit (); |
| // draw the view directly |
| if (::g->gamestate GS_LEVEL && !::g->automapactive && ::g->gametic) |
| R_RenderPlayerView (&::g->players[::g->displayplayer]); |
| if (::g->gamestate GS_LEVEL && ::g->gametic) |
| HU_Drawer (); |
| // clean up border stuff |
| if (::g->gamestate != ::g->oldgamestate && ::g->gamestate != GS_LEVEL) |
| I_SetPalette ((byte*)W_CacheLumpName ('PLAYPAL',PU_CACHE_SHARED)); |
| // see if the border needs to be initially drawn |
| if (::g->gamestate GS_LEVEL && ::g->oldgamestate != GS_LEVEL) |
| { |
| ::g->viewactivestate = false; // view was not active |
| R_FillBackScreen (); // draw the pattern into the back screen |
| } |
| // see if the border needs to be updated to the screen |
| if (::g->gamestate GS_LEVEL && !::g->automapactive && ::g->scaledviewwidth != (320 * GLOBAL_IMAGE_SCALER) ) |
| { |
| if (::g->menuactive || ::g->menuactivestate || !::g->viewactivestate) |
| ::g->borderdrawcount = 3; |
| if (::g->borderdrawcount) |
| { |
| R_DrawViewBorder (); // erase old menu stuff |
| ::g->borderdrawcount--; |
| } |
| } |
| ::g->menuactivestate = ::g->menuactive; |
| ::g->viewactivestate = ::g->viewactive; |
| ::g->inhelpscreensstate = ::g->inhelpscreens; |
| ::g->oldgamestate = ::g->wipegamestate = ::g->gamestate; |
| // draw pause pic |
| /* |
| if (::g->paused) |
| { |
| if (::g->automapactive) |
| y = 4; |
| else |
| y = ::g->viewwindowy+4; |
| V_DrawPatchDirect(::g->viewwindowx+(ORIGINAL_WIDTH-68)/2, |
| y,0,(patch_t*)W_CacheLumpName ('M_PAUSE', PU_CACHE_SHARED)); |
| } |
| */ |
| // menus go directly to the screen |
| M_Drawer (); // menu is drawn even on top of everything |
| NetUpdate ( NULL ); // send out any new accumulation |
| // normal update |
| if (!::g->wipe) |
| { |
| I_FinishUpdate (); // page flip or blit buffer |
| return; |
| } |
| // update |
| wipe_EndScreen(0, 0, SCREENWIDTH, SCREENHEIGHT); |
| ::g->wipestart = I_GetTime () - 1; |
| D_Wipe(); // initialize g->wipedone |
| } |
| voidD_RunFrame( bool Sounds ) |
| { |
| if (Sounds) { |
| // move positional sounds |
| S_UpdateSounds (::g->players[::g->consoleplayer].mo); |
| } |
| // Update display, next frame, with current state. |
| D_Display (); |
| if (Sounds) { |
| // Update sound output. |
| I_SubmitSound(); |
| } |
| } |
| // |
| // D_DoomLoop |
| // |
| voidD_DoomLoop (void) |
| { |
| // DHM - Not used |
| /* |
| if (M_CheckParm ('-debugfile')) |
| { |
| char filename[20]; |
| sprintf (filename,'debug%i.txt',::g->consoleplayer); |
| I_Printf ('debug output to: %sn',filename); |
| ::g->debugfile = f o p e n(filename,'w'); |
| } |
| I_InitGraphics (); |
| while (1) |
| { |
| TryRunTics(); |
| D_RunFrame( true ); |
| } |
| */ |
| } |
| // |
| // DEMO LOOP |
| // |
| // |
| // D_PageTicker |
| // Handles timing for warped ::g->projection |
| // |
| voidD_PageTicker (void) |
| { |
| if (--::g->pagetic < 0) |
| D_AdvanceDemo (); |
| } |
| // |
| // D_PageDrawer |
| // |
| voidD_PageDrawer (void) |
| { |
| V_DrawPatch (0,0, 0, (patch_t*)W_CacheLumpName(::g->pagename, PU_CACHE_SHARED)); |
| } |
| // |
| // D_AdvanceDemo |
| // Called after each demo or intro ::g->demosequence finishes |
| // |
| voidD_AdvanceDemo (void) |
| { |
| ::g->advancedemo = true; |
| } |
| // |
| // This cycles through the demo sequences. |
| // FIXME - version dependend demo numbers? |
| // |
| voidD_DoAdvanceDemo (void) |
| { |
| ::g->players[::g->consoleplayer].playerstate = PST_LIVE; // not reborn |
| ::g->advancedemo = false; |
| ::g->usergame = false; // no save / end game here |
| ::g->paused = false; |
| ::g->gameaction = ga_nothing; |
| if ( ::g->gamemode retail ) |
| ::g->demosequence = (::g->demosequence+1)%8; |
| else |
| ::g->demosequence = (::g->demosequence+1)%6; |
| switch (::g->demosequence) |
| { |
| case0: |
| if ( ::g->gamemode commercial ) |
| ::g->pagetic = 35 * 11; |
| else |
| ::g->pagetic = 8 * TICRATE; |
| ::g->gamestate = GS_DEMOSCREEN; |
| ::g->pagename = 'INTERPIC'; |
| if ( ::g->gamemode commercial ) |
| S_StartMusic(mus_dm2ttl); |
| else |
| S_StartMusic (mus_intro); |
| break; |
| case1: |
| G_DeferedPlayDemo ('demo1'); |
| break; |
| case2: |
| ::g->pagetic = 3 * TICRATE; |
| ::g->gamestate = GS_DEMOSCREEN; |
| ::g->pagename = 'INTERPIC'; |
| break; |
| case3: |
| G_DeferedPlayDemo ('demo2'); |
| break; |
| case4: |
| ::g->pagetic = 3 * TICRATE; |
| ::g->gamestate = GS_DEMOSCREEN; |
| ::g->pagename = 'INTERPIC'; |
| break; |
| case5: |
| G_DeferedPlayDemo ('demo3'); |
| break; |
| // THE DEFINITIVE DOOM Special Edition demo |
| case6: |
| ::g->pagetic = 3 * TICRATE; |
| ::g->gamestate = GS_DEMOSCREEN; |
| ::g->pagename = 'INTERPIC'; |
| break; |
| case7: |
| G_DeferedPlayDemo ('demo4'); |
| break; |
| } |
| } |
| // |
| // D_StartTitle |
| // |
| voidD_StartTitle (void) |
| { |
| ::g->gameaction = ga_nothing; |
| ::g->demosequence = -1; |
| D_AdvanceDemo (); |
| } |
| // print ::g->title for every printed line |
| // |
| // D_AddExtraWadFile |
| // |
| voidD_SetExtraWadFile( constchar *file ) { |
| extraWad = file; |
| } |
| // |
| // D_AddFile |
| // |
| voidD_AddFile (constchar *file) |
| { |
| int numwadfiles; |
| for (numwadfiles = 0 ; wadfiles[numwadfiles] ; numwadfiles++) |
| if (file wadfiles[numwadfiles]) |
| return; |
| ; |
| wadfiles[numwadfiles] = file; |
| } |
| // |
| // IdentifyVersion |
| // Checks availability of IWAD files by name, |
| // to determine whether registered/commercial features |
| // should be executed (notably loading PWAD's). |
| // |
| voidIdentifyVersion (void) |
| { |
| W_FreeWadFiles(); |
| const ExpansionData * expansion = DoomLib::GetCurrentExpansion(); |
| ::g->gamemode = expansion->gameMode; |
| ::g->gamemission = expansion->pack_type; |
| if( expansion->type ExpansionData::PWAD ) { |
| D_AddFile( expansion->iWadFilename ); |
| D_AddFile( expansion->pWadFilename ); |
| } else { |
| D_AddFile( expansion->iWadFilename ); |
| } |
| } |
| // |
| // Find a Response File |
| // |
| voidFindResponseFile (void) |
| { |
| } |
| // |
| // D_DoomMain |
| // |
| voidD_DoomMain (void) |
| { |
| int p; |
| char file[256]; |
| FindResponseFile (); |
| IdentifyVersion (); |
| setbuf (stdout, NULL); |
| ::g->modifiedgame = false; |
| // TODO: Networking |
| //const bool isDeathmatch = gameLocal->GetMatchParms().GetGameType() GAME_TYPE_PVP; |
| constbool isDeathmatch = false; |
| ::g->nomonsters = M_CheckParm ('-nomonsters') || isDeathmatch; |
| ::g->respawnparm = M_CheckParm ('-respawn'); |
| ::g->fastparm = M_CheckParm ('-fast'); |
| ::g->devparm = M_CheckParm ('-devparm'); |
| if (M_CheckParm ('-altdeath') || isDeathmatch) |
| ::g->deathmatch = 2; |
| elseif (M_CheckParm ('-deathmatch')) |
| ::g->deathmatch = 1; |
| switch ( ::g->gamemode ) |
| { |
| case retail: |
| sprintf (::g->title, |
| '' |
| 'The Ultimate DOOM Startup v%i.%i' |
| '', |
| VERSION/100,VERSION%100); |
| break; |
| case shareware: |
| sprintf (::g->title, |
| '' |
| 'DOOM Shareware Startup v%i.%i' |
| '', |
| VERSION/100,VERSION%100); |
| break; |
| case registered: |
| sprintf (::g->title, |
| '' |
| 'DOOM Registered Startup v%i.%i' |
| '', |
| VERSION/100,VERSION%100); |
| break; |
| case commercial: |
| sprintf (::g->title, |
| '' |
| 'DOOM 2: Hell on Earth v%i.%i' |
| '', |
| VERSION/100,VERSION%100); |
| break; |
| default: |
| sprintf (::g->title, |
| '' |
| 'Public DOOM - v%i.%i' |
| '', |
| VERSION/100,VERSION%100); |
| break; |
| } |
| I_Printf ('%sn',::g->title); |
| if (::g->devparm) |
| I_Printf(D_DEVSTR); |
| if (M_CheckParm('-cdrom')) |
| { |
| I_Printf(D_CDROM); |
| //c++ mkdir('c:doomdata',0); |
| strcpy (::g->basedefault,'c:/doomdata/default.cfg'); |
| } |
| // add any files specified on the command line with -file ::g->wadfile |
| // to the wad list |
| // |
| p = M_CheckParm ('-file'); |
| if (p) |
| { |
| // the parms after p are ::g->wadfile/lump names, |
| // until end of parms or another - preceded parm |
| ::g->modifiedgame = true; // homebrew levels |
| while (++p != ::g->myargc && ::g->myargv[p][0] != '-') |
| D_AddFile (::g->myargv[p]); |
| } |
| p = M_CheckParm ('-playdemo'); |
| if (!p) |
| p = M_CheckParm ('-timedemo'); |
| if (p && p < ::g->myargc-1) |
| { |
| sprintf (file,'d:%s.lmp', ::g->myargv[p+1]); |
| D_AddFile (file); |
| I_Printf('Playing demo %s.lmp.n',::g->myargv[p+1]); |
| } |
| // get skill / episode / map from defaults |
| ::g->startskill = sk_medium; |
| ::g->startepisode = 1; |
| ::g->startmap = 1; |
| ::g->autostart = false; |
| if ( DoomLib::matchParms.gameEpisode != GAME_EPISODE_UNKNOWN ) { |
| ::g->startepisode = DoomLib::matchParms.gameEpisode; |
| ::g->autostart = 1; |
| } |
| if ( DoomLib::matchParms.gameMap != -1 ) { |
| ::g->startmap = DoomLib::matchParms.gameMap; |
| ::g->autostart = 1; |
| } |
| if ( DoomLib::matchParms.gameSkill != -1) { |
| ::g->startskill = (skill_t)DoomLib::matchParms.gameSkill; |
| } |
| // get skill / episode / map from cmdline |
| p = M_CheckParm ('-skill'); |
| if (p && p < ::g->myargc-1) |
| { |
| ::g->startskill = (skill_t)(::g->myargv[p+1][0]-'1'); |
| ::g->autostart = true; |
| } |
| p = M_CheckParm ('-episode'); |
| if (p && p < ::g->myargc-1) |
| { |
| ::g->startepisode = ::g->myargv[p+1][0]-'0'; |
| ::g->startmap = 1; |
| ::g->autostart = true; |
| } |
| /*p = M_CheckParm ('-timer'); |
| if (p && p < ::g->myargc-1 && ::g->deathmatch) |
| {*/ |
| // TODO: Networking |
| //const int timeLimit = gameLocal->GetMatchParms().GetTimeLimit(); |
| constint timeLimit = 0; |
| if (timeLimit != 0 && ::g->deathmatch) |
| { |
| inttime; |
| //time = atoi(::g->myargv[p+1]); |
| time = timeLimit; |
| I_Printf('Levels will end after %d minute',time); |
| if (time>1) |
| I_Printf('s'); |
| I_Printf('.n'); |
| } |
| p = M_CheckParm ('-avg'); |
| if (p && p < ::g->myargc-1 && ::g->deathmatch) |
| I_Printf('Austin Virtual Gaming: Levels will end after 20 minutesn'); |
| p = M_CheckParm ('-warp'); |
| if (p && p < ::g->myargc-1) |
| { |
| if (::g->gamemode commercial) |
| ::g->startmap = atoi (::g->myargv[p+1]); |
| else |
| { |
| ::g->startepisode = ::g->myargv[p+1][0]-'0'; |
| ::g->startmap = ::g->myargv[p+2][0]-'0'; |
| } |
| ::g->autostart = true; |
| } |
| I_Printf ('Z_Init: Init zone memory allocation daemon. n'); |
| Z_Init (); |
| // init subsystems |
| I_Printf ('V_Init: allocate ::g->screens.n'); |
| V_Init (); |
| I_Printf ('M_LoadDefaults: Load system defaults.n'); |
| M_LoadDefaults (); // load before initing other systems |
| I_Printf ('W_Init: Init WADfiles.n'); |
| W_InitMultipleFiles (wadfiles); |
| // Check for -file in shareware |
| if (::g->modifiedgame) |
| { |
| // These are the lumps that will be checked in IWAD, |
| // if any one is not present, execution will be aborted. |
| char name[23][16]= |
| { |
| 'e2m1','e2m2','e2m3','e2m4','e2m5','e2m6','e2m7','e2m8','e2m9', |
| 'e3m1','e3m3','e3m3','e3m4','e3m5','e3m6','e3m7','e3m8','e3m9', |
| 'dphoof','bfgga0','heada1','cybra1','spida1d1' |
| }; |
| int i; |
| if ( ::g->gamemode shareware) |
| I_Error('nYou cannot -file with the shareware ' |
| 'version. Register!'); |
| // Check for fake IWAD with right name, |
| // but w/o all the lumps of the registered version. |
| if (::g->gamemode registered) |
| for (i = 0;i < 23; i++) |
| if (W_CheckNumForName(name[i])<0) |
| I_Error('nThis is not the registered version.'); |
| } |
| // Iff additonal PWAD files are used, print modified banner |
| if (::g->modifiedgame) |
| { |
| /*m*/I_Printf ( |
| 'n' |
| 'ATTENTION: This version of DOOM has been modified. If you would like ton' |
| 'get a copy of the original game, call 1-800-IDGAMES or see the readme file.n' |
| ' You will not receive technical support for modified games.n' |
| ' press enter to continuen' |
| 'n' |
| ); |
| getchar (); |
| } |
| // Check and print which version is executed. |
| switch ( ::g->gamemode ) |
| { |
| case shareware: |
| case indetermined: |
| I_Printf ( |
| 'n' |
| ' Shareware!n' |
| 'n' |
| ); |
| break; |
| case registered: |
| case retail: |
| case commercial: |
| I_Printf ( |
| 'n' |
| ' Commercial product - do not distribute!n' |
| ' Please report software piracy to the SPA: 1-800-388-PIR8n' |
| 'n' |
| ); |
| break; |
| default: |
| // Ouch. |
| break; |
| } |
| I_Printf ('M_Init: Init miscellaneous info.n'); |
| M_Init (); |
| I_Printf ('R_Init: Init DOOM refresh daemon - '); |
| R_Init (); |
| I_Printf ('nP_Init: Init Playloop state.n'); |
| P_Init (); |
| I_Printf ('I_Init: Setting up machine state.n'); |
| I_Init (); |
| I_Printf ('D_CheckNetGame: Checking network game status.n'); |
| D_CheckNetGame (); |
| } |
| boolD_DoomMainPoll(void) |
| { |
| int p; |
| char file[256]; |
| if (D_PollNetworkStart() false) |
| returnfalse; |
| I_Printf( 'S_Init: Setting up sound.n' ); |
| S_Init( s_volume_sound.GetInteger(), s_volume_midi.GetInteger() ); |
| I_Printf ('HU_Init: Setting up heads up display.n'); |
| HU_Init (); |
| I_Printf ('ST_Init: Init status bar.n'); |
| ST_Init (); |
| // start the apropriate game based on parms |
| p = M_CheckParm ('-record'); |
| if (p && p < ::g->myargc-1) |
| { |
| G_RecordDemo (::g->myargv[p+1]); |
| ::g->autostart = true; |
| } |
| p = M_CheckParm ('-playdemo'); |
| if (p && p < ::g->myargc-1) |
| { |
| //::g->singledemo = true; // quit after one demo |
| G_DeferedPlayDemo (::g->myargv[p+1]); |
| //D_DoomLoop (); // never returns |
| } |
| p = M_CheckParm ('-timedemo'); |
| if (p && p < ::g->myargc-1) |
| { |
| G_TimeDemo ('nukage1');//::g->myargv[p+1]); |
| D_DoomLoop (); // never returns |
| } |
| p = M_CheckParm ('-loadgame'); |
| if (p && p < ::g->myargc-1) |
| { |
| if (M_CheckParm('-cdrom')) |
| sprintf(file, 'c:doomdata'SAVEGAMENAME'%c.dsg',::g->myargv[p+1][0]); |
| else |
| sprintf(file, SAVEGAMENAME'%c.dsg',::g->myargv[p+1][0]); |
| G_LoadGame (file); |
| } |
| if ( ::g->gameaction != ga_loadgame && ::g->gameaction != ga_playdemo ) |
| { |
| if (::g->autostart || ::g->netgame ) { |
| G_InitNew (::g->startskill, ::g->startepisode, ::g->startmap ); |
| } elseif( ::g->gameaction != ga_newgame) { |
| D_StartTitle (); // start up intro loop |
| } |
| } |
| returntrue; |
| } |
Copy lines Copy permalink
Twenty two years ago an obscure game developer called id Software released a first-person shooter that would have a huge impact on the future of PC gaming, computer graphics and the industry as a whole, that game was Doom.
At the time I was 10, and while I can't exactly recall if my first encounter with the game came right then or a few years later, it certainly left a mark as it did to millions.
One thing I do know is that there is a significant divide between the 1993 sci-fi horror game and id Software’s 2016 reboot. As a young kid I couldn’t imagine playing this latest version of Doom, which is probably why it has been rated M for mature players over the age of 17. Even with that in mind, this game should not be played by the squeamish. It’s what you might call a bit... gory.
Then of course, this is what die-hard fans of the franchise are after, violence is part of the Doom DNA. The action seems to be centered around fast-paced action and some newly introduced finishing moves, dubbed 'Glory Kills' which are scripted animations. Basically you touch up the demons with your various range of projectile weapons and rather than spend more ammunition finishing them you can move in for the glory kill where you stomp on their head, naturally causing it to explode. Alternatively, you might rip off an arm, the action is random so it’s a lucky dip of bloody violence.
Helping to make the gore all the more real and enjoyable for the twisted folks that enjoy that kind of thing is the id Tech 6 game engine, designed specifically for the Doom reboot. The engine supports OpenGL, while Vulkan API support will be patched in at a later date.
For those of you out of the loop, Vulkan is the successor to OpenGL, offering an open-source alternative to Microsoft's DirectX API. Vulkan is cross-platform, meaning it isn't limited to Windows and other Microsoft platforms, and will be supported by Google's Android and Valve's Steam OS.
Coming up soon... Doom running on Vulkan (watch below)
Gamers got their first taste of Doom a month ago when a portion of the multiplayer mode entered a brief open beta. The beta provided access to Team Deathmatch and Warpath game modes on the Heatwave and Infernal maps. Many came away disappointed with the lack of tweakable game and graphics options along with the 60fps frame cap. Gamers weren't enthused after the brief look at the gameplay aspect either.
Historically, id's beta tests have served as a broader test for games' multiplayer capabilities, graphics optimization, and scaling. Thankfully, the beta was just that and now that the game is officially out we are pleased to find a good number of tweakable options including an unlocked frame rate. And although there are no full reviews of the game just yet -- Bethesda didn't give away any advance copies to the press -- 48 hours after release Steam's user reviews can give a pretty good indication that the game delivers: 92% positive scores out of 6,500+ reviews so far.
So then Doom isn’t a crappy PC port, phew!
In fact, this is a gift to the PC Master Race. The 4K visuals are amazing, excellent high resolution textures cover every surface, the lighting and shadows are on point and this all comes together to make those glory kill animations look insane. The question that remains now is, what kind of hardware do you require to enjoy those glory kills in all of their gory glory?
Testing Notes
Doom doesn’t feature a benchmark tool and there aren’t any good pre-scripted sections of the game to test either. After playing for a few hours I decided to go back near the start of the game and benchmark the first main room that you enter full of Arch-Vile demons. Upon entering the room, we move left and then complete a number of laps before the 60 second test completes.
For testing the 'Ultra' preset was used with the exception of 'Decal Filtering' which was set to Anisotropic 16x from 8x. The game has been tested at 1080p, 1440p and 4K using the latest AMD and Nvidia drivers. This means the AMD Crimson Edition 16.5.2 and GeForce Game Ready 365.19 drivers were used.
Doom 3 Timedemo Download Adobe
Again, the benchmark pass was kept simple: we recorded 60 seconds of gameplay from the first level, we took the same path each time and we simply ran past any enemies.
Test System Specs
- Radeon R9 Fury (4096MB)
- GeForce GTX Titan X (12288MB)