micqdf/opengl-cpp
1
0
Fork 0
mirror of https://github.com/MichaelFisher1997/opengl-cpp.git synced 2025-04-26 13:43:11 +00:00
Code Issues Packages Projects Releases Wiki Activity

clang format added

Browse Source
This commit is contained in:
MichaelFisher1997 2025-01-14 23:18:11 +00:00
parent 6b0cc46045
commit 47f8068cdd
8 changed files with 293 additions and 340 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

79
src/IndexBuffer.cpp
View File

@ -1,60 +1,65 @@
#include "IndexBuffer.h"
#include "Renderer.h"
IndexBuffer::IndexBuffer(const unsigned int* data, unsigned int count)
: m_Count(count)
{
IndexBuffer::IndexBuffer(const unsigned int *data, unsigned int count)
: m_Count(count) {
ASSERT(sizeof(unsigned int) == sizeof(GLuint));
//
//std::cout << "m_RendererID: " << &m_RendererID << " " << m_RendererID << std::endl;
// std::cout << "m_RendererID: " << &m_RendererID << " " << m_RendererID <<
// std::endl;
GLCall(glGenBuffers(1, &m_RendererID));
GLCall(glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_RendererID)); //select buffer called 'buffer'
GLCall(glBufferData(GL_ELEMENT_ARRAY_BUFFER, count * sizeof(unsigned int), data, GL_STATIC_DRAW)); // assigne buffer size, static as we use many times, but does not change
GLCall(glBindBuffer(GL_ELEMENT_ARRAY_BUFFER,
m_RendererID)); // select buffer called 'buffer'
GLCall(glBufferData(GL_ELEMENT_ARRAY_BUFFER, count * sizeof(unsigned int),
data,
GL_STATIC_DRAW)); // assigne buffer size, static as we use
// many times, but does not change
}
// Destructor
IndexBuffer::~IndexBuffer() {
if (m_RendererID != 0) { // Only delete if valid
GLCall(glDeleteBuffers(1, &m_RendererID));
std::cout << "IndexBuffer destroyed with RendererID: " << m_RendererID << std::endl;
}
if (m_RendererID != 0) { // Only delete if valid
GLCall(glDeleteBuffers(1, &m_RendererID));
std::cout << "IndexBuffer destroyed with RendererID: " << m_RendererID
<< std::endl;
}
}
// Move Constructor
IndexBuffer::IndexBuffer(IndexBuffer&& other) noexcept
IndexBuffer::IndexBuffer(IndexBuffer &&other) noexcept
: m_RendererID(other.m_RendererID), m_Count(other.m_Count) {
other.m_RendererID = 0; // Invalidate the moved-from object
other.m_Count = 0;
std::cout << "IndexBuffer moved (constructor)" << std::endl;
other.m_RendererID = 0; // Invalidate the moved-from object
other.m_Count = 0;
std::cout << "IndexBuffer moved (constructor)" << std::endl;
}
// Move Assignment Operator
IndexBuffer& IndexBuffer::operator=(IndexBuffer&& other) noexcept {
if (this != &other) {
// Free existing resources
if (m_RendererID != 0) {
GLCall(glDeleteBuffers(1, &m_RendererID));
}
// Transfer ownership
m_RendererID = other.m_RendererID;
m_Count = other.m_Count;
// Invalidate the moved-from object
other.m_RendererID = 0;
other.m_Count = 0;
std::cout << "IndexBuffer moved (assignment)" << std::endl;
IndexBuffer &IndexBuffer::operator=(IndexBuffer &&other) noexcept {
if (this != &other) {
// Free existing resources
if (m_RendererID != 0) {
GLCall(glDeleteBuffers(1, &m_RendererID));
}
return *this;
// Transfer ownership
m_RendererID = other.m_RendererID;
m_Count = other.m_Count;
// Invalidate the moved-from object
other.m_RendererID = 0;
other.m_Count = 0;
std::cout << "IndexBuffer moved (assignment)" << std::endl;
}
return *this;
}
void IndexBuffer::Bind() const
{
GLCall(glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_RendererID)); //select buffer called 'buffer'
void IndexBuffer::Bind() const {
GLCall(glBindBuffer(GL_ELEMENT_ARRAY_BUFFER,
m_RendererID)); // select buffer called 'buffer'
}
void IndexBuffer::Unbind() const
{
GLCall(glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0)); //select buffer called 'buffer'
void IndexBuffer::Unbind() const {
GLCall(glBindBuffer(GL_ELEMENT_ARRAY_BUFFER,
0)); // select buffer called 'buffer'
}

11
src/Renderer.cpp
View File

@ -3,19 +3,20 @@
#include "Renderer.h"
void GLClearError() {
while (glGetError() != GL_NO_ERROR);
while (glGetError() != GL_NO_ERROR)
;
}
bool GLLogCall() {
Color::Modifier red(Color::FG_RED);
Color::Modifier def(Color::FG_DEFAULT);
while (GLenum error = glGetError()) {
std::cout << red << "[OpenGL Error] (" << error << ")" << def << std::endl; //if error, it will return a number, this needs to be converted to hex to then look up that value inn GL docs
std::cout
<< red << "[OpenGL Error] (" << error << ")" << def
<< std::endl; // if error, it will return a number, this needs to be
// converted to hex to then look up that value inn GL docs
return false;
}
return true;
}

222
src/Shader.cpp
View File

@ -1,157 +1,135 @@
#include "Shader.h"
#include "IndexBuffer.h"
#include "Renderer.h"
#include "VertexArray.h"
#include "VertexBuffer.h"
#include "fstream"
#include <cstdio>
#include <iostream>
#include <string>
#include <sstream>
#include "VertexBuffer.h"
#include "VertexArray.h"
#include "IndexBuffer.h"
#include "fstream"
#include "Renderer.h"
#include <string>
Shader::Shader(const std::string& filepath)
: m_FilePath(filepath), m_RendererID(0)
{
ShaderProgramSource source = ParseShader(filepath);
Shader::Shader(const std::string &filepath)
: m_FilePath(filepath), m_RendererID(0) {
ShaderProgramSource source = ParseShader(filepath);
std::cout << "VERTEX" << std::endl << source.VertexSource << std::endl;
std::cout << "FRAGMENT" << std::endl << source.FragmentSource << std::endl;
std::cout << "VERTEX" << std::endl << source.VertexSource << std::endl;
std::cout << "FRAGMENT" << std::endl << source.FragmentSource << std::endl;
m_RendererID = CreateShader(source.VertexSource, source.FragmentSource);
m_RendererID = CreateShader(source.VertexSource, source.FragmentSource);
GLCall( glUseProgram(m_RendererID) );
GLCall(glUseProgram(m_RendererID));
}
Shader::~Shader()
{
GLCall( glDeleteProgram(m_RendererID) );
Shader::~Shader() { GLCall(glDeleteProgram(m_RendererID)); }
void Shader::Bind() const { GLCall(glUseProgram(m_RendererID)); }
void Shader::Unbind() const { GLCall(glUseProgram(0)); }
int Shader::GetUniformLocation(const std::string &name) {
if (m_UniformLocationCache.find(name) != m_UniformLocationCache.end())
return m_UniformLocationCache[name];
GLCall(int location = glGetUniformLocation(m_RendererID, name.c_str()));
if (location == -1)
std::cout << "No active uniform variable with name " << name << " found"
<< std::endl;
m_UniformLocationCache[name] = location;
return location;
}
void Shader::Bind() const
{
GLCall( glUseProgram(m_RendererID) );
void Shader::SetUniform1f(const std::string &name, float value) {
GLCall(glUniform1f(GetUniformLocation(name), value));
}
void Shader::Unbind() const
{
GLCall( glUseProgram(0) );
void Shader::SetUniform4f(const std::string &name, float f0, float f1, float f2,
float f3) {
GLCall(glUniform4f(GetUniformLocation(name), f0, f1, f2, f3));
}
int Shader::GetUniformLocation(const std::string& name)
{
if (m_UniformLocationCache.find(name) != m_UniformLocationCache.end())
return m_UniformLocationCache[name];
enum ShaderType { NONE = -1, VERTEX = 0, FRAGMENT = 1 };
GLCall( int location = glGetUniformLocation(m_RendererID, name.c_str()) );
if (location == -1)
std::cout << "No active uniform variable with name " << name << " found" << std::endl;
struct ShaderProgramSource Shader::ParseShader(const std::string &filepath) {
m_UniformLocationCache[name] = location;
std::ifstream stream(filepath);
std::string line;
std::stringstream ss[2];
ShaderType type = NONE;
return location;
}
void Shader::SetUniform1f(const std::string& name, float value)
{
GLCall( glUniform1f(GetUniformLocation(name), value) );
}
void Shader::SetUniform4f(const std::string& name, float f0, float f1, float f2, float f3)
{
GLCall( glUniform4f(GetUniformLocation(name), f0, f1, f2, f3) );
}
enum ShaderType
{
NONE = -1, VERTEX = 0, FRAGMENT = 1
};
struct ShaderProgramSource Shader::ParseShader(const std::string& filepath)
{
std::ifstream stream(filepath);
std::string line;
std::stringstream ss[2];
ShaderType type = NONE;
while (getline(stream, line))
{
if (line.find("#shader") != std::string::npos)
{
if (line.find("vertex") != std::string::npos)
type = VERTEX;
else if (line.find("fragment") != std::string::npos)
type = FRAGMENT;
}
else
{
ss[(int)type] << line << '\n';
}
while (getline(stream, line)) {
if (line.find("#shader") != std::string::npos) {
if (line.find("vertex") != std::string::npos)
type = VERTEX;
else if (line.find("fragment") != std::string::npos)
type = FRAGMENT;
} else {
ss[(int)type] << line << '\n';
}
}
struct ShaderProgramSource sps = { ss[0].str(), ss[1].str() };
return sps;
struct ShaderProgramSource sps = {ss[0].str(), ss[1].str()};
return sps;
}
unsigned int Shader::CompileShader(unsigned int type, const std::string& source)
{
GLCall( unsigned int id = glCreateShader(type) );
const char* src = source.c_str();
GLCall( glShaderSource(id, 1, &src, nullptr) );
GLCall( glCompileShader(id) );
unsigned int Shader::CompileShader(unsigned int type,
const std::string &source) {
GLCall(unsigned int id = glCreateShader(type));
const char *src = source.c_str();
GLCall(glShaderSource(id, 1, &src, nullptr));
GLCall(glCompileShader(id));
// Error handling
int result;
GLCall( glGetShaderiv(id, GL_COMPILE_STATUS, &result) );
std::cout << (type == GL_VERTEX_SHADER ? "vertex" : "fragment") << " shader compile status: " << result << std::endl;
if ( result == GL_FALSE )
{
int length;
GLCall( glGetShaderiv(id, GL_INFO_LOG_LENGTH, &length) );
char* message = (char*) alloca(length * sizeof(char));
GLCall( glGetShaderInfoLog(id, length, &length, message) );
std::cout
<< "Failed to compile "
<< (type == GL_VERTEX_SHADER ? "vertex" : "fragment")
<< "shader"
<< std::endl;
std::cout << message << std::endl;
GLCall( glDeleteShader(id) );
return 0;
}
// Error handling
int result;
GLCall(glGetShaderiv(id, GL_COMPILE_STATUS, &result));
std::cout << (type == GL_VERTEX_SHADER ? "vertex" : "fragment")
<< " shader compile status: " << result << std::endl;
if (result == GL_FALSE) {
int length;
GLCall(glGetShaderiv(id, GL_INFO_LOG_LENGTH, &length));
char *message = (char *)alloca(length * sizeof(char));
GLCall(glGetShaderInfoLog(id, length, &length, message));
std::cout << "Failed to compile "
<< (type == GL_VERTEX_SHADER ? "vertex" : "fragment") << "shader"
<< std::endl;
std::cout << message << std::endl;
GLCall(glDeleteShader(id));
return 0;
}
return id;
return id;
}
unsigned int Shader::CreateShader(const std::string& vertexShader, const std::string& fragmentShader)
{
// create a shader program
unsigned int program = glCreateProgram();
unsigned int vs = CompileShader(GL_VERTEX_SHADER, vertexShader);
unsigned int fs = CompileShader(GL_FRAGMENT_SHADER, fragmentShader);
unsigned int Shader::CreateShader(const std::string &vertexShader,
const std::string &fragmentShader) {
// create a shader program
unsigned int program = glCreateProgram();
unsigned int vs = CompileShader(GL_VERTEX_SHADER, vertexShader);
unsigned int fs = CompileShader(GL_FRAGMENT_SHADER, fragmentShader);
GLCall( glAttachShader(program, vs) );
GLCall( glAttachShader(program, fs) );
GLCall(glAttachShader(program, vs));
GLCall(glAttachShader(program, fs));
GLCall( glLinkProgram(program) );
GLCall(glLinkProgram(program));
GLint program_linked;
GLint program_linked;
GLCall( glGetProgramiv(program, GL_LINK_STATUS, &program_linked) );
std::cout << "Program link status: " << program_linked << std::endl;
if (program_linked != GL_TRUE)
{
GLsizei log_length = 0;
GLchar message[1024];
GLCall( glGetProgramInfoLog(program, 1024, &log_length, message) );
std::cout << "Failed to link program" << std::endl;
std::cout << message << std::endl;
}
GLCall(glGetProgramiv(program, GL_LINK_STATUS, &program_linked));
std::cout << "Program link status: " << program_linked << std::endl;
if (program_linked != GL_TRUE) {
GLsizei log_length = 0;
GLchar message[1024];
GLCall(glGetProgramInfoLog(program, 1024, &log_length, message));
std::cout << "Failed to link program" << std::endl;
std::cout << message << std::endl;
}
GLCall( glValidateProgram(program) );
GLCall(glValidateProgram(program));
GLCall( glDeleteShader(vs) );
GLCall( glDeleteShader(fs) );
GLCall(glDeleteShader(vs));
GLCall(glDeleteShader(fs));
return program;
return program;
}

38
src/VertexArray.cpp
View File

@ -1,41 +1,33 @@
#include "VertexArray.h"
#include "Renderer.h"
VertexArray::VertexArray()
{
VertexArray::VertexArray() {
std::cout << "VertexArray::VertexArray()" << std::endl;
std::cout << "m_RendererID: " << &m_RendererID << std::endl;
std::cout << "m_RendererID: " << &m_RendererID << std::endl;
GLCall(glGenVertexArrays(1, &m_RendererID));
//glGenVertexArrays(1, &m_RendererID);
// glGenVertexArrays(1, &m_RendererID);
std::cout << "m_RendererID: " << &m_RendererID << std::endl;
if (!m_RendererID) {
std::cerr << "Failed to generate VAO" << std::endl;
}
}
VertexArray::~VertexArray()
{
GLCall(glDeleteVertexArrays(1, &m_RendererID));
}
VertexArray::~VertexArray() { GLCall(glDeleteVertexArrays(1, &m_RendererID)); }
void VertexArray::AddBuffer(const VertexBuffer& vb, const VertexBufferLayout& layout)
{
void VertexArray::AddBuffer(const VertexBuffer &vb,
const VertexBufferLayout &layout) {
Bind();
vb.Bind();
const std::vector<VertexBufferElement> elements = layout.GetElements();
unsigned int offset = 0;
for (unsigned int i = 0; i < elements.size(); i++) {
const auto& element = elements[i];
GLCall(glEnableVertexAttribArray(i));
GLCall( glVertexAttribPointer(i, element.count, element.type, element.normalized,layout.GetStride(), INT2VOIDP(offset)) );
offset += element.count * VertexBufferElement::GetSizeOfType(element.type);
}
const auto &element = elements[i];
GLCall(glEnableVertexAttribArray(i));
GLCall(glVertexAttribPointer(i, element.count, element.type,
element.normalized, layout.GetStride(),
INT2VOIDP(offset)));
offset += element.count * VertexBufferElement::GetSizeOfType(element.type);
}
}
void VertexArray::Bind() const {
GLCall(glBindVertexArray(m_RendererID));
}
void VertexArray::Unbind() const {
GLCall(glBindVertexArray(0));
}
void VertexArray::Bind() const { GLCall(glBindVertexArray(m_RendererID)); }
void VertexArray::Unbind() const { GLCall(glBindVertexArray(0)); }

28
src/VertexBuffer.cpp
View File

@ -1,24 +1,22 @@
#include "VertexBuffer.h"
#include "Renderer.h"
VertexBuffer::VertexBuffer(const void* data, unsigned int size)
{
VertexBuffer::VertexBuffer(const void *data, unsigned int size) {
GLCall(glGenBuffers(1, &m_RendererID));
GLCall(glBindBuffer(GL_ARRAY_BUFFER, m_RendererID)); //select buffer called 'buffer'
GLCall(glBufferData(GL_ARRAY_BUFFER, size, data, GL_STATIC_DRAW)); // assigne buffer size, static as we use many times, but does not change
GLCall(glBindBuffer(GL_ARRAY_BUFFER,
m_RendererID)); // select buffer called 'buffer'
GLCall(glBufferData(GL_ARRAY_BUFFER, size, data,
GL_STATIC_DRAW)); // assigne buffer size, static as we use
// many times, but does not change
}
VertexBuffer::~VertexBuffer()
{
GLCall(glDeleteBuffers(1, &m_RendererID));
VertexBuffer::~VertexBuffer() { GLCall(glDeleteBuffers(1, &m_RendererID)); }
void VertexBuffer::Bind() const {
GLCall(glBindBuffer(GL_ARRAY_BUFFER,
m_RendererID)); // select buffer called 'buffer'
}
void VertexBuffer::Bind() const
{
GLCall(glBindBuffer(GL_ARRAY_BUFFER, m_RendererID)); //select buffer called 'buffer'
}
void VertexBuffer::Unbind() const
{
GLCall(glBindBuffer(GL_ARRAY_BUFFER, 0)); //select buffer called 'buffer'
void VertexBuffer::Unbind() const {
GLCall(glBindBuffer(GL_ARRAY_BUFFER, 0)); // select buffer called 'buffer'
}

9
src/main.cpp
View File

@ -1,14 +1,13 @@
#include "sdl.hpp"
int main(int argc, char* argv[]) {
// Create an instance of our SdlWindow class
std::cout << "starting" << std::endl;
int main(int argc, char *argv[]) {
// Create an instance of our SdlWindow class
std::cout << "starting" << std::endl;
SdlWindow window("My SDL2 Window", 800, 600);
std::cout << "About to run: " << std::endl;
std::cout << "About to run: " << std::endl;
// Run the main loop
window.run();
return 0;
}

179
src/sdl.cpp
View File

@ -1,107 +1,91 @@
#include <GL/glew.h> // Include GLEW before <SDL2/SDL.h>?
#include "sdl.hpp"
#include "VertexBufferLayout.h"
#include <GL/glew.h> // Include GLEW before <SDL2/SDL.h>?
#include <SDL2/SDL_video.h>
#include <alloca.h>
#include <cstdio>
#include <iostream>
#include <string>
#include <ostream>
#include <string>
#include "Renderer.h"
#include "VertexBuffer.h"
#include "VertexArray.h"
#include "IndexBuffer.h"
#include "Renderer.h"
#include "Shader.h"
#include "VertexArray.h"
#include "VertexBuffer.h"
SdlWindow::SdlWindow(const char* title, int width, int height)
: m_window(nullptr),
m_renderer(nullptr),
m_isRunning(false),
m_isFullscreen(false),
m_width(width),
m_height(height),
m_windowedWidth(width),
m_windowedHeight(height),
r(0.5f),
m_glContext(nullptr),
increment(0.05f),
m_Shader(nullptr),
m_Location(-1),
m_IB(nullptr),
m_VB(nullptr),
m_VA(nullptr)
{
SdlWindow::SdlWindow(const char *title, int width, int height)
: m_window(nullptr), m_renderer(nullptr), m_isRunning(false),
m_isFullscreen(false), m_width(width), m_height(height),
m_windowedWidth(width), m_windowedHeight(height), r(0.5f),
m_glContext(nullptr), increment(0.05f), m_Shader(nullptr), m_Location(-1),
m_IB(nullptr), m_VB(nullptr), m_VA(nullptr) {
std::cout << "Step 0: hellow world" << std::endl;
// 1. Set attributes
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 3);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 3);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_CORE);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 3);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 3);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_CORE);
std::cout << "Step 1: SDL_GL_SetAttribute completed" << std::endl;
// 2. Create the window with OpenGL flag
m_window = SDL_CreateWindow(title,
SDL_WINDOWPOS_CENTERED,
SDL_WINDOWPOS_CENTERED,
width,
height,
SDL_WINDOW_OPENGL | SDL_WINDOW_SHOWN| SDL_WINDOW_RESIZABLE);
m_window = SDL_CreateWindow(
title, SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, width, height,
SDL_WINDOW_OPENGL | SDL_WINDOW_SHOWN | SDL_WINDOW_RESIZABLE);
if (!m_window) {
std::cerr << "Failed to create window: " << SDL_GetError() << std::endl;
return;
std::cerr << "Failed to create window: " << SDL_GetError() << std::endl;
return;
}
std::cout << "Step 2: SDL_CreateWindow completed" << std::endl;
m_glContext = SDL_GL_CreateContext(m_window);
if (!m_glContext) {
std::cerr << "Failed to create GL context: " << SDL_GetError() << std::endl;
return;
std::cerr << "Failed to create GL context: " << SDL_GetError() << std::endl;
return;
}
std::cout << "Step 3: SDL_GL_CreateContext completed" << std::endl;
if (SDL_GL_MakeCurrent(m_window, m_glContext) != 0) {
std::cerr << "Failed to make GL context current: " << SDL_GetError() << std::endl;
return;
std::cerr << "Failed to make GL context current: " << SDL_GetError()
<< std::endl;
return;
}
std::cout << "Step 4: SDL_GL_MakeCurrent completed" << std::endl;
#ifndef __APPLE__
#ifndef __APPLE__
glewExperimental = GL_TRUE;
GLenum glewErr = glewInit();
if (glewErr != GLEW_OK) {
std::cerr << "Failed to init GLEW: " << glewGetErrorString(glewErr) << std::endl;
return;
std::cerr << "Failed to init GLEW: " << glewGetErrorString(glewErr)
<< std::endl;
return;
}
std::cout << "Step 5: GLEW initialized successfully" << std::endl;
glGetError(); // Clear GLEW's initial error
#endif
#endif
std::cout << "OpenGL Version: " << glGetString(GL_VERSION) << std::endl;
std::cout << "GLSL Version: " << glGetString(GL_SHADING_LANGUAGE_VERSION) << std::endl;
std::cout << "GLSL Version: " << glGetString(GL_SHADING_LANGUAGE_VERSION)
<< std::endl;
std::cout << "Vendor: " << glGetString(GL_VENDOR) << std::endl;
// 5. Set vsync (optional)
SDL_GL_SetSwapInterval(1); //Vsync
SDL_GL_SetSwapInterval(1); // Vsync
// 6. Mark as running
m_isRunning = true;
float positions[] = { // vertex for a triangle
//x,y
-0.5f, -0.5f, // 0
0.5f, -0.5f, // 1
0.5f, 0.5f, //2
-0.5f, 0.5f // 3
};
unsigned int indices[] = {
0, 1, 2,
2, 3, 0
float positions[] = {
// vertex for a triangle
// x,y
-0.5f, -0.5f, // 0
0.5f, -0.5f, // 1
0.5f, 0.5f, // 2
-0.5f, 0.5f // 3
};
unsigned int indices[] = {0, 1, 2, 2, 3, 0};
m_VA = new VertexArray();
m_VB = new VertexBuffer(positions, 4 * 2 * sizeof(float));
m_IB = new IndexBuffer(indices, 6);
@ -111,46 +95,43 @@ SdlWindow::SdlWindow(const char* title, int width, int height)
m_VA->AddBuffer(*m_VB, layout);
m_Shader = new Shader("res/shaders/Basic.shader");
m_Shader->Bind();
}
SdlWindow::~SdlWindow() {
// If using SDL Renderer, destroy it. But if you’re purely using OpenGL, you might remove it.
// If using SDL Renderer, destroy it. But if you’re purely using OpenGL, you
// might remove it.
if (m_renderer) {
SDL_DestroyRenderer(m_renderer);
m_renderer = nullptr;
SDL_DestroyRenderer(m_renderer);
m_renderer = nullptr;
}
// Delete the OpenGL context
if (m_glContext) {
SDL_GL_DeleteContext(m_glContext);
m_glContext = nullptr;
SDL_GL_DeleteContext(m_glContext);
m_glContext = nullptr;
}
if (m_window) {
SDL_DestroyWindow(m_window);
m_window = nullptr;
SDL_DestroyWindow(m_window);
m_window = nullptr;
}
////TODO
//some point check everything is being deleted
// some point check everything is being deleted
SDL_Quit();
}
//
//
void SdlWindow::run() {
while (m_isRunning) {
processEvents();
processEvents();
update();
render();
}
}
//
void SdlWindow::processEvents() {
SDL_Event event;
SDL_Event event;
while (SDL_PollEvent(&event)) {
if (event.type == SDL_QUIT) {
m_isRunning = false;
@ -167,22 +148,21 @@ SDL_Event event;
}
if (event.key.keysym.sym == SDLK_ESCAPE) {
std::cout << "Bye!" << std::endl;
m_isRunning = false; //exit application
m_isRunning = false; // exit application
}
}
else if (event.type == SDL_WINDOWEVENT) {
} else if (event.type == SDL_WINDOWEVENT) {
if (event.window.event == SDL_WINDOWEVENT_RESIZED) {
// SDL gives the new width/height in event.window.data1/data2
int newWidth = event.window.data1;
int newWidth = event.window.data1;
int newHeight = event.window.data2;
// Update your internal width/height (if you keep track)
m_width = newWidth;
m_width = newWidth;
m_height = newHeight;
// If we are in windowed mode, update the "windowed" size.
if (!m_isFullscreen) {
m_windowedWidth = newWidth;
m_windowedHeight = newHeight;
m_windowedWidth = newWidth;
m_windowedHeight = newHeight;
}
// Update the OpenGL viewport
@ -207,42 +187,43 @@ void SdlWindow::update() {
//
void SdlWindow::render() {
// Use GL calls instead of SDL’s renderer
GLCall(glClearColor(0.0f, 0.0f, 0.0f, 1.0f)); //background
GLCall(glClearColor(0.0f, 0.0f, 0.0f, 1.0f)); // background
//
GLCall(glClear(GL_COLOR_BUFFER_BIT));
m_Shader->Bind();
m_Shader->SetUniform4f("u_Color", r, 0.3, 0.8, 1.0);
m_VA->Bind();
m_IB->Bind();
// TODO: Draw with OpenGL here (shaders, triangles, etc.)
//glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, nullptr);
GLCall(glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, nullptr)); //macro assert for debugging
// glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, nullptr);
GLCall(glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT,
nullptr)); // macro assert for debugging
// Swap buffers
SDL_GL_SwapWindow(m_window);
}
//
void SdlWindow::setFullscreen(bool fullscreen) {
if (m_window) {
m_isFullscreen = fullscreen;
if (m_isFullscreen) {
// Going TO fullscreen:
// (Optional) store the current size again, in case it changed
m_windowedWidth = m_width;
m_windowedHeight = m_height;
if (m_window) {
m_isFullscreen = fullscreen;
if (m_isFullscreen) {
// Going TO fullscreen:
// (Optional) store the current size again, in case it changed
m_windowedWidth = m_width;
m_windowedHeight = m_height;
SDL_SetWindowFullscreen(m_window, SDL_WINDOW_FULLSCREEN_DESKTOP);
} else {
// Returning FROM fullscreen:
SDL_SetWindowFullscreen(m_window, 0); // return to windowed
// Now restore the window’s old size
SDL_SetWindowSize(m_window, m_windowedWidth, m_windowedHeight);
SDL_SetWindowFullscreen(m_window, SDL_WINDOW_FULLSCREEN_DESKTOP);
} else {
// Returning FROM fullscreen:
SDL_SetWindowFullscreen(m_window, 0); // return to windowed
// Now restore the window’s old size
SDL_SetWindowSize(m_window, m_windowedWidth, m_windowedHeight);
// Update m_width, m_height so they reflect the new (restored) size
m_width = m_windowedWidth;
m_height = m_windowedHeight;
}
// Update m_width, m_height so they reflect the new (restored) size
m_width = m_windowedWidth;
m_height = m_windowedHeight;
}
}
}

67
src/sdl.hpp
View File

@ -4,16 +4,16 @@
#include <string>
// Include the OpenGL headers (these may vary by system)
#if defined(__APPLE__)
#include <OpenGL/gl3.h> // On macOS, <OpenGL/gl3.h> is often used
#include <OpenGL/gl3.h> // On macOS, <OpenGL/gl3.h> is often used
#else
#include <GL/glew.h> // or <glad/glad.h> if using GLAD
#include <GL/glew.h> // or <glad/glad.h> if using GLAD
#endif
#include <string>
#include "IndexBuffer.h"
#include "VertexBufferLayout.h"
#include "VertexArray.h"
#include "Shader.h"
#include "VertexArray.h"
#include "VertexBufferLayout.h"
#include <string>
// Forward declaration of classes and structs if needed
// class SomethingElse;
@ -21,50 +21,49 @@
class SdlWindow {
public:
// Constructor
SdlWindow(const char* title, int width, int height);
SdlWindow(const char *title, int width, int height);
// Destructor
~SdlWindow();
// Run the main loop
void run();
// unsigned int compileShader(unsigned int type, const std::string& source);
// unsigned int createShader(const std::string& vetexShader, const std::string& fragmentShader);
// // for spliting our shaders
// //struct ShaderProgramSource {
// // std::string VetexSource, FragmentSource;
// struct ShaderProgramSource {
// std::string VertexSource;
// std::string FragmentSource;
// };
// ShaderProgramSource parseShader(const std::string& filepath);
// unsigned int compileShader(unsigned int type, const std::string& source);
// unsigned int createShader(const std::string& vetexShader, const
// std::string& fragmentShader);
// // for spliting our shaders
// //struct ShaderProgramSource {
// // std::string VetexSource, FragmentSource;
// struct ShaderProgramSource {
// std::string VertexSource;
// std::string FragmentSource;
// };
// ShaderProgramSource parseShader(const std::string& filepath);
void setFullscreen(bool fullscreen);
private:
// Private data members
SDL_Window* m_window;
SDL_Renderer* m_renderer;
bool m_isRunning;
bool m_isFullscreen;
int m_width;
int m_height;
int m_windowedWidth; // stored width before fullscreen
int m_windowedHeight; // stored height before fullscreen
float r;
SDL_Window *m_window;
SDL_Renderer *m_renderer;
bool m_isRunning;
bool m_isFullscreen;
int m_width;
int m_height;
int m_windowedWidth; // stored width before fullscreen
int m_windowedHeight; // stored height before fullscreen
float r;
SDL_GLContext m_glContext;
float increment;
// // temp shader stuff
GLint m_Location;
VertexArray* m_VA;
IndexBuffer* m_IB;
VertexBuffer* m_VB;
Shader* m_Shader;
float increment;
// // temp shader stuff
GLint m_Location;
VertexArray *m_VA;
IndexBuffer *m_IB;
VertexBuffer *m_VB;
Shader *m_Shader;
// Private methods
void processEvents();
void update();
void render();
};