Mastering OpenGL for Graphics Programming

Explore how vertex attributes define data layouts for OpenGL shaders, enabling vertex buffers, strides, and pointers to feed positions, texture coordinates, or normals into the GPU.

Explore how shaders run on the GPU in modern OpenGL, learn the vertex and fragment shaders, and follow the graphics pipeline from CPU data to a colored triangle on screen.

Write and compile your first OpenGL shader in Visual Studio, pairing a vertex shader with a fragment shader and linking them into a program to render a green rectangle.

Rewrite the shader into a dot shader file and read it with C++ fstream to split into vertex and fragment shader sources, then compile and use in the OpenGL program.

Learn how index buffers let you share vertices and render a square as two triangles, using an array of six indices to optimize OpenGL rendering.

Master OpenGL error handling by comparing GL error get with the modern debug callback, draining errors in a loop, and using asserts and breakpoints for precise debugging.

Wrap OpenGL calls with a GL call macro that clears errors, invokes a function like glDrawElements, and reports the exact function, file, and line for precise debugging.

Learn how uniforms in OpenGL pass CPU data to shaders to control color at runtime. Set up a vec4 uniform, locate it, and update it before draw calls.

Explore vertex arrays in OpenGL, their relation to vertex buffers and vertex attribute pointers, and how core versus compatibility profiles determine the need for a vertex array object.

Abstract vertex and index buffers into dedicated classes, reorganize buffer data with vertex array objects and layouts, and structure shaders and rendering code for a neater OpenGL project.

Learn to abstract the vertex array into its own class, organizing vertex buffers, index buffers, and a buffer layout to create a reusable vertex array object in OpenGL.

Abstracts OpenGL buffer layouts by implementing a vertex array object, binding and deleting it in the constructor and destructor, and adding simple bind and unbind operations.

Master OpenGL vertex array and buffer layout abstraction with template specialization, stride calculations, and binding for vertex and index buffers to render a square.

Abstract shader code by loading from a file or string, binding with a use-like function, and configuring uniforms such as a vec4 color via get uniform location.

Continue abstracting shader code by implementing shader source structures and compile, bind, and set-uniform logic, and cache uniform locations with an unordered_map for a future renderer with textures and blending.

Build a simple renderer by abstracting draw calls into a dedicated renderer class that uses a vertex array, index buffer, and shader, enabling multiple renderers and streamlined OpenGL rendering.

Apply textures in OpenGL by importing an image, loading it into CPU memory with stb_image, then push to the GPU and render it on a rectangle or sprite via shaders.

Extend OpenGL textures with a texture class, load and flip images via stb_image, configure filters and wrap, upload to the GPU, and bind to a shader sampler.

explore implementing textures in OpenGL by adding texture coordinates, linking vertex and fragment shaders via a varying, sampling with a sampler 2D, and enabling blending for crisp results.

Learn to use the GLM OpenGL mathematics library to implement an orthographic projection for a 4:3 window. Apply a model view projection matrix in shaders using GLM mat4.

Deepen your understanding of the projection matrix in OpenGL, focusing on orthographic projection and its normalization to device coordinates. Learn how MVP multiplies with vertex data to drive rendering.

Explore the transformation pipeline in OpenGL by learning model, view, and projection matrices (MVP). See how multiplying 4x4 matrices transforms vertices, simulates a camera, and moves the model with correct order.

Learn to integrate ImGui with OpenGL to render on-screen UI elements, including text, sliders, and buttons, and use live controls to adjust a 3D model’s translation and MVP matrix.