Loading a window texture from a HWND into an OpenGL texture

Question

So what I'm trying to accomplish is getting a handle to a window by name (e.g. Slack) and copying that windows pixel information into an OpenGL texture.

I've been basically learning C++ and OpenGL as I've been trying to accomplish this. Before this I had mostly worked with Java.
I managed to load a picture of a cute kitten into a texture and display that on a quad.
I've also found a HWND handle to a specific window.

The problem I have is loading the pixel information from the window and displaying it on a quad. The end goal is to use the texture somewhere else but to make sure that I'm getting the texture I'm displaying it on a quad.

---

The Problem
Below in WindowTextureFactory there are two functions I managed to puzzle together from several sources. I'm sure that's the source of my error. The first one, CreateVideoTexture(...) causes the following error:

Exception thrown at 0x0F61615B (ucrtbased.dll) in program.exe: 0xC0000005:
Access violation reading location 0x0518FFF0.

When I use the data a little later in TextureLoader in this line
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, width, height, 0, GL_RGB, GL_UNSIGNED_BYTE, data);

While the second one, CreateVideoTextureAlt(...), seemingly does nothing. I simply get a black quad.

So what am I doing wrong?

---

I've included a lot of code and I might be going into to much detail. I've spent a lot of time getting to where I am right now and I want to make sure I'm not making a mistake somewhere.

- WindowManager -

To start there's the WindowManager that finds the HWND to a specific window. I've hard-coded "spotify" as a window name to begin with.

#include "WindowManager.h"

HWND mHwnd;
BOOL CALLBACK EnumWindowsProc(HWND hwnd, LPARAM lParam);

WindowManager::WindowManager()
{
    EnumWindows(EnumWindowsProc, NULL);
}

SIZE WindowManager::getSizeForHwnd(HWND hwnd)
{
    RECT rect;
    SIZE size;
    BOOL success = GetWindowRect(hwnd, &rect);

    if (!success)
    {
        int errorCode = GetLastError();
        std::cout << "Call failed to GetWindowRect() with error code: " + std::to_string(errorCode) << std::endl;
    }

    size.cx = rect.right - rect.left;
    size.cy = rect.bottom - rect.top;

    std::cout << "Size: " << size.cx << "x" << size.cy << std::endl;

    return size;
}

HWND WindowManager::getHwnd()
{
    return mHwnd;
}

BOOL CALLBACK EnumWindowsProc(HWND hwnd, LPARAM lParam)
{
    char class_name[80];
    char title[80];

    GetWindowText(hwnd, title, sizeof(title));

    std::string x = title;

    std::transform(x.begin(), x.end(), x.begin(), ::tolower);

    if (!x.compare("spotify"))
    {
        mHwnd = hwnd;
    }

    return TRUE;
}

Using this class like so

WindowManager wManager;
HWND hwnd = wManager.getHwnd();
SIZE size = wManager.getSizeForHwnd(hwnd);

I now have a handle to the Spotify window. The SIZE value changes accordingly if I resize the Spotify window and run the program again.

- WindowTextureFactory -

#include "WindowTextureFactory.h"

WindowTextureFactory::WindowTextureFactory() { }

WindowTextureFactory::~WindowTextureFactory() { }

unsigned char* WindowTextureFactory::CreateVideoTexture(HWND hwnd, SIZE bmpSize)
{
    if (!bmpSize.cx || !bmpSize.cy)
    {
        std::cout << "Error creating window texture in CreateVideoTexture(...)" << std::endl;
        return nullptr;
    }

    BITMAPINFO bmi;
    auto& hdr = bmi.bmiHeader;
    hdr.biSize = sizeof(bmi.bmiHeader);
    hdr.biWidth = bmpSize.cx;
    hdr.biHeight = -bmpSize.cy;
    hdr.biPlanes = 1;
    hdr.biBitCount = 32;
    hdr.biCompression = BI_RGB;
    hdr.biSizeImage = 0;
    hdr.biXPelsPerMeter = 0;
    hdr.biYPelsPerMeter = 0;
    hdr.biClrUsed = 0;
    hdr.biClrImportant = 0;

    unsigned char* bitmapBits;
    HDC hdc = GetWindowDC(hwnd);
    HDC hBmpDc = CreateCompatibleDC(hdc);

    BITMAP bm;
    HBITMAP hBmp = CreateDIBSection(hdc, &bmi, DIB_RGB_COLORS, (void**) &bitmapBits, nullptr, 0);

    SelectObject(hBmpDc, hBmp);

    BOOL success = BitBlt(hBmpDc, 0, 0, bmpSize.cx, bmpSize.cy, hdc, 0, 0, SRCCOPY);

    if (!success)
    {
        std::cout << "BitBlt failed" << std::endl;
    }

    return bitmapBits;
}

unsigned char* WindowTextureFactory::CreateVideoTextureAlt(HWND hwnd, SIZE bmpSize)
{
    HDC hdc = GetDC(hwnd);
    HDC hBmpDc = CreateCompatibleDC(hdc);

    BITMAP bmp;
    HBITMAP hBmp = CreateCompatibleBitmap(hBmpDc, bmpSize.cx, bmpSize.cy);

    GetObject(hBmp, sizeof(BITMAP), &bmp);
    SelectObject(hBmpDc, hBmp);

    BOOL success = BitBlt(hBmpDc, 0, 0, bmpSize.cx, bmpSize.cy, hdc, 0, 0, SRCCOPY);

    if (!success)
    {
        std::cout << "BitBlt failed" << std::endl;
    }

    return (unsigned char*) bmp.bmBits;
}

- TextureLoader -

This class a slightly changed version of another one from in2gpu.com's OpenGL guide. It worked perfectly when loading an external .bmp file.

#include "TextureLoader.h"

TextureLoader::TextureLoader() { }

TextureLoader::~TextureLoader() { }

unsigned int TextureLoader::LoadTexture(unsigned char* data, unsigned int width, unsigned int height)
{
    //create the OpenGL texture
    unsigned int gl_texture_object = 0;
    glGenTextures(1, &gl_texture_object);
    glBindTexture(GL_TEXTURE_2D, gl_texture_object);

    //filtering
    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR_MIPMAP_LINEAR);

    float maxAnisotropy;
    glGetFloatv(GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, &maxAnisotropy);
    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAX_ANISOTROPY_EXT, maxAnisotropy);

    //when we work with textures of sizes not divisible by 4 we have to use the line reader
    //which loads the textures in OpenGL so as it can work with a 1 alligned memory (default is 4)
    glPixelStorei(GL_UNPACK_ALIGNMENT, 1);

    //Generates texture
    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, width, height, 0, GL_RGB, GL_UNSIGNED_BYTE, data);

    //eliminates the array from the RAM
    delete data;

    //creates the mipmap hierarchy
    glGenerateMipmap(GL_TEXTURE_2D);

    //returns the texture object
    return gl_texture_object;
}

- Fragment & Vertex Shaders -

Vertex_Shader_T.glsl

#version 450 core

layout(location = 0) in vec3 vert;
layout(location = 1) in vec2 vertTexCoord;
out vec2 fragTexCoord;

void main()
{
    fragTexCoord = vertTexCoord;

    gl_Position = vec4(vert, 1);
}

Fragment_Shader_T.glsl

#version 450 core

uniform sampler2D tex; // texture
in vec2 fragTexCoord; // texture coord
layout(location = 0) out vec4 finalColor; // pixel color output

void main()
{
    finalColor = texture(tex, fragTexCoord);
}

- main -

#pragma once
#include "Core\Shader_Loader.h"
#include "Core\GameModels.h"
#include "Core\TextureLoader.h"
#include "Core\WindowManager.h"
#include "Core\WindowTextureFactory.h"

Models::GameModels* gameModels;
GLuint program;

void renderScene(void)
{
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    glClearColor(0.6f, 0.6f, 0.6f, 1.0f);

    glBindVertexArray(gameModels->GetModel("quad"));
    glUseProgram(program);
    glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
    glutSwapBuffers();
}

void closeCallback()
{
    std::cout << "GLUT:\t Finished" << std::endl;
    glutLeaveMainLoop();
}

void Init()
{
    glEnable(GL_DEPTH_TEST);

    gameModels = new Models::GameModels();
    gameModels->CreateQuadModel("quad");

    // load and compile shaders
    Core::Shader_Loader shaderLoader;
    program = shaderLoader.CreateProgram("Shaders\\Vertex_Shader_T.glsl", "Shaders\\Fragment_Shader_T.glsl");
    glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
}

void texturize()
{
    Core::TextureLoader textureLoader;

    WindowTextureFactory factory;
    WindowManager wManager;
    HWND hwnd = wManager.getHwnd();
    SIZE size = wManager.getSizeForHwnd(hwnd);
    unsigned char* data = factory.CreateVideoTexture(hwnd, size);

    unsigned int texture = textureLoader.LoadTexture(data, size.cx, size.cy);

    GLint loc = glGetUniformLocation(program, "tex");

    if (loc != -1)
    {
        glUniform1f(loc, 0.432f);
    }

    glUniform1i(texture, 0);
    glActiveTexture(GL_TEXTURE0);
    glBindTexture(GL_TEXTURE_2D, texture);
}

int main(int argc, char **argv)
{
    glutInit(&argc, argv);
    glutInitDisplayMode(GLUT_DEPTH | GLUT_DOUBLE | GLUT_RGBA);
    glutInitWindowPosition(500, 500);
    glutInitWindowSize(800, 600);
    glutCreateWindow("OpenGL Window");
    glutSetOption(GLUT_ACTION_ON_WINDOW_CLOSE, GLUT_ACTION_GLUTMAINLOOP_RETURNS);

    glewInit();

    if (glewIsSupported("GL_VERSION_4_5"))
    {
        std::cout << " OpenGL Version is 4.5\n ";
    }
    else
    {
        std::cout << "OpenGL 4.5 not supported\n ";
    }

    Init();

    // Callbacks
    glutDisplayFunc(renderScene);
    glutCloseFunc(closeCallback);

    texturize();

    glutMainLoop();

    delete gameModels;
    glDeleteProgram(program);
    return 0;
}