603 lines
16 KiB
C++
603 lines
16 KiB
C++
/*
|
|
Copyright 2015 by Joseph Forgione
|
|
This file is part of VCC (Virtual Color Computer).
|
|
|
|
VCC (Virtual Color Computer) 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.
|
|
|
|
VCC (Virtual Color Computer) 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 VCC (Virtual Color Computer). If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
#ifdef _LEGACY_VCC
|
|
#pragma warning( disable : 4800 )
|
|
#endif
|
|
|
|
#define NO_WARN_MBCS_MFC_DEPRECATION
|
|
#define _WIN32_WINNT 0x05010000 // I want to support XP
|
|
|
|
#include "../../src/core/BuildConfig.h"
|
|
#include <vcc/bus/proxy_msgwin.h>
|
|
#include <vcc/util/limits.h>
|
|
#include <vcc/util/logger.h>
|
|
#include <Windows.h>
|
|
#include <CommCtrl.h> // Windows common controls
|
|
#include "defines.h"
|
|
#include "stdio.h"
|
|
#include "DirectDrawInterface.h"
|
|
#include "resource.h"
|
|
#include "../../src/core/tcc1014graphics.h"
|
|
#include "throttle.h"
|
|
#include "config.h"
|
|
#include <iostream>
|
|
#include <string>
|
|
#include "../../src/core/IDisplay.h"
|
|
#include "Screenshot.h"
|
|
|
|
#include "OpenGL.h"
|
|
#include "OpenGLFontConsola.h"
|
|
#include "DirectX.h"
|
|
#include "../../src/core/DisplayNull.h"
|
|
#include "../../src/core/DisplayNone.h"
|
|
|
|
#if USE_DEBUG_AUDIOTAPE
|
|
#include "../../src/core/IDisplayDebug.h"
|
|
#endif // USE_DEBUG_AUDIOTAPE
|
|
|
|
using namespace VCC; // after all includes
|
|
|
|
static IDisplay* g_Display = nullptr;
|
|
static ISystemState* g_SystemState = nullptr;
|
|
|
|
static IDisplayDirectX* g_DirectXDisplay = nullptr;
|
|
static IDisplayOpenGL* g_OpenGLDisplay = nullptr;
|
|
static const OpenGLFont* g_DisplayFont = nullptr;
|
|
|
|
#if USE_OPENGL
|
|
using ClassOpenGL = OpenGL;
|
|
#else
|
|
using ClassOpenGL = DisplayNull;
|
|
#endif
|
|
|
|
#if USE_DIRECTX
|
|
using ClassDirectX = DirectX;
|
|
#else
|
|
using ClassDirectX = DisplayNull;
|
|
#endif
|
|
|
|
static HWND hwndStatusBar=nullptr;
|
|
static unsigned int StatusBarHeight=0;
|
|
static TCHAR szTitle[MAX_LOADSTRING]; // The title bar text
|
|
static TCHAR szWindowClass[MAX_LOADSTRING]; // The title bar text
|
|
static HINSTANCE g_hInstance;
|
|
static int g_nCmdShow;
|
|
static WNDCLASSEX wcex;
|
|
static unsigned char InfoBand=1;
|
|
static unsigned char Resizeable=1;
|
|
static unsigned char ForceAspect=1;
|
|
static char StatusText[255]="";
|
|
static unsigned int Color=0;
|
|
static Rect RememberWin = { CW_USEDEFAULT, CW_USEDEFAULT, DefaultWidth, DefaultHeight };
|
|
static bool UseOpenGL = true;
|
|
|
|
//Function Prototypes for this module
|
|
extern LRESULT CALLBACK WndProc(HWND, UINT, WPARAM, LPARAM); //Callback for the main window
|
|
|
|
// load font on demand, otherwise false if not supported
|
|
bool LoadOpenGLFont()
|
|
{
|
|
#if USE_OPENGL
|
|
return g_OpenGLDisplay && (g_DisplayFont || g_OpenGLDisplay->LoadFont(&g_DisplayFont, IDB_FONT_CONSOLA, OpenGLFontConsola, 32, 127) == OpenGL::OK);
|
|
#else // !USE_OPENGL
|
|
return false;
|
|
#endif // !USE_OPENGL
|
|
}
|
|
|
|
BOOL InitInstance(HINSTANCE hInstance, int nCmdShow)
|
|
{
|
|
g_hInstance=hInstance;
|
|
g_nCmdShow=nCmdShow;
|
|
LoadLibrary("RICHED20.DLL");
|
|
LoadString(g_hInstance, IDS_APP_TITLE, szTitle, MAX_LOADSTRING);
|
|
LoadString(g_hInstance, IDS_APP_TITLE, szWindowClass, MAX_LOADSTRING);
|
|
return TRUE;
|
|
}
|
|
|
|
template<typename T, typename Interface>
|
|
bool InitGraphics(Interface** ptr, SystemState* CWState, int w, int h)
|
|
{
|
|
if (!g_SystemState) g_SystemState = new SystemStatePtr(CWState);
|
|
if (!*ptr) *ptr = new T(g_SystemState);
|
|
if (!g_Display) g_Display = *ptr;
|
|
if (g_Display && g_Display->Setup(CWState->WindowHandle, w, h, StatusBarHeight, CWState->FullScreen == 1) == IDisplay::OK)
|
|
return true;
|
|
g_Display = nullptr;
|
|
*ptr = nullptr;
|
|
return false;
|
|
};
|
|
|
|
bool CreateNullWindow(SystemState* CWState)
|
|
{
|
|
IDisplayOpenGL* display = nullptr;
|
|
return InitGraphics<DisplayNone>(&display, CWState, 640, 480);
|
|
}
|
|
|
|
bool CreateDDWindow(SystemState *CWState)
|
|
{
|
|
RECT rStatBar;
|
|
RECT rc = { 0, 0, DefaultWidth, DefaultHeight };
|
|
|
|
auto isRememberSize = GetRememberSize();
|
|
|
|
if (isRememberSize)
|
|
{
|
|
auto& windowRect = GetIniWindowRect();
|
|
rc = windowRect.GetRect();
|
|
|
|
// if x or y undefined keep size but use default position
|
|
if (windowRect.IsDefaultX() || windowRect.IsDefaultY())
|
|
isRememberSize = false;
|
|
}
|
|
|
|
int xPos = rc.left;
|
|
int yPos = rc.top;
|
|
|
|
// if not remembering window, use default positioning
|
|
if (!isRememberSize)
|
|
{
|
|
xPos = CW_USEDEFAULT;
|
|
yPos = 0;
|
|
}
|
|
|
|
HMONITOR hmon;
|
|
|
|
if (CWState->WindowHandle != nullptr) //If its go a value it must be a mode switch
|
|
{
|
|
hmon = MonitorFromWindow(CWState->WindowHandle, MONITOR_DEFAULTTONEAREST);
|
|
CloseScreen();
|
|
DestroyWindow(CWState->WindowHandle);
|
|
UnregisterClass(wcex.lpszClassName,wcex.hInstance);
|
|
}
|
|
wcex.cbSize = sizeof(WNDCLASSEX); //And Rebuilt it from scratch
|
|
wcex.style = CS_HREDRAW | CS_VREDRAW;
|
|
wcex.lpfnWndProc = (WNDPROC)WndProc;
|
|
wcex.cbClsExtra = 0;
|
|
wcex.cbWndExtra = 0;
|
|
wcex.hInstance = g_hInstance;
|
|
wcex.hIcon = LoadIcon(g_hInstance, (LPCTSTR)IDI_COCO3);
|
|
wcex.hCursor = LoadCursor(nullptr, IDC_ARROW);
|
|
wcex.hbrBackground = (HBRUSH)GetStockObject(BLACK_BRUSH);
|
|
wcex.lpszMenuName = (LPCSTR)IDR_MENU;
|
|
wcex.lpszClassName = szWindowClass;
|
|
wcex.hIconSm = LoadIcon(wcex.hInstance, (LPCTSTR)IDI_COCO3);
|
|
if (CWState->FullScreen)
|
|
{
|
|
wcex.lpszMenuName =nullptr; //Fullscreen has no Menu Bar and no Mouse pointer
|
|
wcex.hCursor = LoadCursor(g_hInstance, MAKEINTRESOURCE(IDC_NONE));
|
|
}
|
|
if (!RegisterClassEx(&wcex))
|
|
return false;
|
|
if (CWState->FullScreen == 0)
|
|
{
|
|
//Windowed Mode
|
|
|
|
// Calculates the required size of the window rectangle, based on the desired client-rectangle size
|
|
// The window rectangle can then be passed to the CreateWindow function to create a window whose client area is the desired size.
|
|
::AdjustWindowRect(&rc, WS_OVERLAPPEDWINDOW, TRUE);
|
|
|
|
// We create the Main window
|
|
CWState->WindowHandle = CreateWindow(szWindowClass, szTitle, WS_OVERLAPPEDWINDOW, xPos, yPos,
|
|
rc.right - rc.left, rc.bottom - rc.top,
|
|
nullptr, nullptr, g_hInstance, nullptr);
|
|
if (!CWState->WindowHandle) // Can't create window
|
|
return false;
|
|
|
|
// Set up stable proxy window for DLL messages
|
|
CWState->hMsgProxy = Core::ProxyMsgWin::SetProxy(CWState->WindowHandle);
|
|
|
|
// Create the Status Bar Window at the bottom
|
|
hwndStatusBar = ::CreateStatusWindow(WS_CHILD | WS_VISIBLE | WS_CLIPSIBLINGS | CCS_BOTTOM , "Ready", CWState->WindowHandle, 2);
|
|
if (!hwndStatusBar) // Can't create Status bar
|
|
return false;
|
|
|
|
// Retrieves the dimensions of the bounding rectangle of the specified window
|
|
// The dimensions are given in screen coordinates that are relative to the upper-left corner of the screen.
|
|
::GetWindowRect(hwndStatusBar, &rStatBar); // Get the size of the Status bar
|
|
StatusBarHeight = rStatBar.bottom - rStatBar.top; // Calculate its height
|
|
|
|
// Get the size of main window and add height of status bar then resize Main
|
|
// re-using rStatBar RECT even though it's the main window
|
|
::GetWindowRect(CWState->WindowHandle, &rStatBar);
|
|
::MoveWindow(CWState->WindowHandle, rStatBar.left, rStatBar.top, // using MoveWindow to resize
|
|
rStatBar.right - rStatBar.left, (rStatBar.bottom + StatusBarHeight) - rStatBar.top,
|
|
1);
|
|
::SendMessage(hwndStatusBar, WM_SIZE, 0, 0); // Redraw Status bar in new position
|
|
}
|
|
else //Full Screen Mode
|
|
{
|
|
CaptureCurrentWindowRect();
|
|
|
|
MONITORINFO mi = { sizeof(mi) };
|
|
if (!GetMonitorInfo(hmon, &mi))
|
|
return false;
|
|
|
|
CWState->WindowHandle = CreateWindow(
|
|
szWindowClass,
|
|
nullptr,
|
|
WS_POPUP | WS_VISIBLE,
|
|
mi.rcMonitor.left,
|
|
mi.rcMonitor.top,
|
|
mi.rcMonitor.right - mi.rcMonitor.left,
|
|
mi.rcMonitor.bottom - mi.rcMonitor.top,
|
|
nullptr, nullptr, g_hInstance, 0);
|
|
}
|
|
|
|
ShowWindow(CWState->WindowHandle, g_nCmdShow);
|
|
UpdateWindow(CWState->WindowHandle);
|
|
|
|
HWND windowHandle = CWState->WindowHandle;
|
|
if (windowHandle)
|
|
{
|
|
::GetClientRect(windowHandle, &rStatBar);
|
|
int w = rStatBar.right - rStatBar.left;
|
|
int h = rStatBar.bottom - rStatBar.top - StatusBarHeight;
|
|
|
|
// attempt to use opengl
|
|
if (UseOpenGL && !InitGraphics<ClassOpenGL>(&g_OpenGLDisplay, CWState, w, h))
|
|
UseOpenGL = false;
|
|
|
|
// otherwise attempt to use directx
|
|
if (!UseOpenGL && !InitGraphics<ClassDirectX>(&g_DirectXDisplay, CWState, w, h))
|
|
return false;
|
|
|
|
SetAspect(ForceAspect);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
/*--------------------------------------------------------------------------*/
|
|
|
|
|
|
bool IsMaximized(SystemState* DFState)
|
|
{
|
|
WINDOWPLACEMENT wp;
|
|
memset(&wp, 0, sizeof(wp));
|
|
wp.length = sizeof(wp);
|
|
GetWindowPlacement(DFState->WindowHandle, &wp);
|
|
return wp.showCmd == SW_MAXIMIZE;
|
|
}
|
|
|
|
|
|
void DisplayFlip(SystemState *DFState) // Double buffering flip
|
|
{
|
|
if (g_Display)
|
|
{
|
|
g_Display->Render();
|
|
#if USE_OPENGL
|
|
if (DFState->FullScreen && InfoBand)
|
|
{
|
|
if (LoadOpenGLFont())
|
|
{
|
|
OpenGL::Rect renderRect;
|
|
g_OpenGLDisplay->GetRect(OpenGL::OPT_RECT_RENDER, &renderRect);
|
|
g_OpenGLDisplay->RenderBox(0, 0, renderRect.w, 25, VCC::ColorBlack, true);
|
|
g_OpenGLDisplay->RenderText(g_DisplayFont, 10, 18, 20, StatusText);
|
|
}
|
|
}
|
|
|
|
#if USE_DEBUG_AUDIOTAPE
|
|
// put these here for now as it needs to be on top
|
|
DebugPrint(10, 250, 20, "Audio Out", VCC::ColorWhite);
|
|
DebugPrint(10, 400, 20, "Audio In", VCC::ColorWhite);
|
|
DebugPrint(10, 515, 20, "Motor", VCC::ColorWhite);
|
|
DebugPrint(10, 545, 20, "MUX", VCC::ColorWhite);
|
|
#endif // USE_DEBUG_AUDIOTAPE
|
|
#endif // USE_OPENGL
|
|
|
|
g_Display->Present();
|
|
}
|
|
|
|
static RECT CurWindow;
|
|
::GetWindowRect(DFState->WindowHandle, &CurWindow);
|
|
static RECT CurScreen;
|
|
::GetClientRect(DFState->WindowHandle, &CurScreen);
|
|
int clientWidth = (int)CurScreen.right;
|
|
int clientHeight = (int)CurScreen.bottom;
|
|
|
|
if (!IsMaximized(DFState) && !DFState->FullScreen && !DFState->Exiting)
|
|
{
|
|
#if USE_DEFAULT_POSITIONING
|
|
// preserve default positioning (like older versions):
|
|
RememberWin.x = RememberWin.IsDefaultX() ? CW_USEDEFAULT : CurWindow.left;
|
|
RememberWin.y = RememberWin.IsDefaultY() ? CW_USEDEFAULT : CurWindow.top;
|
|
#else // !USE_DEFAULT_POSITIONING
|
|
// remember positioning:
|
|
RememberWin.x = CurWindow.left;
|
|
RememberWin.y = CurWindow.top;
|
|
#endif // !USE_DEFAULT_POSITIONING
|
|
|
|
// remember size:
|
|
RememberWin.w = clientWidth; // Used for saving new window size to the ini file.
|
|
RememberWin.h = clientHeight - StatusBarHeight;
|
|
}
|
|
return;
|
|
}
|
|
|
|
unsigned char LockScreen()
|
|
{
|
|
if (!g_Display)
|
|
return 0;
|
|
|
|
if (g_Display->LockSurface() != IDisplay::OK)
|
|
return 1;
|
|
|
|
return 0;
|
|
}
|
|
|
|
void UnlockScreen(SystemState *USState)
|
|
{
|
|
if (g_DirectXDisplay && InfoBand)
|
|
g_DirectXDisplay->RenderStatusLine(StatusText);
|
|
|
|
if (g_Display->UnlockSurface() != IDisplay::OK)
|
|
return;
|
|
|
|
DisplayFlip(USState);
|
|
return;
|
|
}
|
|
|
|
void SetStatusBarText(const char *TextBuffer,const SystemState *STState)
|
|
{
|
|
if (!STState->FullScreen)
|
|
{
|
|
SendMessage(hwndStatusBar,WM_SETTEXT,0, reinterpret_cast<LPARAM>(TextBuffer));
|
|
SendMessage(hwndStatusBar,WM_SIZE,0,0);
|
|
}
|
|
else
|
|
strcpy(StatusText,TextBuffer);
|
|
return;
|
|
}
|
|
|
|
void Cls(unsigned int ClsColor,SystemState *CLState)
|
|
{
|
|
CLState->ResetPending=3; //Tell Main loop to hold Emu
|
|
Color=ClsColor;
|
|
return;
|
|
}
|
|
|
|
void DoCls(SystemState *CLStatus)
|
|
{
|
|
unsigned short x=0,y=0;
|
|
|
|
if(LockScreen())
|
|
return;
|
|
switch (CLStatus->BitDepth)
|
|
{
|
|
case 0:
|
|
for (y=0;y<480;y++)
|
|
for (x=0;x<640;x++)
|
|
CLStatus->PTRsurface8[x + (y*CLStatus->SurfacePitch) ]=Color|128;
|
|
break;
|
|
case 1:
|
|
for (y=0;y<480;y++)
|
|
for (x=0;x<640;x++)
|
|
CLStatus->PTRsurface16[x + (y*CLStatus->SurfacePitch) ]=Color;
|
|
break;
|
|
case 2:
|
|
for (y=0;y<480;y++)
|
|
for (x=0;x<640;x++)
|
|
{
|
|
CLStatus->PTRsurface8[(x*3) + (y*CLStatus->SurfacePitch) ]=(Color & 0xFF0000)>>16;
|
|
CLStatus->PTRsurface8[(x*3)+1 + (y*CLStatus->SurfacePitch) ]=(Color & 0x00FF00)>>8;
|
|
CLStatus->PTRsurface8[(x*3)+2 + (y*CLStatus->SurfacePitch) ]=(Color & 0xFF);
|
|
}
|
|
break;
|
|
case 3:
|
|
for (y=0;y<480;y++)
|
|
for (x=0;x<640;x++)
|
|
CLStatus->PTRsurface32[x + (y*CLStatus->SurfacePitch) ]=Color;
|
|
break;
|
|
default:
|
|
return;
|
|
}
|
|
|
|
UnlockScreen(CLStatus);
|
|
return;
|
|
}
|
|
|
|
unsigned char SetInfoBand( unsigned char Tmp)
|
|
{
|
|
if (Tmp!=QUERY)
|
|
InfoBand=Tmp;
|
|
return InfoBand;
|
|
}
|
|
|
|
unsigned char SetResize(unsigned char Tmp)
|
|
{
|
|
if (Tmp != QUERY)
|
|
{
|
|
Resizeable = Tmp;
|
|
if (g_Display)
|
|
g_Display->SetOption(IDisplay::OPT_FLAG_RESIZEABLE, Resizeable);
|
|
}
|
|
return Resizeable;
|
|
}
|
|
|
|
unsigned char SetAspect (unsigned char Tmp)
|
|
{
|
|
if (Tmp != QUERY)
|
|
{
|
|
ForceAspect = Tmp;
|
|
if (g_Display)
|
|
g_Display->SetOption(IDisplay::OPT_FLAG_ASPECT, ForceAspect);
|
|
}
|
|
return ForceAspect;
|
|
}
|
|
|
|
void DisplaySignalLostMessage()
|
|
{
|
|
#if USE_OPENGL
|
|
if (LoadOpenGLFont())
|
|
{
|
|
const float fontSize = 20;
|
|
const char* message = " Signal Lost! Press F9 ";
|
|
const float messageWidth = strlen(message) * fontSize * g_DisplayFont->glyphs->advance;
|
|
const float baseLine = fontSize - 4;
|
|
|
|
OpenGL::Rect renderRect;
|
|
g_OpenGLDisplay->GetRect(OpenGL::OPT_RECT_RENDER, &renderRect);
|
|
float x = (renderRect.w - messageWidth) / 2;
|
|
float y = (renderRect.h - fontSize) / 2;
|
|
g_OpenGLDisplay->RenderBox(x, y, messageWidth, fontSize, VCC::ColorBlack, true);
|
|
g_OpenGLDisplay->RenderText(g_DisplayFont, x, y + baseLine, fontSize, message);
|
|
}
|
|
#endif // USE_OPENGL
|
|
}
|
|
|
|
float Static(SystemState *STState)
|
|
{
|
|
unsigned short x=0;
|
|
static unsigned short y=0;
|
|
unsigned char Temp=0;
|
|
static unsigned char GreyScales[4] = { 128,135,184,191 };
|
|
|
|
if (g_Display == nullptr)
|
|
return 0;
|
|
|
|
if (g_Display->LockSurface() != IDisplay::OK)
|
|
return 0;
|
|
|
|
switch (STState->BitDepth)
|
|
{
|
|
case 0:
|
|
for (y=0;y<480;y+=2)
|
|
for (x=0;x<160;x++)
|
|
{
|
|
Temp=rand() & 3;
|
|
STState->PTRsurface32[x + (y*STState->SurfacePitch>>2) ]= GreyScales[Temp]|(GreyScales[Temp]<<8)|(GreyScales[Temp]<<16) | (GreyScales[Temp]<<24);
|
|
STState->PTRsurface32[x + ((y+1)*STState->SurfacePitch>>2) ]= GreyScales[Temp]|(GreyScales[Temp]<<8)|(GreyScales[Temp]<<16) | (GreyScales[Temp]<<24);
|
|
}
|
|
break;
|
|
case 1:
|
|
for (y=0;y<480;y+=2)
|
|
for (x=0;x<320;x++)
|
|
{
|
|
Temp=rand() & 31;
|
|
STState->PTRsurface32[x + (y*STState->SurfacePitch>>1) ]=Temp | (Temp <<6) | (Temp<<11) | (Temp<<16) |(Temp<<22)| (Temp<<27);
|
|
STState->PTRsurface32[x + ((y+1)*STState->SurfacePitch>>1) ]=Temp | (Temp <<6) | (Temp<<11) | (Temp<<16) |(Temp<<22)| (Temp<<27);
|
|
}
|
|
break;
|
|
case 2:
|
|
for (y=0;y<480;y++)
|
|
for (x=0;x<640;x++)
|
|
{
|
|
STState->PTRsurface8[(x*3) + (y*STState->SurfacePitch) ]=Temp;
|
|
STState->PTRsurface8[(x*3)+1 + (y*STState->SurfacePitch) ]=Temp<<8;
|
|
STState->PTRsurface8[(x*3)+2 + (y*STState->SurfacePitch) ]=Temp <<16;
|
|
}
|
|
break;
|
|
case 3:
|
|
for (y=0;y<480;y++)
|
|
for (x=0;x<640;x++)
|
|
{
|
|
Temp=rand() & 255;
|
|
STState->PTRsurface32[x + (y*STState->SurfacePitch) ]=Temp | (Temp<<8) | (Temp <<16);
|
|
}
|
|
break;
|
|
default:
|
|
return 0;
|
|
}
|
|
|
|
// need to do during lock
|
|
if (g_DirectXDisplay)
|
|
g_DirectXDisplay->RenderSignalLostMessage();
|
|
|
|
if (g_Display->UnlockSurface() != IDisplay::OK)
|
|
return 0;
|
|
|
|
g_Display->Render();
|
|
DisplaySignalLostMessage();
|
|
g_Display->Present();
|
|
|
|
return CalculateFPS(false);
|
|
}
|
|
|
|
const Rect& GetCurWindowSize()
|
|
{
|
|
return RememberWin;
|
|
}
|
|
|
|
int GetRenderWindowStatusBarHeight()
|
|
{
|
|
return StatusBarHeight;
|
|
}
|
|
|
|
|
|
POINT GetForcedAspectBorderPadding()
|
|
{
|
|
if (g_Display)
|
|
{
|
|
IDisplay::Rect area;
|
|
g_Display->GetRect(IDisplay::OPT_RECT_DISPLAY, &area);
|
|
return { (long)area.x, (long)area.y };
|
|
}
|
|
return { 0,0 };
|
|
}
|
|
|
|
void CloseScreen()
|
|
{
|
|
if (g_Display)
|
|
{
|
|
g_Display->Cleanup();
|
|
delete g_Display;
|
|
delete g_SystemState;
|
|
g_Display = nullptr;
|
|
g_SystemState = nullptr;
|
|
|
|
// alias
|
|
g_DirectXDisplay = nullptr;
|
|
g_OpenGLDisplay = nullptr;
|
|
g_DisplayFont = nullptr;
|
|
}
|
|
}
|
|
|
|
void DebugDrawLine(float x1, float y1, float x2, float y2, Pixel color)
|
|
{
|
|
if (g_Display)
|
|
g_Display->DebugDrawLine(x1, y1, x2, y2, color);
|
|
}
|
|
|
|
void DebugDrawBox(float x, float y, float w, float h, Pixel color, bool filled)
|
|
{
|
|
if (g_Display)
|
|
g_Display->DebugDrawBox(x, y, w, h, color, filled);
|
|
}
|
|
|
|
void DebugPrint(float x, float y, float size, const char* str, Pixel color)
|
|
{
|
|
if (g_OpenGLDisplay && LoadOpenGLFont())
|
|
g_OpenGLDisplay->DebugDrawText(g_DisplayFont, x, y, size, str, color);
|
|
}
|
|
|
|
void DumpScreenshot(const char* fname)
|
|
{
|
|
using namespace Screenshot;
|
|
|
|
auto result = Snap(g_Display, fname);
|
|
|
|
if (result != OK)
|
|
{
|
|
char msg[128];
|
|
sprintf(msg, "Unable to take screenshot! (%d)", result);
|
|
MessageBox(nullptr, msg, "Error", 0);
|
|
}
|
|
}
|