mirror of
https://github.com/id-Software/DOOM-3-BFG.git
synced 2025-04-25 11:01:30 +00:00
1315 lines
30 KiB
C++
1315 lines
30 KiB
C++
/*
|
|
===========================================================================
|
|
|
|
Doom 3 BFG Edition GPL Source Code
|
|
Copyright (C) 1999-2011 id Software LLC, a ZeniMax Media company.
|
|
Copyright (C) 2024 Robert Beckebans
|
|
|
|
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"
|
|
#pragma hdrstop
|
|
|
|
#include "../sys/sys_local.h"
|
|
#include "../framework/EventLoop.h"
|
|
#include "../framework/DeclManager.h"
|
|
|
|
#include <direct.h>
|
|
#include <io.h>
|
|
|
|
#include "imtui/imtui.h"
|
|
#include "imtui/imtui-impl-ncurses.h"
|
|
#include "imtui/imtui-demo.h"
|
|
|
|
idEventLoop* eventLoop;
|
|
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// [SECTION] Example App: Debug Log / ShowExampleAppLog()
|
|
//-----------------------------------------------------------------------------
|
|
|
|
struct MyAppLog
|
|
{
|
|
ImGuiTextBuffer Buf;
|
|
ImGuiTextFilter Filter;
|
|
ImVector<int> LineOffsets; // Index to lines offset. We maintain this with AddLog() calls, allowing us to have a random access on lines
|
|
|
|
MyAppLog()
|
|
{
|
|
Clear();
|
|
}
|
|
|
|
void Clear()
|
|
{
|
|
Buf.clear();
|
|
LineOffsets.clear();
|
|
LineOffsets.push_back( 0 );
|
|
}
|
|
|
|
void AddLog( const char* fmt, ... ) IM_FMTARGS( 2 )
|
|
{
|
|
int old_size = Buf.size();
|
|
va_list args;
|
|
va_start( args, fmt );
|
|
Buf.appendfv( fmt, args );
|
|
va_end( args );
|
|
for( int new_size = Buf.size(); old_size < new_size; old_size++ )
|
|
if( Buf[old_size] == '\n' )
|
|
{
|
|
LineOffsets.push_back( old_size + 1 );
|
|
}
|
|
}
|
|
|
|
void Draw( const char* title, bool* p_open = NULL )
|
|
{
|
|
|
|
{
|
|
auto wSize = ImGui::GetIO().DisplaySize;
|
|
ImGui::SetNextWindowPos( ImVec2( 0, 1 ), ImGuiCond_Always );
|
|
ImGui::SetNextWindowSize( ImVec2( wSize.x, wSize.y - 5 ), ImGuiCond_Always );
|
|
}
|
|
if( !ImGui::Begin( title, p_open, ImGuiWindowFlags_NoDecoration ) )
|
|
{
|
|
ImGui::End();
|
|
return;
|
|
}
|
|
|
|
|
|
bool copy = ImGui::Button( "Copy to Clipboard" );
|
|
ImGui::SameLine();
|
|
|
|
ImGui::Separator();
|
|
ImGui::BeginChild( "scrolling", ImVec2( 0, 0 ), false, ImGuiWindowFlags_HorizontalScrollbar );
|
|
|
|
if( copy )
|
|
{
|
|
ImGui::LogToClipboard();
|
|
}
|
|
|
|
ImGui::PushStyleVar( ImGuiStyleVar_ItemSpacing, ImVec2( 0, 0 ) );
|
|
const char* buf = Buf.begin();
|
|
const char* buf_end = Buf.end();
|
|
#if 0
|
|
if( Filter.IsActive() )
|
|
{
|
|
// In this example we don't use the clipper when Filter is enabled.
|
|
// This is because we don't have a random access on the result on our filter.
|
|
// A real application processing logs with ten of thousands of entries may want to store the result of search/filter.
|
|
// especially if the filtering function is not trivial (e.g. reg-exp).
|
|
for( int line_no = 0; line_no < LineOffsets.Size; line_no++ )
|
|
{
|
|
const char* line_start = buf + LineOffsets[line_no];
|
|
const char* line_end = ( line_no + 1 < LineOffsets.Size ) ? ( buf + LineOffsets[line_no + 1] - 1 ) : buf_end;
|
|
if( Filter.PassFilter( line_start, line_end ) )
|
|
{
|
|
ImGui::TextUnformatted( line_start, line_end );
|
|
}
|
|
}
|
|
}
|
|
else
|
|
#endif
|
|
{
|
|
// The simplest and easy way to display the entire buffer:
|
|
// ImGui::TextUnformatted(buf_begin, buf_end);
|
|
// And it'll just work. TextUnformatted() has specialization for large blob of text and will fast-forward to skip non-visible lines.
|
|
// Here we instead demonstrate using the clipper to only process lines that are within the visible area.
|
|
// If you have tens of thousands of items and their processing cost is non-negligible, coarse clipping them on your side is recommended.
|
|
// Using ImGuiListClipper requires A) random access into your data, and B) items all being the same height,
|
|
// both of which we can handle since we an array pointing to the beginning of each line of text.
|
|
// When using the filter (in the block of code above) we don't have random access into the data to display anymore, which is why we don't use the clipper.
|
|
// Storing or skimming through the search result would make it possible (and would be recommended if you want to search through tens of thousands of entries)
|
|
ImGuiListClipper clipper;
|
|
clipper.Begin( LineOffsets.Size );
|
|
while( clipper.Step() )
|
|
{
|
|
for( int line_no = clipper.DisplayStart; line_no < clipper.DisplayEnd; line_no++ )
|
|
{
|
|
const char* line_start = buf + LineOffsets[line_no];
|
|
const char* line_end = ( line_no + 1 < LineOffsets.Size ) ? ( buf + LineOffsets[line_no + 1] - 1 ) : buf_end;
|
|
ImGui::TextUnformatted( line_start, line_end );
|
|
}
|
|
}
|
|
clipper.End();
|
|
}
|
|
ImGui::PopStyleVar();
|
|
|
|
//if( ImGui::GetScrollY() >= ImGui::GetScrollMaxY() )
|
|
{
|
|
ImGui::SetScrollHereY( 1.0f );
|
|
}
|
|
|
|
ImGui::EndChild();
|
|
ImGui::End();
|
|
}
|
|
};
|
|
|
|
static MyAppLog tuiLog;
|
|
|
|
#define MAXPRINTMSG 4096
|
|
|
|
#define STDIO_PRINT( pre, post ) \
|
|
char msg[MAXPRINTMSG]; \
|
|
va_list argptr; \
|
|
va_start( argptr, fmt ); \
|
|
idStr::vsnPrintf( msg, MAXPRINTMSG - 1, fmt, argptr ); \
|
|
msg[ sizeof( msg ) - 1 ] = '\0'; \
|
|
va_end( argptr ); \
|
|
Sys_Printf( "%s%s%s", pre, msg, post ); \
|
|
|
|
|
|
idCVar com_developer( "developer", "0", CVAR_BOOL | CVAR_SYSTEM, "developer mode" );
|
|
idCVar com_productionMode( "com_productionMode", "0", CVAR_SYSTEM | CVAR_BOOL, "0 - no special behavior, 1 - building a production build, 2 - running a production build" );
|
|
|
|
/*
|
|
==============================================================
|
|
|
|
idSys
|
|
|
|
==============================================================
|
|
*/
|
|
|
|
|
|
|
|
/*
|
|
==============
|
|
Sys_Printf
|
|
==============
|
|
*/
|
|
|
|
void Sys_Printf( const char* fmt, ... )
|
|
{
|
|
char msg[MAXPRINTMSG];
|
|
|
|
va_list argptr;
|
|
va_start( argptr, fmt );
|
|
idStr::vsnPrintf( msg, MAXPRINTMSG - 1, fmt, argptr );
|
|
msg[ sizeof( msg ) - 1 ] = '\0';
|
|
va_end( argptr );
|
|
|
|
printf( msg );
|
|
OutputDebugString( msg );
|
|
|
|
tuiLog.AddLog( "%s", msg );
|
|
}
|
|
|
|
/*
|
|
==============
|
|
Sys_VPrintf
|
|
==============
|
|
*/
|
|
void Sys_VPrintf( const char* fmt, va_list arg )
|
|
{
|
|
char msg[MAXPRINTMSG];
|
|
|
|
idStr::vsnPrintf( msg, MAXPRINTMSG - 1, fmt, arg );
|
|
msg[ sizeof( msg ) - 1 ] = '\0';
|
|
|
|
printf( msg );
|
|
OutputDebugString( msg );
|
|
|
|
tuiLog.AddLog( "%s", msg );
|
|
}
|
|
|
|
/*
|
|
==============
|
|
Sys_Mkdir
|
|
==============
|
|
*/
|
|
void Sys_Mkdir( const char* path )
|
|
{
|
|
_mkdir( path );
|
|
}
|
|
|
|
|
|
/*
|
|
========================
|
|
Sys_Rmdir
|
|
========================
|
|
*/
|
|
bool Sys_Rmdir( const char* path )
|
|
{
|
|
return _rmdir( path ) == 0;
|
|
}
|
|
|
|
/*
|
|
==============
|
|
Sys_EXEPath
|
|
==============
|
|
*/
|
|
const char* Sys_EXEPath()
|
|
{
|
|
static char exe[MAX_OSPATH];
|
|
GetModuleFileName( NULL, exe, sizeof( exe ) - 1 );
|
|
return exe;
|
|
}
|
|
|
|
/*
|
|
==============
|
|
Sys_ListFiles
|
|
==============
|
|
*/
|
|
int Sys_ListFiles( const char* directory, const char* extension, idStrList& list )
|
|
{
|
|
idStr search;
|
|
struct _finddata_t findinfo;
|
|
// RB: 64 bit fixes, changed int to intptr_t
|
|
intptr_t findhandle;
|
|
// RB end
|
|
int flag;
|
|
|
|
if( !extension )
|
|
{
|
|
extension = "";
|
|
}
|
|
|
|
// passing a slash as extension will find directories
|
|
if( extension[0] == '/' && extension[1] == 0 )
|
|
{
|
|
extension = "";
|
|
flag = 0;
|
|
}
|
|
else
|
|
{
|
|
flag = _A_SUBDIR;
|
|
}
|
|
|
|
sprintf( search, "%s\\*%s", directory, extension );
|
|
|
|
// search
|
|
list.Clear();
|
|
|
|
findhandle = _findfirst( search, &findinfo );
|
|
if( findhandle == -1 )
|
|
{
|
|
return -1;
|
|
}
|
|
|
|
do
|
|
{
|
|
if( flag ^ ( findinfo.attrib & _A_SUBDIR ) )
|
|
{
|
|
list.Append( findinfo.name );
|
|
}
|
|
}
|
|
while( _findnext( findhandle, &findinfo ) != -1 );
|
|
|
|
_findclose( findhandle );
|
|
|
|
return list.Num();
|
|
}
|
|
|
|
|
|
|
|
int idEventLoop::JournalLevel() const
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
========================
|
|
Sys_IsFolder
|
|
========================
|
|
*/
|
|
sysFolder_t Sys_IsFolder( const char* path )
|
|
{
|
|
struct _stat buffer;
|
|
if( _stat( path, &buffer ) < 0 )
|
|
{
|
|
return FOLDER_ERROR;
|
|
}
|
|
return ( buffer.st_mode & _S_IFDIR ) != 0 ? FOLDER_YES : FOLDER_NO;
|
|
}
|
|
|
|
const char* Sys_DefaultSavePath()
|
|
{
|
|
return "";
|
|
}
|
|
|
|
const char* Sys_Lang( int )
|
|
{
|
|
return "";
|
|
}
|
|
|
|
|
|
/*
|
|
=================
|
|
Sys_FileTimeStamp
|
|
=================
|
|
*/
|
|
ID_TIME_T Sys_FileTimeStamp( idFileHandle fp )
|
|
{
|
|
FILETIME writeTime;
|
|
GetFileTime( fp, NULL, NULL, &writeTime );
|
|
|
|
/*
|
|
FILETIME = number of 100-nanosecond ticks since midnight
|
|
1 Jan 1601 UTC. time_t = number of 1-second ticks since
|
|
midnight 1 Jan 1970 UTC. To translate, we subtract a
|
|
FILETIME representation of midnight, 1 Jan 1970 from the
|
|
time in question and divide by the number of 100-ns ticks
|
|
in one second.
|
|
*/
|
|
|
|
SYSTEMTIME base_st =
|
|
{
|
|
1970, // wYear
|
|
1, // wMonth
|
|
0, // wDayOfWeek
|
|
1, // wDay
|
|
0, // wHour
|
|
0, // wMinute
|
|
0, // wSecond
|
|
0 // wMilliseconds
|
|
};
|
|
|
|
FILETIME base_ft;
|
|
SystemTimeToFileTime( &base_st, &base_ft );
|
|
|
|
LARGE_INTEGER itime;
|
|
itime.QuadPart = reinterpret_cast<LARGE_INTEGER&>( writeTime ).QuadPart;
|
|
itime.QuadPart -= reinterpret_cast<LARGE_INTEGER&>( base_ft ).QuadPart;
|
|
itime.QuadPart /= 10000000LL;
|
|
return itime.QuadPart;
|
|
}
|
|
|
|
/*
|
|
================
|
|
Sys_GetClockTicks
|
|
================
|
|
*/
|
|
double Sys_GetClockTicks()
|
|
{
|
|
LARGE_INTEGER li;
|
|
|
|
QueryPerformanceCounter( &li );
|
|
return ( double ) li.LowPart + ( double ) 0xFFFFFFFF * li.HighPart;
|
|
}
|
|
|
|
/*
|
|
================
|
|
Sys_ClockTicksPerSecond
|
|
================
|
|
*/
|
|
double Sys_ClockTicksPerSecond()
|
|
{
|
|
static double ticks = 0;
|
|
|
|
if( !ticks )
|
|
{
|
|
LARGE_INTEGER li;
|
|
QueryPerformanceFrequency( &li );
|
|
ticks = li.QuadPart;
|
|
}
|
|
|
|
return ticks;
|
|
}
|
|
|
|
/*
|
|
==============
|
|
Sys_Cwd
|
|
==============
|
|
*/
|
|
const char* Sys_Cwd()
|
|
{
|
|
static char cwd[MAX_OSPATH];
|
|
|
|
_getcwd( cwd, sizeof( cwd ) - 1 );
|
|
cwd[MAX_OSPATH - 1] = 0;
|
|
|
|
return cwd;
|
|
}
|
|
|
|
/*
|
|
==============
|
|
Sys_DefaultBasePath
|
|
==============
|
|
*/
|
|
const char* Sys_DefaultBasePath()
|
|
{
|
|
return Sys_Cwd();
|
|
}
|
|
|
|
int Sys_NumLangs()
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
================
|
|
Sys_Milliseconds
|
|
================
|
|
*/
|
|
int Sys_Milliseconds()
|
|
{
|
|
static DWORD sys_timeBase = timeGetTime();
|
|
return timeGetTime() - sys_timeBase;
|
|
}
|
|
|
|
class idSysCmdline : public idSys
|
|
{
|
|
public:
|
|
virtual void DebugPrintf( VERIFY_FORMAT_STRING const char* fmt, ... )
|
|
{
|
|
va_list argptr;
|
|
|
|
va_start( argptr, fmt );
|
|
Sys_VPrintf( fmt, argptr );
|
|
va_end( argptr );
|
|
}
|
|
|
|
virtual void DebugVPrintf( const char* fmt, va_list arg )
|
|
{
|
|
Sys_VPrintf( fmt, arg );
|
|
}
|
|
|
|
virtual double GetClockTicks()
|
|
{
|
|
return Sys_GetClockTicks();
|
|
}
|
|
|
|
virtual double ClockTicksPerSecond()
|
|
{
|
|
return Sys_ClockTicksPerSecond();
|
|
}
|
|
|
|
virtual cpuid_t GetProcessorId()
|
|
{
|
|
return CPUID_NONE;
|
|
}
|
|
|
|
virtual const char* GetProcessorString()
|
|
{
|
|
return NULL;
|
|
}
|
|
virtual const char* FPU_GetState()
|
|
{
|
|
return NULL;
|
|
}
|
|
virtual bool FPU_StackIsEmpty()
|
|
{
|
|
return false;
|
|
}
|
|
virtual void FPU_SetFTZ( bool enable ) {}
|
|
virtual void FPU_SetDAZ( bool enable ) {}
|
|
|
|
virtual void FPU_EnableExceptions( int exceptions ) {}
|
|
|
|
virtual bool LockMemory( void* ptr, int bytes )
|
|
{
|
|
return false;
|
|
}
|
|
virtual bool UnlockMemory( void* ptr, int bytes )
|
|
{
|
|
return false;
|
|
}
|
|
|
|
virtual int DLL_Load( const char* dllName )
|
|
{
|
|
return 0;
|
|
}
|
|
virtual void* DLL_GetProcAddress( int dllHandle, const char* procName )
|
|
{
|
|
return NULL;
|
|
}
|
|
virtual void DLL_Unload( int dllHandle ) {}
|
|
virtual void DLL_GetFileName( const char* baseName, char* dllName, int maxLength ) {}
|
|
|
|
virtual sysEvent_t GenerateMouseButtonEvent( int button, bool down )
|
|
{
|
|
sysEvent_t ev;
|
|
ev.evType = SE_NONE;
|
|
return ev;
|
|
}
|
|
virtual sysEvent_t GenerateMouseMoveEvent( int deltax, int deltay )
|
|
{
|
|
sysEvent_t ev;
|
|
ev.evType = SE_NONE;
|
|
return ev;
|
|
}
|
|
|
|
virtual void OpenURL( const char* url, bool quit ) {}
|
|
virtual void StartProcess( const char* exeName, bool quit ) {}
|
|
};
|
|
|
|
idSysCmdline idSysLocal;
|
|
idSys* sys = &idSysLocal;
|
|
|
|
/*
|
|
==============================================================
|
|
|
|
idCommon
|
|
|
|
==============================================================
|
|
*/
|
|
|
|
namespace UI
|
|
{
|
|
|
|
enum class ColorScheme : int
|
|
{
|
|
Default,
|
|
Dark,
|
|
Green,
|
|
COUNT,
|
|
};
|
|
|
|
struct State
|
|
{
|
|
int hoveredWindowId = 0;
|
|
int statusWindowHeight = 4;
|
|
|
|
ColorScheme colorScheme = ColorScheme::Dark;
|
|
|
|
bool showHelpWelcome = false;
|
|
bool showHelpModal = false;
|
|
bool showStatusWindow = true;
|
|
|
|
#define STATUS_TEXT_SIZE 512
|
|
idStrStatic<STATUS_TEXT_SIZE> statusWindowHeader = "Initializing Doom Framework";
|
|
idStrStatic<STATUS_TEXT_SIZE> statusActiveTool = "-";
|
|
|
|
float progress = 1.0f;
|
|
|
|
void ChangeColorScheme( bool inc = true )
|
|
{
|
|
if( inc )
|
|
{
|
|
colorScheme = ( ColorScheme )( ( ( int ) colorScheme + 1 ) % ( ( int )ColorScheme::COUNT ) );
|
|
}
|
|
|
|
ImVec4* colors = ImGui::GetStyle().Colors;
|
|
switch( colorScheme )
|
|
{
|
|
case ColorScheme::Default:
|
|
{
|
|
colors[ImGuiCol_Text] = ImVec4( 0.00f, 0.00f, 0.00f, 1.00f );
|
|
colors[ImGuiCol_TextDisabled] = ImVec4( 0.60f, 0.60f, 0.60f, 1.00f );
|
|
colors[ImGuiCol_WindowBg] = ImVec4( 0.96f, 0.96f, 0.94f, 1.00f );
|
|
colors[ImGuiCol_TitleBg] = ImVec4( 1.00f, 0.40f, 0.00f, 1.00f );
|
|
colors[ImGuiCol_TitleBgActive] = ImVec4( 1.00f, 0.40f, 0.00f, 1.00f );
|
|
colors[ImGuiCol_TitleBgCollapsed] = ImVec4( 0.69f, 0.25f, 0.00f, 1.00f );
|
|
colors[ImGuiCol_ChildBg] = ImVec4( 0.96f, 0.96f, 0.94f, 1.00f );
|
|
colors[ImGuiCol_PopupBg] = ImVec4( 0.96f, 0.96f, 0.94f, 1.00f );
|
|
colors[ImGuiCol_ModalWindowDimBg] = ImVec4( 0.00f, 0.00f, 0.00f, 0.00f );
|
|
break;
|
|
}
|
|
|
|
case ColorScheme::Dark:
|
|
{
|
|
colors[ImGuiCol_Text] = ImVec4( 1.00f, 1.00f, 1.00f, 1.00f );
|
|
colors[ImGuiCol_TextDisabled] = ImVec4( 0.60f, 0.60f, 0.60f, 1.00f );
|
|
colors[ImGuiCol_WindowBg] = ImVec4( 0.10f, 0.10f, 0.10f, 1.00f );
|
|
colors[ImGuiCol_TitleBg] = ImVec4( 1.00f, 0.40f, 0.00f, 0.50f );
|
|
colors[ImGuiCol_TitleBgActive] = ImVec4( 1.00f, 0.40f, 0.00f, 0.50f );
|
|
colors[ImGuiCol_TitleBgCollapsed] = ImVec4( 0.69f, 0.25f, 0.00f, 0.50f );
|
|
colors[ImGuiCol_ChildBg] = ImVec4( 0.10f, 0.10f, 0.10f, 1.00f );
|
|
colors[ImGuiCol_PopupBg] = ImVec4( 0.20f, 0.20f, 0.20f, 1.00f );
|
|
colors[ImGuiCol_ModalWindowDimBg] = ImVec4( 0.00f, 0.00f, 0.00f, 0.00f );
|
|
break;
|
|
}
|
|
|
|
case ColorScheme::Green:
|
|
{
|
|
colors[ImGuiCol_Text] = ImVec4( 0.00f, 1.00f, 0.00f, 1.00f );
|
|
colors[ImGuiCol_TextDisabled] = ImVec4( 0.60f, 0.60f, 0.60f, 1.00f );
|
|
colors[ImGuiCol_WindowBg] = ImVec4( 0.10f, 0.10f, 0.10f, 1.00f );
|
|
colors[ImGuiCol_TitleBg] = ImVec4( 0.25f, 0.25f, 0.25f, 1.00f );
|
|
colors[ImGuiCol_TitleBgActive] = ImVec4( 0.25f, 0.25f, 0.25f, 1.00f );
|
|
colors[ImGuiCol_TitleBgCollapsed] = ImVec4( 0.50f, 1.00f, 0.50f, 1.00f );
|
|
colors[ImGuiCol_ChildBg] = ImVec4( 0.10f, 0.10f, 0.10f, 1.00f );
|
|
colors[ImGuiCol_PopupBg] = ImVec4( 0.00f, 0.00f, 0.00f, 1.00f );
|
|
colors[ImGuiCol_ModalWindowDimBg] = ImVec4( 0.00f, 0.00f, 0.00f, 0.00f );
|
|
break;
|
|
}
|
|
|
|
default:
|
|
{
|
|
}
|
|
}
|
|
}
|
|
};
|
|
|
|
}
|
|
|
|
// UI state
|
|
UI::State stateUI;
|
|
|
|
class idCommonLocal : public idCommon
|
|
{
|
|
private:
|
|
int count = 0;
|
|
int expectedCount = 0;
|
|
size_t tics = 0;
|
|
size_t nextTicCount = 0;
|
|
|
|
public:
|
|
bool com_refreshOnPrint = true; // update the screen every print for dmap
|
|
ImTui::TScreen* screen;
|
|
|
|
|
|
// Initialize everything.
|
|
// if the OS allows, pass argc/argv directly (without executable name)
|
|
// otherwise pass the command line in a single string (without executable name)
|
|
virtual void Init( int argc, const char* const* argv, const char* cmdline ) {}
|
|
|
|
// Shuts down everything.
|
|
virtual void Shutdown() {}
|
|
virtual bool IsShuttingDown() const
|
|
{
|
|
return false;
|
|
};
|
|
|
|
virtual void CreateMainMenu() {}
|
|
|
|
// Shuts down everything.
|
|
virtual void Quit() {}
|
|
|
|
// Returns true if common initialization is complete.
|
|
virtual bool IsInitialized() const
|
|
{
|
|
return true;
|
|
};
|
|
|
|
// Called repeatedly as the foreground thread for rendering and game logic.
|
|
virtual void Frame() {}
|
|
|
|
// Redraws the screen, handling games, guis, console, etc
|
|
// in a modal manner outside the normal frame loop
|
|
virtual void UpdateScreen( bool captureToImage, bool releaseMouse = true );
|
|
|
|
virtual void UpdateLevelLoadPacifier() {}
|
|
virtual void LoadPacifierInfo( VERIFY_FORMAT_STRING const char* fmt, ... ) {}
|
|
virtual void LoadPacifierProgressTotal( int total ) {}
|
|
virtual void LoadPacifierProgressIncrement( int step ) {}
|
|
virtual bool LoadPacifierRunning()
|
|
{
|
|
return false;
|
|
}
|
|
|
|
|
|
// Checks for and removes command line "+set var arg" constructs.
|
|
// If match is NULL, all set commands will be executed, otherwise
|
|
// only a set with the exact name.
|
|
virtual void StartupVariable( const char* match ) {}
|
|
|
|
// Begins redirection of console output to the given buffer.
|
|
virtual void BeginRedirect( char* buffer, int buffersize, void ( *flush )( const char* ) ) {}
|
|
|
|
// Stops redirection of console output.
|
|
virtual void EndRedirect() {}
|
|
|
|
// Update the screen with every message printed.
|
|
virtual void SetRefreshOnPrint( bool set )
|
|
{
|
|
//com_refreshOnPrint = set;
|
|
}
|
|
|
|
virtual void Printf( const char* fmt, ... )
|
|
{
|
|
STDIO_PRINT( "", "" );
|
|
|
|
if( com_refreshOnPrint )
|
|
{
|
|
common->UpdateScreen( false );
|
|
}
|
|
}
|
|
|
|
virtual void VPrintf( const char* fmt, va_list arg )
|
|
{
|
|
Sys_VPrintf( fmt, arg );
|
|
|
|
if( com_refreshOnPrint )
|
|
{
|
|
common->UpdateScreen( false );
|
|
}
|
|
}
|
|
|
|
virtual void DPrintf( const char* fmt, ... )
|
|
{
|
|
if( com_developer.GetBool() )
|
|
{
|
|
STDIO_PRINT( "", "" );
|
|
|
|
if( com_refreshOnPrint )
|
|
{
|
|
common->UpdateScreen( false );
|
|
}
|
|
}
|
|
}
|
|
|
|
virtual void VerbosePrintf( const char* fmt, ... )
|
|
{
|
|
if( dmap_verbose.GetBool() )
|
|
{
|
|
STDIO_PRINT( "", "" );
|
|
|
|
if( com_refreshOnPrint )
|
|
{
|
|
common->UpdateScreen( false );
|
|
}
|
|
}
|
|
}
|
|
|
|
virtual void Warning( const char* fmt, ... )
|
|
{
|
|
STDIO_PRINT( "WARNING: ", "\n" );
|
|
|
|
if( com_refreshOnPrint )
|
|
{
|
|
common->UpdateScreen( false );
|
|
}
|
|
}
|
|
|
|
virtual void DWarning( const char* fmt, ... )
|
|
{
|
|
if( com_developer.GetBool() )
|
|
{
|
|
STDIO_PRINT( "WARNING: ", "\n" );
|
|
|
|
if( com_refreshOnPrint )
|
|
{
|
|
common->UpdateScreen( false );
|
|
}
|
|
}
|
|
}
|
|
|
|
// Prints all queued warnings.
|
|
virtual void PrintWarnings() {}
|
|
|
|
// Removes all queued warnings.
|
|
virtual void ClearWarnings( const char* reason ) {}
|
|
|
|
virtual void Error( const char* fmt, ... )
|
|
{
|
|
STDIO_PRINT( "ERROR: ", "\n" );
|
|
|
|
if( com_refreshOnPrint )
|
|
{
|
|
common->UpdateScreen( false );
|
|
}
|
|
exit( 0 );
|
|
}
|
|
virtual void FatalError( const char* fmt, ... )
|
|
{
|
|
STDIO_PRINT( "FATAL ERROR: ", "\n" );
|
|
|
|
if( com_refreshOnPrint )
|
|
{
|
|
common->UpdateScreen( false );
|
|
}
|
|
exit( 0 );
|
|
}
|
|
|
|
// Returns key bound to the command
|
|
virtual const char* KeysFromBinding( const char* bind )
|
|
{
|
|
return NULL;
|
|
};
|
|
|
|
// Returns the binding bound to the key
|
|
virtual const char* BindingFromKey( const char* key )
|
|
{
|
|
return NULL;
|
|
};
|
|
|
|
// Directly sample a button.
|
|
virtual int ButtonState( int key )
|
|
{
|
|
return 0;
|
|
};
|
|
|
|
// Directly sample a keystate.
|
|
virtual int KeyState( int key )
|
|
{
|
|
return 0;
|
|
};
|
|
|
|
// Returns true if a multiplayer game is running.
|
|
// CVars and commands are checked differently in multiplayer mode.
|
|
virtual bool IsMultiplayer()
|
|
{
|
|
return false;
|
|
};
|
|
virtual bool IsServer()
|
|
{
|
|
return false;
|
|
};
|
|
virtual bool IsClient()
|
|
{
|
|
return false;
|
|
};
|
|
|
|
// Returns true if the player has ever enabled the console
|
|
virtual bool GetConsoleUsed()
|
|
{
|
|
return false;
|
|
};
|
|
|
|
// Returns the rate (in ms between snaps) that we want to generate snapshots
|
|
virtual int GetSnapRate()
|
|
{
|
|
return 0;
|
|
};
|
|
|
|
virtual void NetReceiveReliable( int peer, int type, idBitMsg& msg ) { };
|
|
virtual void NetReceiveSnapshot( class idSnapShot& ss ) { };
|
|
virtual void NetReceiveUsercmds( int peer, idBitMsg& msg ) { };
|
|
|
|
// Processes the given event.
|
|
virtual bool ProcessEvent( const sysEvent_t* event )
|
|
{
|
|
return false;
|
|
};
|
|
|
|
virtual bool LoadGame( const char* saveName )
|
|
{
|
|
return false;
|
|
};
|
|
virtual bool SaveGame( const char* saveName )
|
|
{
|
|
return false;
|
|
};
|
|
|
|
virtual idGame* Game()
|
|
{
|
|
return NULL;
|
|
};
|
|
virtual idRenderWorld* RW()
|
|
{
|
|
return NULL;
|
|
};
|
|
virtual idSoundWorld* SW()
|
|
{
|
|
return NULL;
|
|
};
|
|
virtual idSoundWorld* MenuSW()
|
|
{
|
|
return NULL;
|
|
};
|
|
virtual idSession* Session()
|
|
{
|
|
return NULL;
|
|
};
|
|
virtual idCommonDialog& Dialog()
|
|
{
|
|
static idCommonDialog useless;
|
|
return useless;
|
|
};
|
|
|
|
virtual void OnSaveCompleted( idSaveLoadParms& parms ) {}
|
|
virtual void OnLoadCompleted( idSaveLoadParms& parms ) {}
|
|
virtual void OnLoadFilesCompleted( idSaveLoadParms& parms ) {}
|
|
virtual void OnEnumerationCompleted( idSaveLoadParms& parms ) {}
|
|
virtual void OnDeleteCompleted( idSaveLoadParms& parms ) {}
|
|
virtual void TriggerScreenWipe( const char* _wipeMaterial, bool hold ) {}
|
|
|
|
virtual void OnStartHosting( idMatchParameters& parms ) {}
|
|
|
|
virtual int GetGameFrame()
|
|
{
|
|
return 0;
|
|
};
|
|
|
|
virtual void LaunchExternalTitle( int titleIndex, int device, const lobbyConnectInfo_t* const connectInfo ) { };
|
|
|
|
virtual void InitializeMPMapsModes() { };
|
|
virtual const idStrList& GetModeList() const
|
|
{
|
|
static idStrList useless;
|
|
return useless;
|
|
};
|
|
virtual const idStrList& GetModeDisplayList() const
|
|
{
|
|
static idStrList useless;
|
|
return useless;
|
|
};
|
|
virtual const idList<mpMap_t>& GetMapList() const
|
|
{
|
|
static idList<mpMap_t> useless;
|
|
return useless;
|
|
};
|
|
|
|
virtual void ResetPlayerInput( int playerIndex ) {}
|
|
|
|
virtual bool JapaneseCensorship() const
|
|
{
|
|
return false;
|
|
};
|
|
|
|
virtual void QueueShowShell() { }; // Will activate the shell on the next frame.
|
|
virtual void InitTool( const toolFlag_t, const idDict*, idEntity* ) {}
|
|
|
|
virtual void LoadPacifierBinarizeFilename( const char* filename, const char* reason ) {}
|
|
virtual void LoadPacifierBinarizeInfo( const char* info ) {}
|
|
virtual void LoadPacifierBinarizeMiplevel( int level, int maxLevel ) {}
|
|
virtual void LoadPacifierBinarizeProgress( float progress ) {}
|
|
virtual void LoadPacifierBinarizeEnd() { };
|
|
virtual void LoadPacifierBinarizeProgressTotal( int total ) {}
|
|
virtual void LoadPacifierBinarizeProgressIncrement( int step ) {}
|
|
|
|
virtual void DmapPacifierFilename( const char* filename, const char* reason )
|
|
{
|
|
stateUI.statusWindowHeader.Format( "%s | %s", filename, reason );
|
|
}
|
|
|
|
virtual void DmapPacifierInfo( VERIFY_FORMAT_STRING const char* fmt, ... )
|
|
{
|
|
char msg[STATUS_TEXT_SIZE];
|
|
|
|
va_list argptr;
|
|
va_start( argptr, fmt );
|
|
idStr::vsnPrintf( msg, STATUS_TEXT_SIZE - 1, fmt, argptr );
|
|
msg[ sizeof( msg ) - 1 ] = '\0';
|
|
va_end( argptr );
|
|
|
|
stateUI.statusActiveTool = msg;
|
|
|
|
if( com_refreshOnPrint )
|
|
{
|
|
UpdateScreen( false );
|
|
}
|
|
}
|
|
|
|
virtual void DmapPacifierCompileProgressTotal( int total )
|
|
{
|
|
count = 0;
|
|
expectedCount = total;
|
|
tics = 0;
|
|
nextTicCount = 0;
|
|
|
|
stateUI.progress = 0;
|
|
}
|
|
|
|
virtual void DmapPacifierCompileProgressIncrement( int step )
|
|
{
|
|
count += step;
|
|
|
|
stateUI.progress = float( count ) / expectedCount;
|
|
|
|
// don't refresh the UI with every step if there are e.g. 1300 steps
|
|
if( ( count + 1 ) >= nextTicCount )
|
|
{
|
|
size_t ticsNeeded = ( size_t )( ( ( double )( count + 1 ) / expectedCount ) * 50.0 );
|
|
|
|
do
|
|
{
|
|
//common->Printf( "*" );
|
|
}
|
|
while( ++tics < ticsNeeded );
|
|
|
|
nextTicCount = ( size_t )( ( tics / 50.0 ) * expectedCount );
|
|
/*
|
|
if( count == ( expectedCount - 1 ) )
|
|
{
|
|
//if( tics < 51 )
|
|
//{
|
|
// common->Printf( "*" );
|
|
//}
|
|
//common->Printf( "\n" );
|
|
|
|
//stateUI.progress = 1;
|
|
}
|
|
*/
|
|
|
|
if( com_refreshOnPrint )
|
|
{
|
|
common->UpdateScreen( false );
|
|
}
|
|
}
|
|
}
|
|
};
|
|
|
|
idCommonLocal commonLocal;
|
|
idCommon* common = &commonLocal;
|
|
|
|
int com_editors = 0;
|
|
|
|
/*
|
|
==============================================================
|
|
|
|
main
|
|
|
|
==============================================================
|
|
*/
|
|
|
|
int Dmap_NoGui( int argc, char** argv )
|
|
{
|
|
commonLocal.com_refreshOnPrint = false;
|
|
|
|
idLib::common = common;
|
|
idLib::cvarSystem = cvarSystem;
|
|
idLib::fileSystem = fileSystem;
|
|
idLib::sys = sys;
|
|
|
|
idLib::Init();
|
|
cmdSystem->Init();
|
|
cvarSystem->Init();
|
|
idCVar::RegisterStaticVars();
|
|
|
|
// set cvars before filesystem init to use mod paths
|
|
idCmdArgs args;
|
|
for( int i = 0; i < argc; i++ )
|
|
{
|
|
if( idStr::Icmp( argv[ i ], "+set" ) == 0 )
|
|
{
|
|
if( ( i + 2 ) < argc )
|
|
{
|
|
cvarSystem->SetCVarString( argv[ i + 1 ], argv[ i + 2 ] );
|
|
}
|
|
|
|
i += 2;
|
|
}
|
|
else if( idStr::Icmp( argv[ i ], "-t" ) == 0 || idStr::Icmp( argv[ i ], "-nogui" ) == 0 )
|
|
{
|
|
}
|
|
else
|
|
{
|
|
args.AppendArg( argv[i] );
|
|
}
|
|
}
|
|
|
|
fileSystem->Init();
|
|
declManager->InitTool();
|
|
|
|
Dmap_f( args );
|
|
|
|
return 0;
|
|
}
|
|
|
|
#if 0
|
|
|
|
void idCommonLocal::UpdateScreen( bool captureToImage, bool releaseMouse )
|
|
{
|
|
}
|
|
|
|
int main( int argc, char** argv )
|
|
{
|
|
return Dmap_NoGui( argc, argv );
|
|
}
|
|
|
|
#elif 1
|
|
|
|
|
|
void idCommonLocal::UpdateScreen( bool captureToImage, bool releaseMouse )
|
|
{
|
|
bool demo = true;
|
|
bool conOpen = true;
|
|
|
|
ImTui_ImplNcurses_NewFrame();
|
|
ImTui_ImplText_NewFrame();
|
|
|
|
ImGui::NewFrame();
|
|
|
|
{
|
|
auto wSize = ImGui::GetIO().DisplaySize;
|
|
if( stateUI.showStatusWindow )
|
|
{
|
|
wSize.y -= stateUI.statusWindowHeight;
|
|
}
|
|
wSize.x = int( wSize.x );
|
|
ImGui::SetNextWindowPos( ImVec2( 0, 0 ), ImGuiCond_Always );
|
|
|
|
ImGui::SetNextWindowSize( wSize, ImGuiCond_Always );
|
|
}
|
|
|
|
//idStr title = va( "RBDMAP version %s %s", ENGINE_VERSION, BUILD_STRING );
|
|
idStr title = va( "RBDMAP version %s %s %s %s", ENGINE_VERSION, BUILD_STRING, __DATE__, __TIME__ );
|
|
ImGui::Begin( title.c_str(), nullptr,
|
|
ImGuiWindowFlags_NoCollapse |
|
|
ImGuiWindowFlags_NoResize |
|
|
ImGuiWindowFlags_NoMove |
|
|
ImGuiWindowFlags_NoScrollbar );
|
|
|
|
tuiLog.Draw( "Current Log:", &conOpen );
|
|
|
|
//ShowExampleAppConsole( &conOpen );
|
|
|
|
//ImTui::ShowDemoWindow( &demo );
|
|
|
|
ImGui::End();
|
|
|
|
{
|
|
auto wSize = ImGui::GetIO().DisplaySize;
|
|
ImGui::SetNextWindowPos( ImVec2( 0, wSize.y - stateUI.statusWindowHeight ), ImGuiCond_Always );
|
|
ImGui::SetNextWindowSize( ImVec2( wSize.x, stateUI.statusWindowHeight ), ImGuiCond_Always );
|
|
}
|
|
|
|
ImGui::Begin( stateUI.statusWindowHeader, nullptr,
|
|
ImGuiWindowFlags_NoCollapse |
|
|
ImGuiWindowFlags_NoResize |
|
|
ImGuiWindowFlags_NoMove );
|
|
|
|
auto wSize = ImGui::GetIO().DisplaySize;
|
|
if( stateUI.progress < 1.0f )
|
|
{
|
|
ImGui::ProgressBar( stateUI.progress, ImVec2( wSize.x, 0.0f ) );
|
|
}
|
|
else
|
|
{
|
|
ImGui::Text( " " );
|
|
}
|
|
|
|
ImGui::Text( " %s", stateUI.statusActiveTool.c_str() );
|
|
ImGui::Text( " Source code : https://github.com/RobertBeckebans/RBDOOM-3-BFG" );
|
|
ImGui::End();
|
|
|
|
ImGui::Render();
|
|
|
|
ImTui_ImplText_RenderDrawData( ImGui::GetDrawData(), screen );
|
|
ImTui_ImplNcurses_DrawScreen();
|
|
}
|
|
|
|
int main( int argc, char** argv )
|
|
{
|
|
for( int i = 0; i < argc; i++ )
|
|
{
|
|
if( idStr::Icmp( argv[ i ], "-t" ) == 0 || idStr::Icmp( argv[ i ], "-nogui" ) == 0 )
|
|
{
|
|
return Dmap_NoGui( argc, argv );
|
|
}
|
|
}
|
|
|
|
IMGUI_CHECKVERSION();
|
|
ImGui::CreateContext();
|
|
|
|
commonLocal.screen = ImTui_ImplNcurses_Init( true );
|
|
ImTui_ImplText_Init();
|
|
|
|
stateUI.ChangeColorScheme( false );
|
|
|
|
idLib::common = common;
|
|
idLib::cvarSystem = cvarSystem;
|
|
idLib::fileSystem = fileSystem;
|
|
idLib::sys = sys;
|
|
|
|
idLib::Init();
|
|
cmdSystem->Init();
|
|
cvarSystem->Init();
|
|
idCVar::RegisterStaticVars();
|
|
|
|
// set cvars before filesystem init to use mod paths
|
|
idCmdArgs args;
|
|
for( int i = 0; i < argc; i++ )
|
|
{
|
|
if( idStr::Icmp( argv[ i ], "+set" ) == 0 )
|
|
{
|
|
if( ( i + 2 ) < argc )
|
|
{
|
|
cvarSystem->SetCVarString( argv[ i + 1 ], argv[ i + 2 ] );
|
|
}
|
|
|
|
i += 2;
|
|
}
|
|
else if( idStr::Icmp( argv[ i ], "-t" ) == 0 || idStr::Icmp( argv[ i ], "-nogui" ) == 0 )
|
|
{
|
|
}
|
|
else
|
|
{
|
|
args.AppendArg( argv[i] );
|
|
}
|
|
}
|
|
|
|
fileSystem->Init();
|
|
declManager->InitTool();
|
|
|
|
Dmap_f( args );
|
|
|
|
#if 0
|
|
while( true )
|
|
{
|
|
bool captureToImage = false;
|
|
common->UpdateScreen( captureToImage );
|
|
}
|
|
#endif
|
|
|
|
ImTui_ImplText_Shutdown();
|
|
ImTui_ImplNcurses_Shutdown();
|
|
|
|
return 0;
|
|
}
|
|
#else
|
|
|
|
#include "imtui/imtui.h"
|
|
#include "imtui/imtui-impl-ncurses.h"
|
|
#include "imtui/imtui-demo.h"
|
|
|
|
void idCommonLocal::UpdateScreen( bool captureToImage, bool releaseMouse )
|
|
{
|
|
}
|
|
|
|
int main()
|
|
{
|
|
IMGUI_CHECKVERSION();
|
|
ImGui::CreateContext();
|
|
|
|
auto screen = ImTui_ImplNcurses_Init( true );
|
|
ImTui_ImplText_Init();
|
|
|
|
stateUI.ChangeColorScheme( false );
|
|
|
|
bool demo = true;
|
|
int nframes = 0;
|
|
float fval = 1.23f;
|
|
|
|
while( true )
|
|
{
|
|
ImTui_ImplNcurses_NewFrame();
|
|
ImTui_ImplText_NewFrame();
|
|
|
|
ImGui::NewFrame();
|
|
|
|
ImGui::SetNextWindowPos( ImVec2( 4, 27 ), ImGuiCond_Once );
|
|
ImGui::SetNextWindowSize( ImVec2( 50.0, 10.0 ), ImGuiCond_Once );
|
|
ImGui::Begin( "Hello, world!" );
|
|
ImGui::Text( "NFrames = %d", nframes++ );
|
|
ImGui::Text( "Mouse Pos : x = %g, y = %g", ImGui::GetIO().MousePos.x, ImGui::GetIO().MousePos.y );
|
|
ImGui::Text( "Time per frame %.3f ms/frame (%.1f FPS)", 1000.0f / ImGui::GetIO().Framerate, ImGui::GetIO().Framerate );
|
|
ImGui::Text( "Float:" );
|
|
ImGui::SameLine();
|
|
ImGui::SliderFloat( "##float", &fval, 0.0f, 10.0f );
|
|
|
|
#ifndef __EMSCRIPTEN__
|
|
ImGui::Text( "%s", "" );
|
|
if( ImGui::Button( "Exit program", { ImGui::GetContentRegionAvail().x, 2 } ) )
|
|
{
|
|
break;
|
|
}
|
|
#endif
|
|
|
|
ImGui::End();
|
|
|
|
ImTui::ShowDemoWindow( &demo );
|
|
|
|
ImGui::Render();
|
|
|
|
ImTui_ImplText_RenderDrawData( ImGui::GetDrawData(), screen );
|
|
ImTui_ImplNcurses_DrawScreen();
|
|
}
|
|
|
|
ImTui_ImplText_Shutdown();
|
|
ImTui_ImplNcurses_Shutdown();
|
|
|
|
return 0;
|
|
}
|
|
|
|
#endif
|