Невозможно обрабатывать полный экран в OpenGL через класс окон ⇐ C++

[Anonymous]

--------- Обновлено ---------
Я пытаюсь создать окно Класс, который может позаботиться о создании окна с основными функциональными возможностями, такими как переключение полноэкранного и привязка ESC, чтобы закрыть окно и window Я могу выйти с ESC , но когда я нажимаю f11 , я продолжаю получать исключение доступа к 0x001d6f6b в idk.exe: 0xc00000000: место для чтения нарушений доступа 0xccccf78. в строке 16 in Window.cpp , не уверен, почему это происходит. GLFWGETWINDOWPOS (_Window, & _WindowedMode.xpos, & _WindowedMode.ypos); достигнут, я продолжаю получать ту же ошибку, и я застрял. Br />#pragma once
#include
#include
#include

struct WindowProperties
{
int xpos, ypos;
int width, height;
};

class Window
{
private:
std::string _title;
bool _fullscreen;
GLFWwindow* _window;
float _aspectRatio;
WindowProperties _windowedMode;

static void framebufferSizeCallback(GLFWwindow* window, int width, int height)
{
Window* windowInstance = static_cast(glfwGetWindowUserPointer(window));
if (windowInstance)
{
windowInstance->handleFramebufferResize(width, height);
}
}

static void keyCallback(GLFWwindow* window, int key, int scancode, int action, int mods)
{
Window* windowInstance = static_cast(glfwGetWindowUserPointer(window));
if (windowInstance)
{
windowInstance->handleKeyPress(key, scancode, action, mods);
}
}

public:
Window(const std::string& title, WindowProperties winProp, bool fullscreen = false)
: _title(title)
, _windowedMode(winProp)
, _fullscreen(fullscreen)
, _window(nullptr)
, _aspectRatio(static_cast(_windowedMode.width) / static_cast(_windowedMode.height)) {}

void toggleFullscreen()
{
_fullscreen = !_fullscreen;

if (_fullscreen)
{
glfwGetWindowPos(_window, &_windowedMode.xpos, &_windowedMode.ypos);
glfwGetWindowSize(_window, &_windowedMode.width, &_windowedMode.height);

GLFWmonitor* monitor = glfwGetPrimaryMonitor();
const GLFWvidmode* mode = glfwGetVideoMode(monitor);

glfwSetWindowMonitor(_window, monitor, 0, 0, mode->width, mode->height, mode->refreshRate);
}
else
{
// Return to windowed mode with previous position and size
glfwSetWindowMonitor(_window, nullptr,
_windowedMode.xpos, _windowedMode.ypos,
_windowedMode.width, _windowedMode.height,
0);
}
}

void handleFramebufferResize(int width, int height)
{
_windowedMode.width = width;
_windowedMode.height = height;
_aspectRatio = static_cast(width) / static_cast(height);
glViewport(0, 0, width, height);
}

void handleKeyPress(int key, int scancode, int action, int mods)
{
if (key == GLFW_KEY_ESCAPE && action == GLFW_PRESS)
{
glfwSetWindowShouldClose(_window, true);
}
else if (key == GLFW_KEY_F11 && action == GLFW_PRESS)
{
toggleFullscreen();
}
}

bool init()
{
if (!glfwInit())
{
std::cerr
camera.cpp
#include "Camera.h"
#include

glm::mat4 Camera::GetViewMatrix()
{
return glm::lookAt(Position, Position + Front, Up);
}

// processes input received from any keyboard-like input system. Accepts input parameter in the form of camera defined ENUM (to abstract it from windowing systems)
void Camera::ProcessKeyboard(Camera_Movement direction, float deltaTime)
{
float velocity = MovementSpeed * deltaTime;
if (direction == FORWARD)
Position += Front * velocity;
if (direction == BACKWARD)
Position -= Front * velocity;
if (direction == LEFT)
Position -= Right * velocity;
if (direction == RIGHT)
Position += Right * velocity;
if (direction == UP)
Position += Up * velocity;
if (direction == DOWN)
Position -= Up * velocity;
}

// processes input received from a mouse input system. Expects the offset value in both the x and y direction.
void Camera::ProcessMouseMovement(float xoffset, float yoffset, GLboolean constrainPitch)
{
xoffset *= MouseSensitivity;
yoffset *= MouseSensitivity;

Yaw += xoffset;
Pitch += yoffset;

// make sure that when pitch is out of bounds, screen doesn't get flipped
if (constrainPitch)
{
if (Pitch > 89.0f)
Pitch = 89.0f;
if (Pitch < -89.0f)
Pitch = -89.0f;
}

// update Front, Right and Up Vectors using the updated Euler angles
updateCameraVectors();
}

// processes input received from a mouse scroll-wheel event. Only requires input on the vertical wheel-axis
void Camera::ProcessMouseScroll(float yoffset)
{
Zoom -= (float)yoffset;
if (Zoom < 1.0f)
Zoom = 1.0f;
if (Zoom > 45.0f)
Zoom = 45.0f;
}

void Camera::updateCameraVectors()
{
// calculate the new Front vector
glm::vec3 front;
front.x = cos(glm::radians(Yaw)) * cos(glm::radians(Pitch));
front.y = sin(glm::radians(Pitch));
front.z = sin(glm::radians(Yaw)) * cos(glm::radians(Pitch));
Front = glm::normalize(front);
// also re-calculate the Right and Up vector
Right = glm::normalize(glm::cross(Front, WorldUp)); // normalize the vectors, because their length gets closer to 0 the more you look up or down which results in slower movement.
Up = glm::normalize(glm::cross(Right, Front));
}
< /code>
cameracontroller: < /p>
#include "CameraController.h"

CameraController::CameraController(GLFWwindow* window, Camera& camera)
: m_window(window)
, m_camera(camera)
, m_lastX(0.0f)
, m_lastY(0.0f)
, m_firstMouse(true)
, m_enabled(true)
{
// Store window dimensions for initial aspect ratio
int width, height;
glfwGetWindowSize(window, &width, &height);
m_aspectRatio = static_cast(width) / static_cast(height);

// Store previous callbacks
m_previousMouseCallback = glfwSetCursorPosCallback(window, MouseCallback);
m_previousScrollCallback = glfwSetScrollCallback(window, ScrollCallback);

// Set window user pointer to this instance
glfwSetWindowUserPointer(window, this);

// Set initial cursor state
//glfwSetInputMode(window, GLFW_CURSOR, GLFW_CURSOR_DISABLED);
}

CameraController::~CameraController()
{
// Restore previous callbacks
glfwSetCursorPosCallback(m_window, m_previousMouseCallback);
glfwSetScrollCallback(m_window, m_previousScrollCallback);
}

void CameraController::Update(float deltaTime)
{
if (!m_enabled) return;
ProcessKeyboardInput(deltaTime);
}

void CameraController::ProcessKeyboardInput(float deltaTime)
{
if (glfwGetKey(m_window, GLFW_KEY_W) == GLFW_PRESS)
m_camera.ProcessKeyboard(FORWARD, deltaTime);
if (glfwGetKey(m_window, GLFW_KEY_S) == GLFW_PRESS)
m_camera.ProcessKeyboard(BACKWARD, deltaTime);
if (glfwGetKey(m_window, GLFW_KEY_A) == GLFW_PRESS)
m_camera.ProcessKeyboard(LEFT, deltaTime);
if (glfwGetKey(m_window, GLFW_KEY_D) == GLFW_PRESS)
m_camera.ProcessKeyboard(RIGHT, deltaTime);
if (glfwGetKey(m_window, GLFW_KEY_SPACE) == GLFW_PRESS)
m_camera.ProcessKeyboard(UP, deltaTime);
if (glfwGetKey(m_window, GLFW_KEY_LEFT_ALT) == GLFW_PRESS)
m_camera.ProcessKeyboard(DOWN, deltaTime);
}

void CameraController::ProcessMouseMovement(double xpos, double ypos)
{
if (!m_enabled) return;

if (m_firstMouse)
{
m_lastX = xpos;
m_lastY = ypos;
m_firstMouse = false;
}

float xoffset = xpos - m_lastX;
float yoffset = m_lastY - ypos;

m_lastX = xpos;
m_lastY = ypos;

m_camera.ProcessMouseMovement(xoffset, yoffset);
}

void CameraController::ProcessMouseScroll(double yoffset)
{
if (!m_enabled) return;
m_camera.ProcessMouseScroll(static_cast(yoffset));
}

// Static callback implementations
void CameraController::MouseCallback(GLFWwindow* window, double xpos, double ypos)
{
auto* controller = static_cast(glfwGetWindowUserPointer(window));
if (controller) {
controller->ProcessMouseMovement(xpos, ypos);
}
}

void CameraController::ScrollCallback(GLFWwindow* window, double xoffset, double yoffset)
{
auto* controller = static_cast(glfwGetWindowUserPointer(window));
if (controller) {
controller->ProcessMouseScroll(yoffset);
}
}
< /code>
Appling App: < /p>
#include
#include
#include
#include
#include
#include
#include

#include "Shader.h"
#include "Camera.h"
#include "Window.h"
#include "CameraController.h"

#define PI 3.14159265358979

WindowProperties windowedMode(100, 100, 920, 900);

float deltaTime = 0.0f;
float lastFrame = 0.0f;
float aspectRatio;

int main()
{
Window window("IDK Window", windowedMode, false);
if (!window.init())
{
return -1;
}

Camera camera(glm::vec3(0.0f, 0.0f, 3.0f));
CameraController cameraController(window.getWindow(), camera);

Shader shaderID("Shaders/BasicVertexShader.glsl", "Shaders/BasicFragmentShader.glsl");

aspectRatio = (float)windowedMode.width / (float)windowedMode.height;

float vertices[] = {
-0.5f, -0.5f, 0.0f,
0.5f, -0.5f, 0.0f,
0.5f, -0.5f, 0.0f,
0.0f, 0.5f, 0.0f,
0.0f, 0.5f, 0.0f,
-0.5f, -0.5f, 0.0f
};

// Create and bind VAO/VBO
GLuint VAO, VBO;
glGenVertexArrays(1, &VAO);
glGenBuffers(1, &VBO);

glBindVertexArray(VAO);
glBindBuffer(GL_ARRAY_BUFFER, VBO);
glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);

// Configure vertex attributes
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(float), (void*)0);
glEnableVertexAttribArray(0);

// Unbind to avoid accidental modification
glBindBuffer(GL_ARRAY_BUFFER, 0);
glBindVertexArray(0);
glLineWidth(2.0f);

while (!glfwWindowShouldClose(window.getWindow()))
{
float currentTime = static_cast(glfwGetTime());
deltaTime = currentTime - lastFrame;
lastFrame = currentTime;

cameraController.Update(deltaTime);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

shaderID.use();

glm::mat4 projection = glm::perspective(glm::radians(camera.Zoom), aspectRatio, 0.1f, 100.0f);
glm::mat4 view = camera.GetViewMatrix();
glm::mat4 model = glm::mat4(1.0f);
model = glm::translate(model, glm::vec3(0.0f, 0.0f, -2.0f));

shaderID.setMat4("projection", projection);
shaderID.setMat4("view", view);
shaderID.setMat4("model", model);

// Draw lines
glBindVertexArray(VAO);
glDrawArrays(GL_LINES, 0, 8);

glfwSwapBuffers(window.getWindow());
glfwPollEvents();
}

glfwTerminate();

return 0;
}


Подробнее здесь: https://stackoverflow.com/questions/793 ... ndow-class