515 lines
19 KiB
C++
515 lines
19 KiB
C++
// Copyright 2015 by Joseph Forgion
|
|
// 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. If not, see <http://www.gnu.org/licenses/>.
|
|
//
|
|
// 2025/04/10 - Craig Allsop - Add OpenGL rendering.
|
|
//
|
|
|
|
#include "DirectX.h"
|
|
|
|
#if USE_DIRECTX
|
|
|
|
#include "DirectDrawInterface.h"
|
|
#include "ddraw.h"
|
|
|
|
namespace VCC
|
|
{
|
|
//
|
|
// Private wrapper on result code for logging errors
|
|
//
|
|
static int Result(int code)
|
|
{
|
|
if (code != IDisplay::OK)
|
|
{
|
|
char message[256];
|
|
snprintf(message, 64, "DirectX error %d\nCheck DirectX support", code);
|
|
MessageBox(nullptr, message, "Error", 0);
|
|
// FIXME: This is needed and should not be commented out. Wrap it conditional
|
|
// either here or in the debug log functions.
|
|
//PrintLogC("OpenGL Error: %d\n", code);
|
|
}
|
|
return code;
|
|
}
|
|
|
|
namespace Detail
|
|
{
|
|
//Global Variables for Direct Draw funcions
|
|
LPDIRECTDRAW g_pDD; // The DirectDraw object
|
|
LPDIRECTDRAWCLIPPER g_pClipper; // Clipper for primary surface
|
|
LPDIRECTDRAWSURFACE g_pDDS; // Primary surface
|
|
LPDIRECTDRAWSURFACE g_pDDSBack; // Back surface
|
|
IDirectDrawPalette* ddpal; // Needed for 8bit Palette mode
|
|
bool isInitialized;
|
|
bool isFullscreen;
|
|
bool forceAspect;
|
|
bool resizeable;
|
|
int statusBarHeight;
|
|
RECT WindowDefaultSize;
|
|
POINT ForcedAspectBorderPadding;
|
|
|
|
// surface while locked
|
|
void* surface;
|
|
int bitDepth;
|
|
long surfacePitch;
|
|
}
|
|
|
|
DirectX::DirectX(ISystemState* state) : state(state)
|
|
{
|
|
using namespace Detail;
|
|
isInitialized = false;
|
|
isFullscreen = false;
|
|
forceAspect = false;
|
|
statusBarHeight = 0;
|
|
resizeable = true;
|
|
WindowDefaultSize = {};
|
|
ForcedAspectBorderPadding = {};
|
|
g_pDDSBack = nullptr;
|
|
g_pDDS = nullptr;
|
|
g_pClipper = nullptr;
|
|
g_pDD = nullptr;
|
|
ddpal = nullptr;
|
|
surface = nullptr;
|
|
bitDepth = 0;
|
|
surfacePitch = 0;
|
|
}
|
|
|
|
int DirectX::Setup(void* hwnd, int width, int height, int statusHeight, bool fullscreen)
|
|
{
|
|
using namespace Detail;
|
|
|
|
isFullscreen = fullscreen;
|
|
statusBarHeight = statusHeight;
|
|
|
|
GetWindowRect((HWND)hwnd, &WindowDefaultSize);
|
|
|
|
HRESULT hr;
|
|
PALETTEENTRY pal[256];
|
|
DDSURFACEDESC ddsd; // A structure to describe the surfaces we want
|
|
unsigned char ColorValues[4] = { 0,85,170,255 };
|
|
|
|
memset(&ddsd, 0, sizeof(ddsd)); // Clear all members of the structure to 0
|
|
ddsd.dwSize = sizeof(ddsd); // The first parameter of the structure must contain the size of the structure
|
|
|
|
// Create an instance of a DirectDraw object
|
|
hr = ::DirectDrawCreate(nullptr, &g_pDD, nullptr);
|
|
if (FAILED(hr)) return Result(ERR_UNKNOWN);
|
|
|
|
VCC::Rect windowRect = { 0, 0, 640, 480 };
|
|
|
|
if (fullscreen)
|
|
{
|
|
ddsd.lPitch = 0;
|
|
ddsd.ddpfPixelFormat.dwRGBBitCount = 0;
|
|
hr = DirectDrawCreate(nullptr, &g_pDD, nullptr); // Initialize DirectDraw
|
|
if (FAILED(hr)) return Result(ERR_UNKNOWN);
|
|
hr = g_pDD->SetCooperativeLevel((HWND)hwnd, DDSCL_EXCLUSIVE | DDSCL_FULLSCREEN | DDSCL_NOWINDOWCHANGES);
|
|
if (FAILED(hr)) return Result(ERR_UNKNOWN);
|
|
hr = g_pDD->SetDisplayMode(windowRect.w, windowRect.h, 32); // Set 640x480x32 Bit full-screen mode
|
|
if (FAILED(hr)) return Result(ERR_UNKNOWN);
|
|
ddsd.dwFlags = DDSD_CAPS | DDSD_BACKBUFFERCOUNT;
|
|
ddsd.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE | DDSCAPS_COMPLEX | DDSCAPS_FLIP;
|
|
ddsd.dwBackBufferCount = 1;
|
|
hr = g_pDD->CreateSurface(&ddsd, &g_pDDS, nullptr);
|
|
if (FAILED(hr)) return Result(ERR_UNKNOWN);
|
|
ddsd.ddsCaps.dwCaps = DDSCAPS_BACKBUFFER;
|
|
g_pDDS->GetAttachedSurface(&ddsd.ddsCaps, &g_pDDSBack);
|
|
hr = g_pDD->GetDisplayMode(&ddsd);
|
|
if (FAILED(hr)) return Result(ERR_UNKNOWN);
|
|
//***********************************TEST*****************************************
|
|
for (unsigned short i = 0;i <= 63;i++)
|
|
{
|
|
pal[i + 128].peBlue = ColorValues[(i & 8) >> 2 | (i & 1)];
|
|
pal[i + 128].peGreen = ColorValues[(i & 16) >> 3 | (i & 2) >> 1];
|
|
pal[i + 128].peRed = ColorValues[(i & 32) >> 4 | (i & 4) >> 2];
|
|
pal[i + 128].peFlags = PC_RESERVED | PC_NOCOLLAPSE;
|
|
}
|
|
g_pDD->CreatePalette(DDPCAPS_8BIT | DDPCAPS_ALLOW256, pal, &ddpal, nullptr);
|
|
g_pDDS->SetPalette(ddpal); // Set palette for Primary surface
|
|
//**********************************END TEST***************************************
|
|
}
|
|
else
|
|
{
|
|
// Initialize the DirectDraw object
|
|
hr = g_pDD->SetCooperativeLevel((HWND)hwnd, DDSCL_NORMAL); // Set DDSCL_NORMAL to use windowed mode
|
|
if (FAILED(hr)) return Result(ERR_UNKNOWN);
|
|
|
|
ddsd.dwFlags = DDSD_CAPS;
|
|
ddsd.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE;
|
|
|
|
// Create our Primary Surface
|
|
hr = g_pDD->CreateSurface(&ddsd, &g_pDDS, nullptr);
|
|
if (FAILED(hr)) return Result(ERR_UNKNOWN);
|
|
ddsd.dwFlags = DDSD_WIDTH | DDSD_HEIGHT | DDSD_CAPS;
|
|
ddsd.dwWidth = windowRect.w; // Make our off-screen surface
|
|
ddsd.dwHeight = windowRect.h;
|
|
ddsd.ddsCaps.dwCaps = DDSCAPS_VIDEOMEMORY; // Try to create back buffer in video RAM
|
|
|
|
#if USE_DIRECTX_16BIT_SURFACE
|
|
// Set 16-bit pixel format (5-6-5)
|
|
ddsd.dwFlags |= DDSD_PIXELFORMAT;
|
|
ddsd.ddpfPixelFormat.dwSize = sizeof(DDPIXELFORMAT);
|
|
ddsd.ddpfPixelFormat.dwFlags = DDPF_RGB;
|
|
ddsd.ddpfPixelFormat.dwRGBBitCount = 16;
|
|
ddsd.ddpfPixelFormat.dwRBitMask = 0xF800; // 5 bits Red
|
|
ddsd.ddpfPixelFormat.dwGBitMask = 0x07E0; // 6 bits Green
|
|
ddsd.ddpfPixelFormat.dwBBitMask = 0x001F; // 5 bits Blue
|
|
#elif USE_DIRECTX_8BIT_SURFACE
|
|
ddsd.dwFlags |= DDSD_PIXELFORMAT;
|
|
ddsd.ddpfPixelFormat.dwSize = sizeof(DDPIXELFORMAT);
|
|
ddsd.ddpfPixelFormat.dwFlags = DDPF_RGB | DDPF_PALETTEINDEXED8;
|
|
ddsd.ddpfPixelFormat.dwRGBBitCount = 8;
|
|
#endif
|
|
|
|
hr = g_pDD->CreateSurface(&ddsd, &g_pDDSBack, nullptr);
|
|
if (FAILED(hr)) // If not enough Video Ram
|
|
{
|
|
ddsd.ddsCaps.dwCaps = DDSCAPS_SYSTEMMEMORY; // Try to create back buffer in System RAM
|
|
hr = g_pDD->CreateSurface(&ddsd, &g_pDDSBack, nullptr);
|
|
if (FAILED(hr)) return Result(ERR_UNKNOWN); //Giving Up
|
|
MessageBox(nullptr, "Creating Back Buffer in System Ram\n", "Performance Warning", 0);
|
|
}
|
|
|
|
hr = g_pDD->GetDisplayMode(&ddsd);
|
|
if (FAILED(hr)) return Result(ERR_UNKNOWN);
|
|
hr = g_pDD->CreateClipper(0, &g_pClipper, nullptr); // Create the clipper using the DirectDraw object
|
|
if (FAILED(hr)) return Result(ERR_UNKNOWN);
|
|
hr = g_pClipper->SetHWnd(0, (HWND)hwnd); // Assign your window's HWND to the clipper
|
|
if (FAILED(hr)) return Result(ERR_UNKNOWN);
|
|
hr = g_pDDS->SetClipper(g_pClipper); // Attach the clipper to the primary surface
|
|
if (FAILED(hr)) return Result(ERR_UNKNOWN);
|
|
hr = g_pDDSBack->Lock(nullptr, &ddsd, DDLOCK_WAIT, nullptr);
|
|
if (FAILED(hr)) return Result(ERR_UNKNOWN);
|
|
hr = g_pDDSBack->Unlock(nullptr); // Unlock surface
|
|
if (FAILED(hr)) return Result(ERR_UNKNOWN);
|
|
}
|
|
|
|
return Result(OK);
|
|
}
|
|
|
|
int DirectX::Render()
|
|
{
|
|
using namespace std;
|
|
using namespace Detail;
|
|
|
|
static HRESULT hr;
|
|
static RECT rcSrc; // source blit rectangle
|
|
static RECT rcDest; // destination blit rectangle
|
|
static RECT Temp;
|
|
static POINT p;
|
|
|
|
HWND hwnd;
|
|
if (state->GetWindowHandle((void**)&hwnd) != OK)
|
|
return Result(ERR_UNKNOWN);
|
|
|
|
VCC::Rect windowRect;
|
|
if (state->GetRect(1, &windowRect) != OK)
|
|
return Result(ERR_UNKNOWN);
|
|
|
|
ForcedAspectBorderPadding = { 0,0 };
|
|
|
|
if (isFullscreen) // if we're windowed do the blit, else just Flip
|
|
hr = g_pDDS->Flip(nullptr, DDFLIP_NOVSYNC | DDFLIP_DONOTWAIT); //DDFLIP_WAIT
|
|
else
|
|
{
|
|
p.x = 0; p.y = 0;
|
|
|
|
// The ClientToScreen function converts the client-area coordinates of a specified point to screen coordinates.
|
|
// in other word the client rectangle of the main windows 0, 0 (upper-left corner)
|
|
// in a screen x,y coords which is put back into p
|
|
::ClientToScreen(hwnd, &p); // find out where on the primary surface our window lives
|
|
|
|
// get the actual client rectangle, which is always 0,0 - w,h
|
|
::GetClientRect(hwnd, &rcDest);
|
|
|
|
// The OffsetRect function moves the specified rectangle by the specified offsets
|
|
// add the delta screen point we got above, which gives us the client rect in screen coordinates.
|
|
::OffsetRect(&rcDest, p.x, p.y);
|
|
|
|
// our destination rectangle is going to be
|
|
::SetRect(&rcSrc, 0, 0, windowRect.w, windowRect.h);
|
|
|
|
if (resizeable)
|
|
{
|
|
rcDest.bottom -= statusBarHeight;
|
|
|
|
if (forceAspect) // Adjust the Aspect Ratio if window is resized
|
|
{
|
|
float srcWidth = (float)windowRect.w;
|
|
float srcHeight = (float)windowRect.h;
|
|
float srcRatio = srcWidth / srcHeight;
|
|
|
|
// change this to use the existing rcDest and the calc, w = right-left & h = bottom-top,
|
|
// because rcDest has already been converted to screen cords, right?
|
|
static RECT rcClient;
|
|
::GetClientRect(hwnd, &rcClient); // x,y is always 0,0 so right, bottom is w,h
|
|
rcClient.bottom -= statusBarHeight;
|
|
|
|
float clientWidth = (float)rcClient.right;
|
|
float clientHeight = (float)rcClient.bottom;
|
|
float clientRatio = clientWidth / clientHeight;
|
|
|
|
float dstWidth = 0, dstHeight = 0;
|
|
|
|
if (clientRatio > srcRatio)
|
|
{
|
|
dstWidth = srcWidth * clientHeight / srcHeight;
|
|
dstHeight = clientHeight;
|
|
}
|
|
else
|
|
{
|
|
dstWidth = clientWidth;
|
|
dstHeight = srcHeight * clientWidth / srcWidth;
|
|
}
|
|
|
|
float dstX = (clientWidth - dstWidth) / 2;
|
|
float dstY = (clientHeight - dstHeight) / 2;
|
|
|
|
static POINT pDstLeftTop;
|
|
pDstLeftTop.x = (long)dstX; pDstLeftTop.y = (long)dstY;
|
|
ForcedAspectBorderPadding = pDstLeftTop;
|
|
|
|
::ClientToScreen(hwnd, &pDstLeftTop);
|
|
|
|
static POINT pDstRightBottom;
|
|
pDstRightBottom.x = (long)(dstX + dstWidth); pDstRightBottom.y = (long)(dstY + dstHeight);
|
|
::ClientToScreen(hwnd, &pDstRightBottom);
|
|
|
|
::SetRect(&rcDest, pDstLeftTop.x, pDstLeftTop.y, pDstRightBottom.x, pDstRightBottom.y);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// this does not seem ideal, it lets you begin to resize and immediately resizes it back ... causing a lot of flicker.
|
|
rcDest.right = rcDest.left + windowRect.w;
|
|
rcDest.bottom = rcDest.top + windowRect.h;
|
|
::GetWindowRect(hwnd, &Temp);
|
|
::MoveWindow(hwnd, Temp.left, Temp.top, WindowDefaultSize.right - WindowDefaultSize.left, WindowDefaultSize.bottom - WindowDefaultSize.top, 1);
|
|
}
|
|
|
|
if (g_pDDSBack == nullptr)
|
|
return Result(ERR_UNKNOWN);
|
|
|
|
hr = g_pDDS->Blt(&rcDest, g_pDDSBack, &rcSrc, DDBLT_WAIT, nullptr); // DDBLT_WAIT
|
|
if (hr == DDERR_SURFACELOST)
|
|
{
|
|
hr = g_pDDS->Restore();
|
|
if (hr == DDERR_WRONGMODE) return Result(ERR_WRONGMODE);
|
|
if (FAILED(hr)) return Result(ERR_UNKNOWN);
|
|
g_pDDSBack->Restore();
|
|
hr = g_pDDS->Blt(&rcDest, g_pDDSBack, &rcSrc, DDBLT_WAIT, nullptr); // DDBLT_WAIT
|
|
if (hr == E_FAIL) return Result(OK);
|
|
}
|
|
if (FAILED(hr)) return Result(ERR_UNKNOWN);
|
|
}
|
|
|
|
return Result(OK);
|
|
}
|
|
|
|
int DirectX::Present()
|
|
{
|
|
return Result(OK);
|
|
}
|
|
|
|
int DirectX::Cleanup()
|
|
{
|
|
using namespace Detail;
|
|
if (g_pDD != nullptr)
|
|
g_pDD->Release(); //Destroy the current Window
|
|
|
|
return Result(OK);
|
|
}
|
|
|
|
int DirectX::SetOption(int flagOption, bool enabled)
|
|
{
|
|
using namespace Detail;
|
|
//if (!isInitialized) return Result(ERR_NOTINITIALIZED);
|
|
switch (flagOption)
|
|
{
|
|
case OPT_FLAG_ASPECT: forceAspect = enabled; break;
|
|
case OPT_FLAG_RESIZEABLE: resizeable = enabled; break;
|
|
default: return Result(ERR_BADOPTION);
|
|
}
|
|
return Result(OK);
|
|
}
|
|
|
|
int DirectX::GetSurface(Pixel** pixels)
|
|
{
|
|
using namespace Detail;
|
|
if (!surface) return Result(ERR_UNKNOWN);
|
|
if (bitDepth == 3)
|
|
{
|
|
*pixels = (Pixel*)surface;
|
|
return Result(OK);
|
|
}
|
|
return Result(ERR_UNSUPPORTED);
|
|
}
|
|
|
|
int DirectX::GetRect(int rectOption, Rect* rect)
|
|
{
|
|
switch (rectOption)
|
|
{
|
|
case OPT_RECT_DISPLAY: GetDisplayArea(rect); break;
|
|
case OPT_RECT_SURFACE: GetSurfaceArea(rect); break;
|
|
default: return Result(ERR_BADOPTION);
|
|
}
|
|
return Result(OK);
|
|
}
|
|
|
|
int DirectX::LockSurface()
|
|
{
|
|
using namespace Detail;
|
|
|
|
CheckSurfaces();
|
|
|
|
HRESULT hr;
|
|
DDSURFACEDESC ddsd; // A structure to describe the surfaces we want
|
|
memset(&ddsd, 0, sizeof(ddsd)); // Clear all members of the structure to 0
|
|
ddsd.dwSize = sizeof(ddsd); // The first parameter of the structure must contain the size of the structure
|
|
|
|
// Lock entire surface, wait if it is busy, return surface memory pointer
|
|
hr = g_pDDSBack->Lock(nullptr, &ddsd, DDLOCK_WAIT | DDLOCK_SURFACEMEMORYPTR, nullptr);
|
|
if (hr == E_FAIL) return ERR_CANTLOCK;
|
|
if (FAILED(hr)) return Result(ERR_UNKNOWN);
|
|
|
|
switch (ddsd.ddpfPixelFormat.dwRGBBitCount)
|
|
{
|
|
case 8:
|
|
surfacePitch = ddsd.lPitch;
|
|
bitDepth = 0;
|
|
break;
|
|
case 15:
|
|
case 16:
|
|
surfacePitch = ddsd.lPitch / 2;
|
|
bitDepth = 1;
|
|
break;
|
|
case 24:
|
|
MessageBox(nullptr, "24 Bit color is currently unsupported", "Ok", 0);
|
|
exit(0);
|
|
surfacePitch = ddsd.lPitch;
|
|
bitDepth = 2;
|
|
break;
|
|
case 32:
|
|
surfacePitch = ddsd.lPitch / 4;
|
|
bitDepth = 3;
|
|
break;
|
|
default:
|
|
MessageBox(nullptr, "Unsupported Color Depth!", "Error", 0);
|
|
return 1;
|
|
break;
|
|
}
|
|
if (ddsd.lpSurface == nullptr)
|
|
MessageBox(nullptr, "Returning NULL!!", "ok", 0);
|
|
|
|
surface = ddsd.lpSurface;
|
|
state->SetSurface(surface, bitDepth, surfacePitch);
|
|
|
|
return Result(OK);
|
|
}
|
|
|
|
int DirectX::UnlockSurface()
|
|
{
|
|
using namespace Detail;
|
|
|
|
HRESULT hr;
|
|
hr = g_pDDSBack->Unlock(nullptr);
|
|
surface = nullptr;
|
|
if (FAILED(hr)) return Result(ERR_UNKNOWN);
|
|
|
|
return Result(OK);
|
|
}
|
|
|
|
void DirectX::GetSurfaceArea(Rect* rect) const
|
|
{
|
|
rect->x = 0;
|
|
rect->y = 0;
|
|
rect->w = 640;
|
|
rect->h = 480;
|
|
}
|
|
|
|
void DirectX::GetDisplayArea(Rect* rect) const
|
|
{
|
|
using namespace Detail;
|
|
rect->x = (float)ForcedAspectBorderPadding.x;
|
|
rect->y = (float)ForcedAspectBorderPadding.y;
|
|
rect->w = 640;
|
|
rect->h = 480;
|
|
}
|
|
|
|
void DirectX::CheckSurfaces() const
|
|
{
|
|
using namespace Detail;
|
|
|
|
if (g_pDDS) // Check the primary surface
|
|
if (g_pDDS->IsLost() == DDERR_SURFACELOST)
|
|
g_pDDS->Restore();
|
|
|
|
if (g_pDDSBack) // Check the back buffer
|
|
if (g_pDDSBack->IsLost() == DDERR_SURFACELOST)
|
|
g_pDDSBack->Restore();
|
|
|
|
}
|
|
|
|
int DirectX::RenderSignalLostMessage()
|
|
{
|
|
using namespace Detail;
|
|
static unsigned short TextX = rand() % 580, TextY = rand() % 470;
|
|
static unsigned char Counter, Counter1 = 32;
|
|
static char Phase = 1;
|
|
static char Message[] = " Signal Missing! Press F9";
|
|
|
|
HDC hdc;
|
|
g_pDDSBack->GetDC(&hdc);
|
|
SetBkColor(hdc, 0);
|
|
SetTextColor(hdc, RGB(Counter1 << 2, Counter1 << 2, Counter1 << 2));
|
|
TextOut(hdc, TextX, TextY, Message, strlen(Message));
|
|
Counter++;
|
|
Counter1 += Phase;
|
|
if (Counter1 == 60 || Counter1 == 20)
|
|
Phase = -Phase;
|
|
Counter %= 60; //about 1 seconds
|
|
if (!Counter)
|
|
{
|
|
TextX = rand() % 580;
|
|
TextY = rand() % 470;
|
|
}
|
|
g_pDDSBack->ReleaseDC(hdc);
|
|
return Result(OK);
|
|
}
|
|
|
|
int DirectX::RenderStatusLine(char * statusText)
|
|
{
|
|
using namespace Detail;
|
|
size_t Index = 0;
|
|
HDC hdc;
|
|
//Put StatusText for full screen here
|
|
if (isFullscreen)
|
|
{
|
|
g_pDDSBack->GetDC(&hdc);
|
|
SetBkColor(hdc, RGB(0, 0, 0));
|
|
SetTextColor(hdc, RGB(255, 255, 255));
|
|
Index = strlen(statusText);
|
|
for (;Index < 132;Index++)
|
|
statusText[Index] = 32;
|
|
statusText[Index] = 0;
|
|
TextOut(hdc, 0, 0, statusText, 132);
|
|
g_pDDSBack->ReleaseDC(hdc);
|
|
}
|
|
return Result(OK);
|
|
}
|
|
}
|
|
|
|
#endif // USE_DIRECTX
|
|
|