// 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 . // // 2025/04/10 - Craig Allsop - Add OpenGL rendering. // #include "OpenGL.h" #include "../../src/core/BuildConfig.h" #include #include #include #include "GL/glext.h" #include "GL/wglext.h" #include #if USE_OPENGL #if USE_DEBUG_LINES #include #endif typedef HGLRC(WINAPI* wglprocCreateContextAttribsARB)(HDC, HGLRC, const int*); typedef BOOL(WINAPI* wglprocChoosePixelFormatARB)(HDC, const int*, const FLOAT*, UINT, int*, UINT*); typedef BOOL(WINAPI* wglprocSwapIntervalEXT)(int interval); #pragma comment(lib, "opengl32.lib") #pragma comment(lib, "glu32") static const LPCSTR ViewClass = "VCC_ViewWnd"; static const LPCSTR OpenGLClass = "VCC_OpenGLWnd"; namespace VCC { // // Private wrapper on result code for logging errors // static int Result(int code) { if (code != OpenGL::OK) { char message[256]; snprintf(message,64,"OpenGL error %d\nCheck OpenGL 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; } // // Impliementation detail of OpenGL interface. // struct OpenGL::Detail { const int SubClassId = 1; const int GLSubClassId = 2; const int SurfaceWidth = 640; // coco surface size const int SurfaceHeight = 480; const float PalFreq = 60.0f; const float NtscFreq = 50.0f; bool isInitialized; // if already initialized HWND hWnd; // window handle of OpenGL window HDC hDC; // its context HGLRC hRC; int width; // width of OpenGL window int height; // height of OpenGL window int statusHeight; // height of status bar bool aspect; // true if aspect preserved, otherwise fit bool ntsc; // use ntsc 50hz, otherwise 60hz Pixel* pixels; // cpu side surface buffer GLuint texId; // OpenGL texture on gpu wglprocSwapIntervalEXT wglSwapIntervalEXT; ISystemState* state; #if USE_DEBUG_LINES struct Line { float x1; float y1; float x2; float y2; Pixel color; }; std::vector debugLines; struct Box { float x1; float y1; float w; float h; Pixel color; bool filled; }; std::vector debugBoxes; struct Text { const OpenGLFont* font; float x1; float y1; float size; std::string str; Pixel color; }; std::vector debugTexts; #endif // USE_DEBUG_LINES OpenGL::Detail(ISystemState *state) : isInitialized(false), hWnd(nullptr), hDC(nullptr), hRC(nullptr) , width(0), height(0), statusHeight(0), aspect(true), ntsc(false) , pixels(nullptr), texId(0), wglSwapIntervalEXT(nullptr), state(state) { } // intercepted parent window messages static LRESULT __stdcall SubclassProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam, UINT_PTR uIdSubclass, DWORD_PTR dwRefData) { switch (uMsg) { case WM_ERASEBKGND: return 1; case WM_SIZE: { auto detail = reinterpret_cast(dwRefData); detail->Resize(LOWORD(lParam), HIWORD(lParam)); break; } case WM_NCDESTROY: RemoveWindowSubclass(hWnd, &SubclassProc, uIdSubclass); break; }; return DefSubclassProc(hWnd, uMsg, wParam, lParam); } static LRESULT __stdcall GLSubclassProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam, UINT_PTR uIdSubclass, DWORD_PTR dwRefData) { switch (uMsg) { case WM_ERASEBKGND: return 1; // prevent child window taking mouse messages case WM_NCHITTEST: return HTTRANSPARENT; case WM_NCDESTROY: RemoveWindowSubclass(hWnd, &SubclassProc, uIdSubclass); break; }; return DefSubclassProc(hWnd, uMsg, wParam, lParam); } void Resize(int width, int height) { // windows callback with client size, leave space for status bar. height -= statusHeight; this->width = width; this->height = height; if (hWnd) SetWindowPos(hWnd, nullptr, 0, 0, width, height, SWP_NOCOPYBITS); } int Setup(void* hwnd, int width, int height, int statusHeight) { if (isInitialized) return Result(ERR_INITIALIZED); HWND hTempWnd = nullptr; HDC hTempDC = nullptr; HGLRC hTempRC = nullptr; auto hInstance = GetModuleHandle(nullptr); auto cleanupTempWindow = [&](int err) { if (hTempRC) { wglMakeCurrent(nullptr, nullptr); wglDeleteContext(hTempRC); } if (hTempDC) ReleaseDC(hTempWnd, hTempDC); if (hTempWnd) DestroyWindow(hTempWnd); UnregisterClass(ViewClass, hInstance); return err; }; auto cleanupWindow = [&](int err) { Cleanup(); return cleanupTempWindow(err); }; this->width = width; this->height = height; this->statusHeight = statusHeight; WNDCLASS wc; memset(&wc, 0, sizeof(wc)); wc.style = CS_HREDRAW | CS_VREDRAW | CS_OWNDC; wc.lpfnWndProc = DefWindowProc; wc.hInstance = GetModuleHandle(nullptr); wc.lpszClassName = ViewClass; if (!RegisterClass(&wc)) return ERR_TMPREGISTERCLASS; // Create a temporary context to get address of wgl extensions. hTempWnd = CreateWindowEx(WS_EX_APPWINDOW, ViewClass, "Simple", WS_VISIBLE | WS_POPUP | WS_MAXIMIZE, 0, 0, 0, 0, nullptr, nullptr, hInstance, nullptr); if (!hTempWnd) return Result(ERR_TMPCREATEWINDOW); hTempDC = GetDC(hTempWnd); if (!hTempDC) return Result(cleanupTempWindow(ERR_TMPGETDC)); PIXELFORMATDESCRIPTOR pfd; memset(&pfd, 0, sizeof(pfd)); pfd.nSize = sizeof(pfd); pfd.nVersion = 1; pfd.dwFlags = PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER | PFD_DRAW_TO_WINDOW; pfd.cColorBits = 24; pfd.iPixelType = PFD_TYPE_RGBA; pfd.iLayerType = PFD_MAIN_PLANE; int iPF; if (!(iPF = ChoosePixelFormat(hTempDC, &pfd))) return Result(cleanupTempWindow(ERR_TMPCHOOSEFORMAT)); if (!SetPixelFormat(hTempDC, iPF, &pfd)) return Result(cleanupTempWindow(ERR_TMPSETPIXELFORMAT)); if (!(hTempRC = wglCreateContext(hTempDC))) return Result(cleanupTempWindow(ERR_TMPCREATECONTEXT)); if (!wglMakeCurrent(hTempDC, hTempRC)) return Result(cleanupTempWindow(ERR_TMPMAKECONTEXT)); // Function pointers returned by wglGetProcAddress are tied to the render context they were obtained with. wglprocCreateContextAttribsARB wglCreateContextAttribsARB = (wglprocCreateContextAttribsARB)wglGetProcAddress("wglCreateContextAttribsARB"); wglprocChoosePixelFormatARB wglChoosePixelFormatARB = (wglprocChoosePixelFormatARB)wglGetProcAddress("wglChoosePixelFormatARB"); wglSwapIntervalEXT = (wglprocSwapIntervalEXT)wglGetProcAddress("wglSwapIntervalEXT"); if (wglChoosePixelFormatARB && wglCreateContextAttribsARB && wglSwapIntervalEXT) { WNDCLASS wc = { 0 }; wc.lpfnWndProc = DefWindowProc; wc.hInstance = hInstance; wc.hbrBackground = nullptr; wc.lpszClassName = OpenGLClass; wc.style = CS_OWNDC; if (!RegisterClass(&wc)) return Result(cleanupTempWindow(ERR_REGISTERCLASS)); SetWindowSubclass((HWND)hwnd, &SubclassProc, SubClassId, (DWORD_PTR)this); hWnd = CreateWindowEx(0, OpenGLClass, nullptr, WS_VISIBLE | WS_CHILD, 0, 0, width, height, (HWND)hwnd, 0, hInstance, this); if (!hWnd) { UnregisterClass(OpenGLClass, hInstance); return Result(cleanupTempWindow(ERR_CREATEWINDOW)); } SetWindowSubclass((HWND)hWnd, &GLSubclassProc, GLSubClassId, (DWORD_PTR)this); hDC = GetDC(hWnd); if (!hDC) return Result(cleanupWindow(ERR_GETDC)); int attribs[] = { WGL_DRAW_TO_WINDOW_ARB, TRUE, WGL_DOUBLE_BUFFER_ARB, TRUE, WGL_SUPPORT_OPENGL_ARB, TRUE, WGL_PIXEL_TYPE_ARB, WGL_TYPE_RGBA_ARB, WGL_COLOR_BITS_ARB, 24, WGL_RED_BITS_ARB, 8, WGL_GREEN_BITS_ARB, 8, WGL_BLUE_BITS_ARB, 8, WGL_DEPTH_BITS_ARB, 0, WGL_STENCIL_BITS_ARB, 0, 0, 0 }; UINT numFormats; BOOL success = wglChoosePixelFormatARB(hDC, attribs, nullptr, 1, &iPF, &numFormats); DescribePixelFormat(hDC, iPF, sizeof(pfd), &pfd); if (!(success && numFormats >= 1 && SetPixelFormat(hDC, iPF, &pfd))) return Result(cleanupWindow(ERR_SETPIXELFORMAT)); // request OpenGl 3.0 int contextAttribs[] = { WGL_CONTEXT_MAJOR_VERSION_ARB, 3, WGL_CONTEXT_MINOR_VERSION_ARB, 0, 0, 0 }; hRC = wglCreateContextAttribsARB(hDC, nullptr, contextAttribs); if (!hRC) return Result(cleanupWindow(ERR_GLVERSION)); // release temporary window cleanupTempWindow(OK); } else return Result(ERR_MISSINGAPIS); // the off screen surface pixels = new Pixel[SurfaceWidth * SurfaceHeight]; memset(pixels, 0, SurfaceWidth * SurfaceHeight * sizeof(Pixel)); // create texture for rendering surface wglMakeCurrent(hDC, hRC); glViewport(0, 0, width, height); glGenTextures(1, &texId); glBindTexture(GL_TEXTURE_2D, texId); glEnable(GL_TEXTURE_2D); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, SurfaceWidth, SurfaceHeight, 0, GL_BGRA, GL_UNSIGNED_BYTE, pixels); wglMakeCurrent(nullptr, nullptr); isInitialized = true; return Result(OK); } int Render() { if (!isInitialized) return Result(ERR_NOTINITIALIZED); wglMakeCurrent(hDC, hRC); glViewport(0, 0, width, height); glMatrixMode(GL_PROJECTION); glLoadIdentity(); glOrtho(0, (float)width, (float)height, 0, -1, 1); glMatrixMode(GL_MODELVIEW); glLoadIdentity(); // select surface texture glBindTexture(GL_TEXTURE_2D, texId); glEnable(GL_TEXTURE_2D); // update it glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, SurfaceWidth, SurfaceHeight, GL_BGRA, GL_UNSIGNED_BYTE, pixels); Rect area; GetDisplayArea(&area); // aliases - don't panic const auto& x = area.x; const auto& y = area.y; const auto& w = area.w; const auto& h = area.h; // draw main surface in the middle glColor3f(1, 1, 1); glBegin(GL_QUADS); glTexCoord2f(0, 0); glVertex3f(x, y, 0); glTexCoord2f(1, 0); glVertex3f(x + w, y, 0); glTexCoord2f(1, 1); glVertex3f(x + w, y + h, 0); glTexCoord2f(0, 1); glVertex3f(x, y + h, 0); glEnd(); #if USE_BLACKEDGES // Switch to black color for edges glDisable(GL_TEXTURE_2D); #define glTexCoord2f(a,b) glColor3f(0,0,0) #endif // USE_BLACKEDGES glBegin(GL_QUADS); if (x > 0) { // fill left/right edge glTexCoord2f(0, 0); glVertex3f(0, 0, 0); glTexCoord2f(0, 0); glVertex3f(x, 0, 0); glTexCoord2f(0, 1); glVertex3f(x, h, 0); glTexCoord2f(0, 1); glVertex3f(0, h, 0); glTexCoord2f(1, 0); glVertex3f(x + w, y, 0); glTexCoord2f(1, 0); glVertex3f((float)width, y, 0); glTexCoord2f(1, 1); glVertex3f((float)width, y + h, 0); glTexCoord2f(1, 1); glVertex3f(x + w, y + h, 0); } else if (y > 0) { // fill top/bottom edge glTexCoord2f(0, 0); glVertex3f(0, 0, 0); glTexCoord2f(1, 0); glVertex3f(w, 0, 0); glTexCoord2f(1, 0); glVertex3f(w, y, 0); glTexCoord2f(0, 0); glVertex3f(0, y, 0); glTexCoord2f(0, 1); glVertex3f(0, y + h, 0); glTexCoord2f(1, 1); glVertex3f(w, y + h, 0); glTexCoord2f(1, 1); glVertex3f(w, (float)height, 0); glTexCoord2f(0, 1); glVertex3f(0, (float)height, 0); } #if USE_BLACKEDGES #undef glTexCoord2f #endif // USE_BLACKEDGES glEnd(); #if USE_DEBUG_LINES if (debugBoxes.size()) { Pixel lastColor(debugBoxes[0].color); glEnable(GL_BLEND); glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); glColor4ub(lastColor.r, lastColor.g, lastColor.b, lastColor.a); for (size_t i = 0; i < debugBoxes.size(); ++i) { auto x = debugBoxes[i].x1; auto y = debugBoxes[i].y1; auto w = debugBoxes[i].w; auto h = debugBoxes[i].h; if (lastColor != debugBoxes[i].color) { lastColor = debugBoxes[i].color; glColor4ub(lastColor.r, lastColor.g, lastColor.b, lastColor.a); } if (debugBoxes[i].filled) { glBegin(GL_QUADS); glVertex3f(x, y, 0); glVertex3f(x + w, y, 0); glVertex3f(x + w, y + h, 0); glVertex3f(x, y + h, 0); glEnd(); } else { glBegin(GL_LINES); glVertex3f(x, y, 0); glVertex3f(x + w, y, 0); glVertex3f(x + w, y, 0); glVertex3f(x + w, y + h, 0); glVertex3f(x + w, y + h, 0); glVertex3f(x, y + h, 0); glVertex3f(x, y + h, 0); glVertex3f(x, y, 0); glEnd(); } } glDisable(GL_BLEND); debugBoxes.clear(); } // draw some debug lines if (debugLines.size()) { Pixel lastColor(debugLines[0].color); glEnable(GL_BLEND); glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); glBegin(GL_LINES); glColor4ub(lastColor.r, lastColor.g, lastColor.b, lastColor.a); for (size_t i = 0; i < debugLines.size(); ++i) { if (lastColor != debugLines[i].color) { lastColor = debugLines[i].color; glColor4ub(lastColor.r, lastColor.g, lastColor.b, lastColor.a); } glVertex3f(debugLines[i].x1, debugLines[i].y1, 0); glVertex3f(debugLines[i].x2, debugLines[i].y2, 0); } glEnd(); glDisable(GL_BLEND); debugLines.clear(); } if (debugTexts.size()) { for (auto &t : debugTexts) { RenderText(t.font, t.x1, t.y1, t.size, t.str.c_str()); } debugTexts.clear(); } #endif // USE_DEBUG_LINES wglMakeCurrent(nullptr, nullptr); return Result(OK); } int Cleanup() { if (!isInitialized) return Result(ERR_NOTINITIALIZED); if (pixels) delete[] pixels; if (hDC) ReleaseDC(hWnd, hDC); if (hWnd) DestroyWindow(hWnd); UnregisterClass(OpenGLClass, GetModuleHandle(nullptr)); isInitialized = false; return Result(OK); } int GetSurface(Pixel** pixels) const { if (!isInitialized) return Result(ERR_NOTINITIALIZED); *pixels = this->pixels; return Result(OK); } int SetOption(int option, bool enabled) { if (!isInitialized) return Result(ERR_NOTINITIALIZED); switch (option) { case OPT_FLAG_ASPECT: aspect = enabled; break; case OPT_FLAG_NTSC: ntsc = enabled; break; case OPT_FLAG_RESIZEABLE: break; default: return Result(ERR_BADOPTION); } return Result(OK); } int GetRect(int rectOption, Rect* rect) { if (!isInitialized) return Result(ERR_NOTINITIALIZED); switch (rectOption) { case OPT_RECT_DISPLAY: GetDisplayArea(rect); break; case OPT_RECT_RENDER: GetRenderArea(rect); break; case OPT_RECT_SURFACE: GetSurfaceArea(rect); break; default: return Result(ERR_BADOPTION); } return Result(OK); } int RenderText(const OpenGLFont* font, float x, float y, float size, const char* text) const { if (!isInitialized) return Result(ERR_NOTINITIALIZED); int length = strlen(text); wglMakeCurrent(hDC, hRC); glViewport(0, 0, width, height); glMatrixMode(GL_PROJECTION); glLoadIdentity(); glOrtho(0, (float)width, (float)height, 0, -1, 1); glMatrixMode(GL_MODELVIEW); glLoadIdentity(); glBindTexture(GL_TEXTURE_2D, font->texture); glEnable(GL_TEXTURE_2D); glBegin(GL_QUADS); glColor3f(1, 1, 1); for (int i = 0; i < length; ++i) { auto ch = text[i]; if (ch < font->start || ch >= font->end) continue; const auto glyph = font->glyphs + ch - font->start; if (ch != ' ') { const auto &ad = glyph->atlasDimensions; const auto& d = glyph->dimensions; float u1 = ad.l / font->textureWidth; float v1 = ad.b / font->textureHeight; float u2 = ad.r / font->textureWidth; float v2 = ad.t / font->textureHeight; glTexCoord2f(u1, v1); glVertex3f(x + size * d.l, y + size * d.b, 0); glTexCoord2f(u2, v1); glVertex3f(x + size * d.r, y + size * d.b, 0); glTexCoord2f(u2, v2); glVertex3f(x + size * d.r, y + size * d.t, 0); glTexCoord2f(u1, v2); glVertex3f(x + size * d.l, y + size * d.t, 0); } x += glyph->advance * size; } glEnd(); wglMakeCurrent(nullptr, nullptr); return Result(OK); } int Present() const { if (!isInitialized) return Result(ERR_NOTINITIALIZED); wglMakeCurrent(hDC, hRC); // present glFlush(); // don't sync with monitor, if monitor is 30hz we want vcc // running at 60 still, refresh is controlled in throttle. wglSwapIntervalEXT(0); SwapBuffers(hDC); wglMakeCurrent(nullptr, nullptr); return Result(OK); } int LoadFont(const OpenGLFont** outFont, int bitmapRes, const OpenGLFontGlyph* glyphs, int start, int end) const { *outFont = nullptr; if (!isInitialized) return Result(ERR_NOTINITIALIZED); HBITMAP hBitmap = nullptr; HDC dcBitmap = nullptr; COLORREF* bitmapPixels = nullptr; auto cleanup = [&](int code) { if (hBitmap) DeleteObject(hBitmap); if (dcBitmap) ReleaseDC(nullptr, dcBitmap); if (bitmapPixels) delete bitmapPixels; return code; }; // load bitmap resource auto hInstance = GetModuleHandle(nullptr); hBitmap = LoadBitmap(hInstance, MAKEINTRESOURCE(bitmapRes)); if (!hBitmap) return Result(cleanup(ERR_FONTHBITMAP)); dcBitmap = CreateCompatibleDC(nullptr); if (!dcBitmap) return Result(cleanup(ERR_FONTDC)); SelectObject(dcBitmap, hBitmap); BITMAP bm; ::GetObject(hBitmap, sizeof(bm), &bm); BITMAPINFO bmpInfo; bmpInfo.bmiHeader.biSize = sizeof(BITMAPINFOHEADER); bmpInfo.bmiHeader.biWidth = bm.bmWidth; bmpInfo.bmiHeader.biHeight = -bm.bmHeight; bmpInfo.bmiHeader.biPlanes = 1; bmpInfo.bmiHeader.biBitCount = 24; bmpInfo.bmiHeader.biCompression = BI_RGB; bmpInfo.bmiHeader.biSizeImage = 0; // get bitmap data bitmapPixels = new COLORREF[bm.bmWidth * bm.bmHeight]; if (GetDIBits(dcBitmap, hBitmap, 0, bm.bmHeight, bitmapPixels, &bmpInfo, DIB_RGB_COLORS) == 0) return Result(cleanup(ERR_FONTGETDIBITS)); // upload texture GLuint textureId = 0; wglMakeCurrent(hDC, hRC); glGenTextures(1, &textureId); glBindTexture(GL_TEXTURE_2D, textureId); glEnable(GL_TEXTURE_2D); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_GENERATE_MIPMAP, GL_TRUE); glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, bm.bmWidth, bm.bmHeight, 0, GL_BGR, GL_UNSIGNED_BYTE, bitmapPixels); if (glGetError()) return Result(cleanup(ERR_FONTTEXIMAGE2D)); wglMakeCurrent(nullptr, nullptr); // allocate font OpenGLFont* font = new OpenGLFont(); font->glyphs = glyphs; font->start = start; font->end = end; font->texture = textureId; font->textureWidth = (float)bm.bmWidth; font->textureHeight = (float)bm.bmHeight; *outFont = font; return Result(cleanup(OK)); } #if USE_DEBUG_LINES void DebugDrawLine(float x1, float y1, float x2, float y2, Pixel color) { debugLines.push_back({ x1, y1, x2, y2, color }); } void DebugDrawText(const OpenGLFont* font, float x, float y, float size, const char* text, Pixel color) { debugTexts.push_back({ font, x, y, size, text, color }); } void DebugDrawBox(float x1, float y1, float w, float h, Pixel color, bool filled) { debugBoxes.push_back({ x1, y1, w, h, color, filled }); } #endif // USE_DEBUG_LINES int RenderBox(float x, float y, float w, float h, Pixel color, bool filled) const { if (!isInitialized) return Result(ERR_NOTINITIALIZED); float x2 = x + w; float y2 = y + h; wglMakeCurrent(hDC, hRC); glViewport(0, 0, width, height); glMatrixMode(GL_PROJECTION); glLoadIdentity(); glOrtho(0, (float)width, (float)height, 0, -1, 1); glMatrixMode(GL_MODELVIEW); glLoadIdentity(); glColor3ub(color.r, color.g, color.b); if (filled) { glBegin(GL_QUADS); glVertex3f(x, y, 0); glVertex3f(x + w, y, 0); glVertex3f(x + w, y + h, 0); glVertex3f(x, y + h, 0); glEnd(); } else { glBegin(GL_LINES); glVertex3f(x, y, 0); glVertex3f(x + w, y, 0); glVertex3f(x + w, y, 0); glVertex3f(x + w, y + h, 0); glVertex3f(x + w, y + h, 0); glVertex3f(x, y + h, 0); glVertex3f(x, y + h, 0); glVertex3f(x, y, 0); glEnd(); } wglMakeCurrent(nullptr, nullptr); return Result(OK); } int LockSurface() { if (!isInitialized) return Result(ERR_NOTINITIALIZED); state->SetSurface(pixels, 3, DefaultWidth); return Result(OK); } private: // returns the box where display should be rendered void GetDisplayArea(Rect* area) const { area->w = (float)width; area->h = (float)height; // scale to fit display with aspect kept if (aspect) { // keep aspect ratio, ntsc = 50hz float freqScale = ntsc ? PalFreq / NtscFreq : 1.0f; float dw = (float)SurfaceWidth; float dh = (float)SurfaceHeight * freqScale; float rx = area->w / dw; float ry = area->h / dh; float r = rx > ry ? ry : rx; area->w = r * dw; area->h = r * dh; } // center on display area->x = (width - area->w) / 2.0f; area->y = (height - area->h) / 2.0f; } void GetRenderArea(Rect* area) const { area->x = area->y = 0; area->w = (float)width; area->h = (float)height; } void GetSurfaceArea(Rect* area) const { area->x = area->y = 0; area->w = (float)SurfaceWidth; area->h = (float)SurfaceHeight; } }; ////////////////////////////////////////////////////////////////////////////////////////////////// // // Forwarding functions to implementation. // int OpenGL::GetSurface(Pixel** pixels) { if (detail) return detail->GetSurface(pixels); return Result(ERR_NOTINITIALIZED); } int OpenGL::Setup(void* hwnd, int width, int height, int statusHeight, bool fullscreen) { detail = new Detail(state); return detail->Setup(hwnd, width, height, statusHeight); } int OpenGL::Render() { if (detail) return detail->Render(); return Result(ERR_NOTINITIALIZED); } int OpenGL::Cleanup() { if (detail) { int result = detail->Cleanup(); delete detail; detail = nullptr; return result; } return Result(ERR_NOTINITIALIZED); } int OpenGL::Present() { if (detail) return detail->Present(); return Result(ERR_NOTINITIALIZED); } int OpenGL::SetOption(int option, bool enabled) { if (detail) return detail->SetOption(option, enabled); return Result(ERR_NOTINITIALIZED); } int OpenGL::RenderBox(float x, float y, float w, float h, Pixel color, bool filled) { if (detail) return detail->RenderBox(x,y,w,h,color,filled); return Result(ERR_NOTINITIALIZED); } int OpenGL::GetRect(int rectOption, Rect* area) { if (detail) return detail->GetRect(rectOption, area); return Result(ERR_NOTINITIALIZED); } int OpenGL::RenderText(const OpenGLFont* font, float x, float y, float size, const char* text) { if (detail) return detail->RenderText(font, x, y, size, text); return Result(ERR_NOTINITIALIZED); } int OpenGL::LoadFont(const OpenGLFont** outFont, int bitmapRes, const OpenGLFontGlyph* glyphs, int start, int end) { if (detail) return detail->LoadFont(outFont, bitmapRes, glyphs, start, end); return Result(ERR_NOTINITIALIZED); } int OpenGL::LockSurface() { if (detail) return detail->LockSurface(); return Result(ERR_NOTINITIALIZED); } ////////////////////////////////////////////////////////////////////////////////////////////////// void OpenGL::DebugDrawText(const OpenGLFont* font, float x, float y, float size, const char* text, Pixel color) { #if USE_DEBUG_LINES if (detail) detail->DebugDrawText(font, x, y, size, text, color); #endif } void OpenGL::DebugDrawLine(float x1, float y1, float x2, float y2, Pixel color) { #if USE_DEBUG_LINES if (detail) detail->DebugDrawLine(x1, y1, x2, y2, color); #endif // USE_DEBUG_LINES } void OpenGL::DebugDrawBox(float x, float y, float w, float h, Pixel color, bool filled) { #if USE_DEBUG_LINES if (detail) detail->DebugDrawBox(x, y, w, h, color, filled); /* { float x2 = x + w; float y2 = y + h; detail->RenderBox(x, y, x2 - x, y2 - y, color, filled); //detail->DebugDrawLine(x, y, x2, y, color); //detail->DebugDrawLine(x2, y, x2, y2, color); //detail->DebugDrawLine(x2, y2, x, y2, color); //detail->DebugDrawLine(x, y2, x, y, color); } */ #endif // USE_DEBUG_LINES } } #endif // USE_OPENGL