Vfrdtyky

The blue border is the screenshot mapped onto a plane. from an HBITMAP
https://i.imgur.com/M9Q5FfY.png
The regular screeenshot was taken by screenshotter.h and saved as a BITMAP.
I'm hoping I can keep this in memory and just swap it that way.

https://i.imgur.com/Pk84BpP.png

   // Include standard headers

#include <stdio.h>

#include <stdlib.h>



// Include GLEW

#include <GL/glew.h>



// Include GLFW

#include <GLFW/glfw3.h>

GLFWwindow* window;



// Include GLM

#include <glm/glm.hpp>

#include <glm/gtc/matrix_transform.hpp>

using namespace glm;



#include <common/shader.hpp>

#include <common/texture.hpp>

#include "screenshotter.h"





#include "gl/gl.h"

#include "gl/glu.h"









// Include GLM

#include <glm/glm.hpp>

#include <glm/gtc/matrix_transform.hpp>





#include "playground.h"

//#include "resource.h"



#include "scrnsave.h"  //contains hMainInstance



int Filter;

// Interpolated values from the vertex shaders



using namespace glm;

using namespace std;

int main( void )

{

    // Initialise GLFW

    if (!glfwInit())

    {

        fprintf(stderr, "Failed to initialize GLFWn");

        getchar();

        return -1;

    }



    glfwWindowHint(GLFW_SAMPLES, 4);

    glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);

    glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);

    glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE); // To make MacOS happy; should not be needed

    glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);



    // Open a window and create its OpenGL context

    window = glfwCreateWindow(1024, 768, "Tutorial 04 - Colored Cube", NULL, NULL);

    if (window == NULL) {

        fprintf(stderr, "Failed to open GLFW window. If you have an Intel GPU, they are not 3.3 compatible. Try the 2.1 version of the tutorials.n");

        getchar();

        glfwTerminate();

        return -1;

    }

    glfwMakeContextCurrent(window);



    // Initialize GLEW

    glewExperimental = true; // Needed for core profile

    if (glewInit() != GLEW_OK) {

        fprintf(stderr, "Failed to initialize GLEWn");

        getchar();

        glfwTerminate();

        return -1;

    }



    // Ensure we can capture the escape key being pressed below

    glfwSetInputMode(window, GLFW_STICKY_KEYS, GL_TRUE);



    // Dark blue background

    glClearColor(0.0f, 0.0f, 0.4f, 0.0f);



    // Enable depth test

    glEnable(GL_DEPTH_TEST);

    // Accept fragment if it closer to the camera than the former one

    glDepthFunc(GL_LESS);



    GLuint VertexArrayID;

    glGenVertexArrays(1, &VertexArrayID);

    glBindVertexArray(VertexArrayID);



    // Create and compile our GLSL program from the shaders

    GLuint programID = LoadShaders("../tutorial05_textured_cube/TransformVertexShader.vertexshader", "../tutorial05_textured_cube/TextureFragmentShader.fragmentshader");

    //GLuint programID = LoadShaders("TransformVertexShader.vertexshader", "TextureFragmentShader.fragmentshader");



    // Get a handle for our "MVP" uniform

    GLuint MatrixID = glGetUniformLocation(programID, "MVP");

    //"C:/project/blender/gl/ogl-master/tutorial05_textured_cube/uvtemplate1.bmp"

    GLuint Texture = loadBMPfromScreenshotter();

    GLuint TextureID = glGetUniformLocation(programID, "myTextureSampler");

    // Projection matrix : 45° Field of View, 4:3 ratio, display range : 0.1 unit <-> 100 units

    glm::mat4 Projection = glm::perspective(glm::radians(45.0f), 4.0f / 3.0f, 0.1f, 100.0f);

    // Camera matrix

    glm::mat4 View = glm::lookAt(

        glm::vec3(4,0, 0), // Camera is at (4,3,-3), in World Space

        glm::vec3(0, 0, 0), // and looks at the origin

        glm::vec3(0, 0, 1)  // Head is up (set to 0,-1,0 to look upside-down)

    );

    // Model matrix : an identity matrix (model will be at the origin)

    glm::mat4 Model = glm::mat4(1.0f);

    // Our ModelViewProjection : multiplication of our 3 matrices

    glm::mat4 MVP = Projection * View * Model; // Remember, matrix multiplication is the other way around



                                               // Our vertices. Tree consecutive floats give a 3D vertex; Three consecutive vertices give a triangle.

                                               // A cube has 6 faces with 2 triangles each, so this makes 6*2=12 triangles, and 12*3 vertices

    static const GLfloat g_vertex_buffer_data = {

        -1.0f,-1.0f,-1.0f,

        -1.0f,-1.0f, 1.0f,

        -1.0f, 1.0f, 1.0f,

        1.0f, 1.0f,-1.0f,

        -1.0f,-1.0f,-1.0f,

        -1.0f, 1.0f,-1.0f,

        1.0f,-1.0f, 1.0f,

        -1.0f,-1.0f,-1.0f,

        1.0f,-1.0f,-1.0f,

        1.0f, 1.0f,-1.0f,

        1.0f,-1.0f,-1.0f,

        -1.0f,-1.0f,-1.0f,

        -1.0f,-1.0f,-1.0f,

        -1.0f, 1.0f, 1.0f,

        -1.0f, 1.0f,-1.0f,

        1.0f,-1.0f, 1.0f,

        -1.0f,-1.0f, 1.0f,

        -1.0f,-1.0f,-1.0f,

        -1.0f, 1.0f, 1.0f,

        -1.0f,-1.0f, 1.0f,

        1.0f,-1.0f, 1.0f,

        1.0f, 1.0f, 1.0f,

        1.0f,-1.0f,-1.0f,

        1.0f, 1.0f,-1.0f,

        1.0f,-1.0f,-1.0f,

        1.0f, 1.0f, 1.0f,

        1.0f,-1.0f, 1.0f,

        1.0f, 1.0f, 1.0f,

        1.0f, 1.0f,-1.0f,

        -1.0f, 1.0f,-1.0f,

        1.0f, 1.0f, 1.0f,

        -1.0f, 1.0f,-1.0f,

        -1.0f, 1.0f, 1.0f,

        1.0f, 1.0f, 1.0f,

        -1.0f, 1.0f, 1.0f,

        1.0f,-1.0f, 1.0f

    };



    // One color for each vertex. They were generated randomly.

    static const GLfloat g_color_buffer_data = {

        0.583f,  0.771f,  0.014f,

        0.609f,  0.115f,  0.436f,

        0.327f,  0.483f,  0.844f,

        0.822f,  0.569f,  0.201f,

        0.435f,  0.602f,  0.223f,

        0.310f,  0.747f,  0.185f,

        0.597f,  0.770f,  0.761f,

        0.559f,  0.436f,  0.730f,

        0.359f,  0.583f,  0.152f,

        0.483f,  0.596f,  0.789f,

        0.559f,  0.861f,  0.639f,

        0.195f,  0.548f,  0.859f,

        0.014f,  0.184f,  0.576f,

        0.771f,  0.328f,  0.970f,

        0.406f,  0.615f,  0.116f,

        0.676f,  0.977f,  0.133f,

        0.971f,  0.572f,  0.833f,

        0.140f,  0.616f,  0.489f,

        0.997f,  0.513f,  0.064f,

        0.945f,  0.719f,  0.592f,

        0.543f,  0.021f,  0.978f,

        0.279f,  0.317f,  0.505f,

        0.167f,  0.620f,  0.077f,

        0.347f,  0.857f,  0.137f,

        0.055f,  0.953f,  0.042f,

        0.714f,  0.505f,  0.345f,

        0.783f,  0.290f,  0.734f,

        0.722f,  0.645f,  0.174f,

        0.302f,  0.455f,  0.848f,

        0.225f,  0.587f,  0.040f,

        0.517f,  0.713f,  0.338f,

        0.053f,  0.959f,  0.120f,

        0.393f,  0.621f,  0.362f,

        0.673f,  0.211f,  0.457f,

        0.820f,  0.883f,  0.371f,

        0.982f,  0.099f,  0.879f

    };

    // Two UV coordinatesfor each vertex. They were created with Blender. You'll learn shortly how to do this yourself.

    static const GLfloat g_uv_buffer_data = {

        0.000059f, 1.0f - 0.000004f,

        0.000103f, 1.0f - 0.336048f,

        0.335973f, 1.0f - 0.335903f,

        1.000023f, 1.0f - 0.000013f,

        0.667979f, 1.0f - 0.335851f,

        0.999958f, 1.0f - 0.336064f,

        0.667979f, 1.0f - 0.335851f,

        0.336024f, 1.0f - 0.671877f,

        0.667969f, 1.0f - 0.671889f,

        1.000023f, 1.0f - 0.000013f,

        0.668104f, 1.0f - 0.000013f,

        0.667979f, 1.0f - 0.335851f,

        0.000059f, 1.0f - 0.000004f,

        0.335973f, 1.0f - 0.335903f,

        0.336098f, 1.0f - 0.000071f,

        0.667979f, 1.0f - 0.335851f,

        0.335973f, 1.0f - 0.335903f,

        0.336024f, 1.0f - 0.671877f,

        1.000004f, 1.0f - 0.671847f,

        0.999958f, 1.0f - 0.336064f,

        0.667979f, 1.0f - 0.335851f,

        0.668104f, 1.0f - 0.000013f,

        0.335973f, 1.0f - 0.335903f,

        0.667979f, 1.0f - 0.335851f,

        0.335973f, 1.0f - 0.335903f,

        0.668104f, 1.0f - 0.000013f,

        0.336098f, 1.0f - 0.000071f,

        0.000103f, 1.0f - 0.336048f,

        0.000004f, 1.0f - 0.671870f,

        0.336024f, 1.0f - 0.671877f,

        0.000103f, 1.0f - 0.336048f,

        0.336024f, 1.0f - 0.671877f,

        0.335973f, 1.0f - 0.335903f,

        0.667969f, 1.0f - 0.671889f,

        1.000004f, 1.0f - 0.671847f,

        0.667979f, 1.0f - 0.335851f

    };



    GLuint vertexbuffer;

    glGenBuffers(1, &vertexbuffer);

    glBindBuffer(GL_ARRAY_BUFFER, vertexbuffer);

    glBufferData(GL_ARRAY_BUFFER, sizeof(g_vertex_buffer_data), g_vertex_buffer_data, GL_STATIC_DRAW);



    GLuint uvbuffer;

    glGenBuffers(1, &uvbuffer);

    glBindBuffer(GL_ARRAY_BUFFER, uvbuffer);

    glBufferData(GL_ARRAY_BUFFER, sizeof(g_uv_buffer_data), g_uv_buffer_data, GL_STATIC_DRAW);







    GLuint colorbuffer;

    glGenBuffers(1, &colorbuffer);

    glBindBuffer(GL_ARRAY_BUFFER, colorbuffer);

    glBufferData(GL_ARRAY_BUFFER, sizeof(g_color_buffer_data), g_color_buffer_data, GL_STATIC_DRAW);







    do {



        // Clear the screen

        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);



        // Use our shader

        glUseProgram(programID);



        // Send our transformation to the currently bound shader, 

        // in the "MVP" uniform

        glUniformMatrix4fv(MatrixID, 1, GL_FALSE, &MVP[0][0]);

        // Bind our texture in Texture Unit 0

        glActiveTexture(GL_TEXTURE0);

        glBindTexture(GL_TEXTURE_2D, Texture);

        // Set our "myTextureSampler" sampler to use Texture Unit 0

        glUniform1i(TextureID, 0);

        // 1rst attribute buffer : vertices

        glEnableVertexAttribArray(0);

        glBindBuffer(GL_ARRAY_BUFFER, vertexbuffer);

        glVertexAttribPointer(

            0,                  // attribute. No particular reason for 0, but must match the layout in the shader.

            3,                  // size

            GL_FLOAT,           // type

            GL_FALSE,           // normalized?

            0,                  // stride

            (void*)0            // array buffer offset

        );



        // 2nd attribute buffer : colors

        glEnableVertexAttribArray(1);

        glBindBuffer(GL_ARRAY_BUFFER, colorbuffer);

        glVertexAttribPointer(

            1,                                // attribute. No particular reason for 1, but must match the layout in the shader.

            3,                                // size

            GL_FLOAT,                         // type

            GL_FALSE,                         // normalized?

            0,                                // stride

            (void*)0                          // array buffer offset

        );



        // 2nd attribute buffer : UVs

        glEnableVertexAttribArray(1);

        glBindBuffer(GL_ARRAY_BUFFER, uvbuffer);

        glVertexAttribPointer(

            1,                                // attribute. No particular reason for 1, but must match the layout in the shader.

            2,                                // size : U+V => 2

            GL_FLOAT,                         // type

            GL_FALSE,                         // normalized?

            0,                                // stride

            (void*)0                          // array buffer offset

        );



        // Draw the triangle !

        glDrawArrays(GL_TRIANGLES, 0, 12 * 3); // 12*3 indices starting at 0 -> 12 triangles



        glDisableVertexAttribArray(0);

        glDisableVertexAttribArray(1);



        // Swap buffers

        glfwSwapBuffers(window);

        glfwPollEvents();



    } // Check if the ESC key was pressed or the window was closed

    while (glfwGetKey(window, GLFW_KEY_ESCAPE) != GLFW_PRESS &&

        glfwWindowShouldClose(window) == 0);



    // Cleanup VBO and shader

    glDeleteBuffers(1, &vertexbuffer);

    glDeleteBuffers(1, &colorbuffer);

    glDeleteProgram(programID);

    glDeleteVertexArrays(1, &VertexArrayID);



    // Close OpenGL window and terminate GLFW

    glfwTerminate();



    return 0;

}

//affects all textures in memory.

void SetTextureFilter(int newfilter)

{

    if (newfilter >= 0 && newfilter <= 1)

    {

        Filter = newfilter;

    }

}





GLuint loadBMPfromScreenshotter() {





    // Data read from the header of the BMP file

    unsigned char header[54];

    unsigned int dataPos;

    unsigned int imageSize;

    unsigned int width, height;

    // Actual RGB data

    unsigned char * data;



    // Open the file





    //// Read the information about the image

    //dataPos = *(int*)&(header[0x0A]);

    //imageSize = *(int*)&(header[0x22]);

    //width = *(int*)&(header[0x12]);

    //height = *(int*)&(header[0x16]);



    // Some BMP files are misformatted, guess missing information

    //if (imageSize == 0)    imageSize = width * height * 3; // 3 : one byte for each Red, Green and Blue component

    //if (dataPos == 0)      dataPos = 54; // The BMP header is done that way



    Screenshotter* screenshot = new Screenshotter();

    LPWSTR stuff = NULL;

    HBITMAP hBmp = screenshot->wWinMain(NULL, 0, stuff, 0);







    /// begin black website load

    //HBITMAP hBmp = NULL;



    /*hBmp = (HBITMAP) ::LoadImage(hMainInstance,

    MAKEINTRESOURCE(id), IMAGE_BITMAP, 0, 0, LR_CREATEDIBSECTION);*/



    //get info about the bitmap

    BITMAP BM;

    ::GetObject(hBmp, sizeof(BM), &BM);

                                         // Create a buffer

//  data = new unsigned char[imageSize];



    // Read the actual data from the file into the buffer



    // Everything is in memory now, the file can be closed.



    // Create one OpenGL texture

    GLuint textureID;

    glGenTextures(1, &textureID);



    // "Bind" the newly created texture : all future texture functions will modify this texture

    glBindTexture(GL_TEXTURE_2D, textureID);



    // Give the image to OpenGL

    /*glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, BM.bmWidth, BM.bmHeight, 0, GL_BGR, GL_UNSIGNED_BYTE, BM.bmBits

);*/

    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, BM.bmWidth, BM.bmHeight,

        0, GL_BGR_EXT, GL_UNSIGNED_BYTE, BM.bmBits);

    //glGenerateMipmap(GL_TEXTURE_2D);

    // OpenGL has now copied the data. Free our own version

    //delete data;



    // Poor filtering, or ...

    //glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);

    //glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); 



    // ... nice trilinear filtering ...

    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);

    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);

    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);

    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);

    // ... which requires mipmaps. Generate them automatically.

   glGenerateMipmap(GL_TEXTURE_2D);



    // Return the ID of the texture we just created

    return textureID;

}

Any suggestions as to what my problem is with the screenshot not mapping? it looks like pixels are showing up , it just doesn't seem like it is the right format or something.