linly/opengl-playground
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

It's friday....

Browse Source
This commit is contained in:
Aura Farmer
2024-08-02 14:00:33 +03:00
parent 9cb7a7592b
commit 8544a3277e
12 changed files with 13081 additions and 44 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
.gitignore vendored Normal file
View File

@@ -0,0 +1 @@
/out/

20
Makefile
View File

@@ -3,11 +3,25 @@
# #
# @file # @file
# @version 0.1 # @version 0.1
CC = g++
CFLAGS = -Wall
LIBS = -lglfw -lGLESv2 -lm -lGL -lGLEW -ldl
INCL = ./include
DEPS = gl_utils.cpp glad.c
EXE = pog
all: build run
build: $(EXE).cpp $(DEPS)
$(CC) $(CFLAGS) $^ $(LIBS) -I$(INCL) -o ./out/$(EXE)
debug: $(EXE).cpp $(DEPS)
$(CC) -g $(CFLAGS) $^ $(LIBS) -I$(INCL) -o ./out/$(EXE)-debug
build:
g++ -o ./out/pog pog.cpp -lglfw -lGLESv2 -lm -lGL
run: build run: build
./out/pog ./out/pog
gdb: debug
gdb ./out/debug
# end # end

6
fragment_shader.glsl Normal file
View File

@@ -0,0 +1,6 @@
#version 330 core
out vec4 FragColor;
void main()
{
FragColor = vec4(1.0f, 0.5f, 0.2f, 1.0f);
}

191
gl_utils.cpp Normal file
View File

@@ -0,0 +1,191 @@
/******************************************************************************\
| OpenGL 4 Example Code. |
| Accompanies written series "Anton's OpenGL 4 Tutorials" |
| Email: anton at antongerdelan dot net |
| First version 27 Jan 2014 |
| Dr Anton Gerdelan, Trinity College Dublin, Ireland. |
| See individual libraries separate legal notices |
|******************************************************************************|
| This is just a file holding some commonly-used "utility" functions to keep |
| the main file a bit easier to read. You can might build up something like |
| this as learn more GL. Note that you don't need much code here to do good GL.|
| If you have a big object-oriented engine then maybe you can ask yourself if |
| it is really making life easier. |
\******************************************************************************/
#include "include/gl_utils.h"
#include <assert.h>
#include <stdio.h>
#include <string.h>
#include <time.h>
#define GL_LOG_FILE "gl.log"
#define MAX_SHADER_LENGTH 262144
/*--------------------------------LOG FUNCTIONS-------------------------------*/
bool restart_gl_log() {
FILE* file = fopen( GL_LOG_FILE, "w" );
if ( !file ) {
fprintf( stderr, "ERROR: could not open GL_LOG_FILE log file %s for writing\n", GL_LOG_FILE );
return false;
}
time_t now = time( NULL );
char* date = ctime( &now );
fprintf( file, "GL_LOG_FILE log. local time %s\n", date );
fclose( file );
return true;
}
bool gl_log( const char* message, ... ) {
va_list argptr;
FILE* file = fopen( GL_LOG_FILE, "a" );
if ( !file ) {
fprintf( stderr, "ERROR: could not open GL_LOG_FILE %s file for appending\n", GL_LOG_FILE );
return false;
}
va_start( argptr, message );
vfprintf( file, message, argptr );
va_end( argptr );
fclose( file );
return true;
}
/* same as gl_log except also prints to stderr */
bool gl_log_err( const char* message, ... ) {
va_list argptr;
FILE* file = fopen( GL_LOG_FILE, "a" );
if ( !file ) {
fprintf( stderr, "ERROR: could not open GL_LOG_FILE %s file for appending\n", GL_LOG_FILE );
return false;
}
va_start( argptr, message );
vfprintf( file, message, argptr );
va_end( argptr );
va_start( argptr, message );
vfprintf( stderr, message, argptr );
va_end( argptr );
fclose( file );
return true;
}
void glfw_error_callback( int error, const char* description ) {
fputs( description, stderr );
gl_log_err( "%s\n", description );
}
void _update_fps_counter( GLFWwindow* window ) {
static double previous_seconds = glfwGetTime();
static int frame_count;
double current_seconds = glfwGetTime();
double elapsed_seconds = current_seconds - previous_seconds;
if ( elapsed_seconds > 0.25 ) {
previous_seconds = current_seconds;
double fps = (double)frame_count / elapsed_seconds;
char tmp[128];
sprintf( tmp, "opengl @ fps: %.2f", fps );
glfwSetWindowTitle( window, tmp );
frame_count = 0;
}
frame_count++;
}
/*-----------------------------------SHADERS----------------------------------*/
/* copy a shader from a plain text file into a character array */
bool parse_file_into_str( const char* file_name, char* shader_str, int max_len ) {
FILE* file = fopen( file_name, "r" );
if ( !file ) {
gl_log_err( "ERROR: opening file for reading: %s\n", file_name );
return false;
}
size_t cnt = fread( shader_str, 1, max_len - 1, file );
if ( (int)cnt >= max_len - 1 ) { gl_log_err( "WARNING: file %s too big - truncated.\n", file_name ); }
if ( ferror( file ) ) {
gl_log_err( "ERROR: reading shader file %s\n", file_name );
fclose( file );
return false;
}
// append \0 to end of file string
shader_str[cnt] = 0;
fclose( file );
return true;
}
void print_shader_info_log( GLuint shader_index ) {
int max_length = 2048;
int actual_length = 0;
char log[2048];
glGetShaderInfoLog( shader_index, max_length, &actual_length, log );
printf( "shader info log for GL index %i:\n%s\n", shader_index, log );
gl_log( "shader info log for GL index %i:\n%s\n", shader_index, log );
}
bool create_shader( const char* file_name, GLuint* shader, GLenum type ) {
gl_log( "creating shader from %s...\n", file_name );
char shader_string[MAX_SHADER_LENGTH];
parse_file_into_str( file_name, shader_string, MAX_SHADER_LENGTH );
*shader = glCreateShader( type );
const GLchar* p = (const GLchar*)shader_string;
glShaderSource( *shader, 1, &p, NULL );
glCompileShader( *shader );
// check for compile errors
int params = -1;
glGetShaderiv( *shader, GL_COMPILE_STATUS, &params );
if ( GL_TRUE != params ) {
gl_log_err( "ERROR: GL shader index %i did not compile\n", *shader );
print_shader_info_log( *shader );
return false; // or exit or something
}
gl_log( "shader compiled. index %i\n", *shader );
return true;
}
void print_programme_info_log( GLuint sp ) {
int max_length = 2048;
int actual_length = 0;
char log[2048];
glGetProgramInfoLog( sp, max_length, &actual_length, log );
printf( "program info log for GL index %u:\n%s", sp, log );
gl_log( "program info log for GL index %u:\n%s", sp, log );
}
bool is_programme_valid( GLuint sp ) {
glValidateProgram( sp );
GLint params = -1;
glGetProgramiv( sp, GL_VALIDATE_STATUS, &params );
if ( GL_TRUE != params ) {
gl_log_err( "program %i GL_VALIDATE_STATUS = GL_FALSE\n", sp );
print_programme_info_log( sp );
return false;
}
gl_log( "program %i GL_VALIDATE_STATUS = GL_TRUE\n", sp );
return true;
}
bool create_programme( GLuint vert, GLuint frag, GLuint* programme ) {
*programme = glCreateProgram();
gl_log( "created programme %u. attaching shaders %u and %u...\n", *programme, vert, frag );
glAttachShader( *programme, vert );
glAttachShader( *programme, frag );
// link the shader programme. if binding input attributes do that before link
glLinkProgram( *programme );
GLint params = -1;
glGetProgramiv( *programme, GL_LINK_STATUS, &params );
if ( GL_TRUE != params ) {
gl_log_err( "ERROR: could not link shader programme GL index %u\n", *programme );
print_programme_info_log( *programme );
return false;
}
( is_programme_valid( *programme ) );
// delete shaders here to free memory
glDeleteShader( vert );
glDeleteShader( frag );
return true;
}
GLuint create_programme_from_files( const char* vert_file_name, const char* frag_file_name ) {
GLuint vert, frag, programme;
( create_shader( vert_file_name, &vert, GL_VERTEX_SHADER ) );
( create_shader( frag_file_name, &frag, GL_FRAGMENT_SHADER ) );
( create_programme( vert, frag, &programme ) );
return programme;
}

4579
glad.c Normal file
View File

File diff suppressed because it is too large Load Diff

186
hello_triangle.cpp Normal file
View File

@@ -0,0 +1,186 @@
#include <EGL/egl.h>
#include <GL/glew.h>
#include <GL/glut.h>
#include <GLFW/glfw3.h>
// #include <GLES2/gl2.h>
#include "pog.h"
#include <iostream>
void framebuffer_size_callback(GLFWwindow* window, int width, int height);
void processInput(GLFWwindow *window);
// settings
const unsigned int SCR_WIDTH = 800;
const unsigned int SCR_HEIGHT = 600;
const char *vertexShaderSource = "#version 330 core\n"
"layout (location = 0) in vec3 aPos;\n"
"void main()\n"
"{\n"
" gl_Position = vec4(aPos.x, aPos.y, aPos.z, 1.0);\n"
"}\0";
const char *fragmentShaderSource = "#version 330 core\n"
"out vec4 FragColor;\n"
"void main()\n"
"{\n"
" FragColor = vec4(1.0f, 0.5f, 0.2f, 1.0f);\n"
"}\n\0";
int main()
{
// glfw: initialize and configure
// ------------------------------
glfwInit();
glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
#ifdef __APPLE__
glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE);
#endif
// glfw window creation
// --------------------
GLFWwindow* window = glfwCreateWindow(SCR_WIDTH, SCR_HEIGHT, "LearnOpenGL", NULL, NULL);
if (window == NULL)
{
std::cout << "Failed to create GLFW window" << std::endl;
glfwTerminate();
return -1;
}
glfwMakeContextCurrent(window);
glfwSetFramebufferSizeCallback(window, framebuffer_size_callback);
// glad: load all OpenGL function pointers
// ---------------------------------------
// if (!gladLoadGLLoader((GLADloadproc)glfwGetProcAddress))
// {
// std::cout << "Failed to initialize GLAD" << std::endl;
// return -1;
// }
// build and compile our shader program
// ------------------------------------
// vertex shader
unsigned int vertexShader = glCreateShader(GL_VERTEX_SHADER);
glShaderSource(vertexShader, 1, &vertexShaderSource, NULL);
glCompileShader(vertexShader);
// check for shader compile errors
int success;
char infoLog[512];
glGetShaderiv(vertexShader, GL_COMPILE_STATUS, &success);
if (!success)
{
glGetShaderInfoLog(vertexShader, 512, NULL, infoLog);
std::cout << "ERROR::SHADER::VERTEX::COMPILATION_FAILED\n" << infoLog << std::endl;
}
// fragment shader
unsigned int fragmentShader = glCreateShader(GL_FRAGMENT_SHADER);
glShaderSource(fragmentShader, 1, &fragmentShaderSource, NULL);
glCompileShader(fragmentShader);
// check for shader compile errors
glGetShaderiv(fragmentShader, GL_COMPILE_STATUS, &success);
if (!success)
{
glGetShaderInfoLog(fragmentShader, 512, NULL, infoLog);
std::cout << "ERROR::SHADER::FRAGMENT::COMPILATION_FAILED\n" << infoLog << std::endl;
}
// link shaders
unsigned int shaderProgram = glCreateProgram();
glAttachShader(shaderProgram, vertexShader);
glAttachShader(shaderProgram, fragmentShader);
glLinkProgram(shaderProgram);
// check for linking errors
glGetProgramiv(shaderProgram, GL_LINK_STATUS, &success);
if (!success) {
glGetProgramInfoLog(shaderProgram, 512, NULL, infoLog);
std::cout << "ERROR::SHADER::PROGRAM::LINKING_FAILED\n" << infoLog << std::endl;
}
glDeleteShader(vertexShader);
glDeleteShader(fragmentShader);
// set up vertex data (and buffer(s)) and configure vertex attributes
// ------------------------------------------------------------------
float vertices[] = {
-0.5f, -0.5f, 0.0f, // left
0.5f, -0.5f, 0.0f, // right
0.0f, 0.5f, 0.0f // top
};
unsigned int VBO, VAO;
glGenVertexArrays(1, &VAO);
glGenBuffers(1, &VBO);
// bind the Vertex Array Object first, then bind and set vertex buffer(s), and then configure vertex attributes(s).
glBindVertexArray(VAO);
glBindBuffer(GL_ARRAY_BUFFER, VBO);
glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(float), (void*)0);
glEnableVertexAttribArray(0);
// note that this is allowed, the call to glVertexAttribPointer registered VBO as the vertex attribute's bound vertex buffer object so afterwards we can safely unbind
glBindBuffer(GL_ARRAY_BUFFER, 0);
// You can unbind the VAO afterwards so other VAO calls won't accidentally modify this VAO, but this rarely happens. Modifying other
// VAOs requires a call to glBindVertexArray anyways so we generally don't unbind VAOs (nor VBOs) when it's not directly necessary.
glBindVertexArray(0);
// uncomment this call to draw in wireframe polygons.
//glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
// render loop
// -----------
while (!glfwWindowShouldClose(window))
{
// input
// -----
processInput(window);
// render
// ------
glClearColor(0.2f, 0.3f, 0.3f, 1.0f);
glClear(GL_COLOR_BUFFER_BIT);
// draw our first triangle
glUseProgram(shaderProgram);
glBindVertexArray(VAO); // seeing as we only have a single VAO there's no need to bind it every time, but we'll do so to keep things a bit more organized
glDrawArrays(GL_TRIANGLES, 0, 3);
// glBindVertexArray(0); // no need to unbind it every time
// glfw: swap buffers and poll IO events (keys pressed/released, mouse moved etc.)
// -------------------------------------------------------------------------------
glfwSwapBuffers(window);
glfwPollEvents();
}
// optional: de-allocate all resources once they've outlived their purpose:
// ------------------------------------------------------------------------
glDeleteVertexArrays(1, &VAO);
glDeleteBuffers(1, &VBO);
glDeleteProgram(shaderProgram);
// glfw: terminate, clearing all previously allocated GLFW resources.
// ------------------------------------------------------------------
glfwTerminate();
return 0;
}
// process all input: query GLFW whether relevant keys are pressed/released this frame and react accordingly
// ---------------------------------------------------------------------------------------------------------
void processInput(GLFWwindow *window)
{
if (glfwGetKey(window, GLFW_KEY_ESCAPE) == GLFW_PRESS)
glfwSetWindowShouldClose(window, true);
}
// glfw: whenever the window size changed (by OS or user resize) this callback function executes
// ---------------------------------------------------------------------------------------------
void framebuffer_size_callback(GLFWwindow* window, int width, int height)
{
// make sure the viewport matches the new window dimensions; note that width and
// height will be significantly larger than specified on retina displays.
glViewport(0, 0, width, height);
}

290
include/KHR/khrplatform.h Normal file
View File

@@ -0,0 +1,290 @@
#ifndef __khrplatform_h_
#define __khrplatform_h_
/*
** Copyright (c) 2008-2018 The Khronos Group Inc.
**
** Permission is hereby granted, free of charge, to any person obtaining a
** copy of this software and/or associated documentation files (the
** "Materials"), to deal in the Materials without restriction, including
** without limitation the rights to use, copy, modify, merge, publish,
** distribute, sublicense, and/or sell copies of the Materials, and to
** permit persons to whom the Materials are furnished to do so, subject to
** the following conditions:
**
** The above copyright notice and this permission notice shall be included
** in all copies or substantial portions of the Materials.
**
** THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
** EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
** MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
** IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
** CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
** TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
** MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.
*/
/* Khronos platform-specific types and definitions.
*
* The master copy of khrplatform.h is maintained in the Khronos EGL
* Registry repository at https://github.com/KhronosGroup/EGL-Registry
* The last semantic modification to khrplatform.h was at commit ID:
* 67a3e0864c2d75ea5287b9f3d2eb74a745936692
*
* Adopters may modify this file to suit their platform. Adopters are
* encouraged to submit platform specific modifications to the Khronos
* group so that they can be included in future versions of this file.
* Please submit changes by filing pull requests or issues on
* the EGL Registry repository linked above.
*
*
* See the Implementer's Guidelines for information about where this file
* should be located on your system and for more details of its use:
* http://www.khronos.org/registry/implementers_guide.pdf
*
* This file should be included as
* #include <KHR/khrplatform.h>
* by Khronos client API header files that use its types and defines.
*
* The types in khrplatform.h should only be used to define API-specific types.
*
* Types defined in khrplatform.h:
* khronos_int8_t signed 8 bit
* khronos_uint8_t unsigned 8 bit
* khronos_int16_t signed 16 bit
* khronos_uint16_t unsigned 16 bit
* khronos_int32_t signed 32 bit
* khronos_uint32_t unsigned 32 bit
* khronos_int64_t signed 64 bit
* khronos_uint64_t unsigned 64 bit
* khronos_intptr_t signed same number of bits as a pointer
* khronos_uintptr_t unsigned same number of bits as a pointer
* khronos_ssize_t signed size
* khronos_usize_t unsigned size
* khronos_float_t signed 32 bit floating point
* khronos_time_ns_t unsigned 64 bit time in nanoseconds
* khronos_utime_nanoseconds_t unsigned time interval or absolute time in
* nanoseconds
* khronos_stime_nanoseconds_t signed time interval in nanoseconds
* khronos_boolean_enum_t enumerated boolean type. This should
* only be used as a base type when a client API's boolean type is
* an enum. Client APIs which use an integer or other type for
* booleans cannot use this as the base type for their boolean.
*
* Tokens defined in khrplatform.h:
*
* KHRONOS_FALSE, KHRONOS_TRUE Enumerated boolean false/true values.
*
* KHRONOS_SUPPORT_INT64 is 1 if 64 bit integers are supported; otherwise 0.
* KHRONOS_SUPPORT_FLOAT is 1 if floats are supported; otherwise 0.
*
* Calling convention macros defined in this file:
* KHRONOS_APICALL
* KHRONOS_APIENTRY
* KHRONOS_APIATTRIBUTES
*
* These may be used in function prototypes as:
*
* KHRONOS_APICALL void KHRONOS_APIENTRY funcname(
* int arg1,
* int arg2) KHRONOS_APIATTRIBUTES;
*/
#if defined(__SCITECH_SNAP__) && !defined(KHRONOS_STATIC)
# define KHRONOS_STATIC 1
#endif
/*-------------------------------------------------------------------------
* Definition of KHRONOS_APICALL
*-------------------------------------------------------------------------
* This precedes the return type of the function in the function prototype.
*/
#if defined(KHRONOS_STATIC)
/* If the preprocessor constant KHRONOS_STATIC is defined, make the
* header compatible with static linking. */
# define KHRONOS_APICALL
#elif defined(_WIN32)
# define KHRONOS_APICALL __declspec(dllimport)
#elif defined (__SYMBIAN32__)
# define KHRONOS_APICALL IMPORT_C
#elif defined(__ANDROID__)
# define KHRONOS_APICALL __attribute__((visibility("default")))
#else
# define KHRONOS_APICALL
#endif
/*-------------------------------------------------------------------------
* Definition of KHRONOS_APIENTRY
*-------------------------------------------------------------------------
* This follows the return type of the function and precedes the function
* name in the function prototype.
*/
#if defined(_WIN32) && !defined(_WIN32_WCE) && !defined(__SCITECH_SNAP__)
/* Win32 but not WinCE */
# define KHRONOS_APIENTRY __stdcall
#else
# define KHRONOS_APIENTRY
#endif
/*-------------------------------------------------------------------------
* Definition of KHRONOS_APIATTRIBUTES
*-------------------------------------------------------------------------
* This follows the closing parenthesis of the function prototype arguments.
*/
#if defined (__ARMCC_2__)
#define KHRONOS_APIATTRIBUTES __softfp
#else
#define KHRONOS_APIATTRIBUTES
#endif
/*-------------------------------------------------------------------------
* basic type definitions
*-----------------------------------------------------------------------*/
#if (defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L) || defined(__GNUC__) || defined(__SCO__) || defined(__USLC__)
/*
* Using <stdint.h>
*/
#include <stdint.h>
typedef int32_t khronos_int32_t;
typedef uint32_t khronos_uint32_t;
typedef int64_t khronos_int64_t;
typedef uint64_t khronos_uint64_t;
#define KHRONOS_SUPPORT_INT64 1
#define KHRONOS_SUPPORT_FLOAT 1
#elif defined(__VMS ) || defined(__sgi)
/*
* Using <inttypes.h>
*/
#include <inttypes.h>
typedef int32_t khronos_int32_t;
typedef uint32_t khronos_uint32_t;
typedef int64_t khronos_int64_t;
typedef uint64_t khronos_uint64_t;
#define KHRONOS_SUPPORT_INT64 1
#define KHRONOS_SUPPORT_FLOAT 1
#elif defined(_WIN32) && !defined(__SCITECH_SNAP__)
/*
* Win32
*/
typedef __int32 khronos_int32_t;
typedef unsigned __int32 khronos_uint32_t;
typedef __int64 khronos_int64_t;
typedef unsigned __int64 khronos_uint64_t;
#define KHRONOS_SUPPORT_INT64 1
#define KHRONOS_SUPPORT_FLOAT 1
#elif defined(__sun__) || defined(__digital__)
/*
* Sun or Digital
*/
typedef int khronos_int32_t;
typedef unsigned int khronos_uint32_t;
#if defined(__arch64__) || defined(_LP64)
typedef long int khronos_int64_t;
typedef unsigned long int khronos_uint64_t;
#else
typedef long long int khronos_int64_t;
typedef unsigned long long int khronos_uint64_t;
#endif /* __arch64__ */
#define KHRONOS_SUPPORT_INT64 1
#define KHRONOS_SUPPORT_FLOAT 1
#elif 0
/*
* Hypothetical platform with no float or int64 support
*/
typedef int khronos_int32_t;
typedef unsigned int khronos_uint32_t;
#define KHRONOS_SUPPORT_INT64 0
#define KHRONOS_SUPPORT_FLOAT 0
#else
/*
* Generic fallback
*/
#include <stdint.h>
typedef int32_t khronos_int32_t;
typedef uint32_t khronos_uint32_t;
typedef int64_t khronos_int64_t;
typedef uint64_t khronos_uint64_t;
#define KHRONOS_SUPPORT_INT64 1
#define KHRONOS_SUPPORT_FLOAT 1
#endif
/*
* Types that are (so far) the same on all platforms
*/
typedef signed char khronos_int8_t;
typedef unsigned char khronos_uint8_t;
typedef signed short int khronos_int16_t;
typedef unsigned short int khronos_uint16_t;
/*
* Types that differ between LLP64 and LP64 architectures - in LLP64,
* pointers are 64 bits, but 'long' is still 32 bits. Win64 appears
* to be the only LLP64 architecture in current use.
*/
#ifdef _WIN64
typedef signed long long int khronos_intptr_t;
typedef unsigned long long int khronos_uintptr_t;
typedef signed long long int khronos_ssize_t;
typedef unsigned long long int khronos_usize_t;
#else
typedef signed long int khronos_intptr_t;
typedef unsigned long int khronos_uintptr_t;
typedef signed long int khronos_ssize_t;
typedef unsigned long int khronos_usize_t;
#endif
#if KHRONOS_SUPPORT_FLOAT
/*
* Float type
*/
typedef float khronos_float_t;
#endif
#if KHRONOS_SUPPORT_INT64
/* Time types
*
* These types can be used to represent a time interval in nanoseconds or
* an absolute Unadjusted System Time. Unadjusted System Time is the number
* of nanoseconds since some arbitrary system event (e.g. since the last
* time the system booted). The Unadjusted System Time is an unsigned
* 64 bit value that wraps back to 0 every 584 years. Time intervals
* may be either signed or unsigned.
*/
typedef khronos_uint64_t khronos_utime_nanoseconds_t;
typedef khronos_int64_t khronos_stime_nanoseconds_t;
#endif
/*
* Dummy value used to pad enum types to 32 bits.
*/
#ifndef KHRONOS_MAX_ENUM
#define KHRONOS_MAX_ENUM 0x7FFFFFFF
#endif
/*
* Enumerated boolean type
*
* Values other than zero should be considered to be true. Therefore
* comparisons should not be made against KHRONOS_TRUE.
*/
typedef enum {
KHRONOS_FALSE = 0,
KHRONOS_TRUE = 1,
KHRONOS_BOOLEAN_ENUM_FORCE_SIZE = KHRONOS_MAX_ENUM
} khronos_boolean_enum_t;
#endif /* __khrplatform_h_ */

47
include/gl_utils.h Normal file
View File

@@ -0,0 +1,47 @@
/******************************************************************************\
| OpenGL 4 Example Code. |
| Accompanies written series "Anton's OpenGL 4 Tutorials" |
| Email: anton at antongerdelan dot net |
| First version 27 Jan 2014 |
| Dr Anton Gerdelan, Trinity College Dublin, Ireland. |
| See individual libraries for separate legal notices |
\******************************************************************************/
#ifndef _GL_UTILS_H_
#define _GL_UTILS_H_
#include "glad/glad.h" // include GLEW and new version of GL on Windows
#include <GLFW/glfw3.h> // GLFW helper library
#include <stdarg.h>
#define GL_LOG_FILE "gl.log"
extern GLFWwindow* g_window;
bool restart_gl_log();
bool gl_log( const char* message, ... );
/* same as gl_log except also prints to stderr */
bool gl_log_err( const char* message, ... );
void glfw_error_callback( int error, const char* description );
void log_gl_params();
void _update_fps_counter( GLFWwindow* window );
const char* GL_type_to_string( unsigned int type );
void print_shader_info_log( GLuint shader_index );
void print_programme_info_log( GLuint sp );
void print_all( GLuint sp );
bool is_valid( GLuint sp );
bool parse_file_into_str( const char* file_name, char* shader_str, int max_len );
GLuint create_programme_from_files( const char* vert_file_name, const char* frag_file_name );
#endif

7688
include/glad/glad.h Normal file
View File

File diff suppressed because it is too large Load Diff

107
pog.cpp
View File

@@ -1,12 +1,12 @@
#include <GL/glew.h>
#include <GLFW/glfw3.h>
#include <EGL/egl.h> #include <EGL/egl.h>
// #include <GL/glew.h>
#include "include/gl_utils.h"
#include <GL/glut.h> #include <GL/glut.h>
#include <GLFW/glfw3.h>
// #include <GLES2/gl2.h> // #include <GLES2/gl2.h>
#include <iostream>
#include "pog.h" #include "pog.h"
#include <iostream>
int main() { int main() {
int x;
glfwInit(); glfwInit();
glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3); glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3); glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
@@ -23,28 +23,22 @@ int main() {
glfwMakeContextCurrent(window); glfwMakeContextCurrent(window);
glfwSetFramebufferSizeCallback(window, framebuffer_size_callback); glfwSetFramebufferSizeCallback(window, framebuffer_size_callback);
while (!glfwWindowShouldClose(window)) { // glad: load all OpenGL function pointers
processInput(window); // ---------------------------------------
if (!gladLoadGLLoader((GLADloadproc)glfwGetProcAddress)) {
glClearColor(0.2f, 0.3f, 0.6f, 1.0f); std::cout << "Failed to initialize GLAD" << std::endl;
glClear(GL_COLOR_BUFFER_BIT); return -1;
}
glfwSwapBuffers(window); if (!GLAD_GL_ARB_direct_state_access) {
glfwPollEvents(); /* see
* https://www.khronos.org/registry/OpenGL/extensions/ARB/ARB_direct_state_access.txt
* https://www.khronos.org/opengl/wiki/Direct_State_Access. This is the way.
*/
std::cout << "DSA not supported!" << std::endl;
return -1;
} }
float vertices[] = {
-0.5f, -0.5f, 0.0f,
0.5f, -0.5f, 0.0f,
0.0f, 0.5f, 0.0f
};
unsigned int VBO; // compiling the shaders
glGenBuffers(1, &VBO);
glBindBuffer(GL_ARRAY_BUFFER, VBO);
glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);
//compiling the shaders
const char *vertexShaderSource = const char *vertexShaderSource =
"#version 330 core\n" "#version 330 core\n"
"layout (location = 0) in vec3 aPos;\n" "layout (location = 0) in vec3 aPos;\n"
@@ -53,7 +47,7 @@ int main() {
" gl_Position = vec4(aPos.x, aPos.y, aPos.z, 1.0);\n" " gl_Position = vec4(aPos.x, aPos.y, aPos.z, 1.0);\n"
"}\0"; "}\0";
unsigned int vertexShader; unsigned int vertexShader;
vertexShader = glCreateShader(GL_VERTEX_SHADER); //compile code vertexShader = glCreateShader(GL_VERTEX_SHADER); // compile code
glShaderSource(vertexShader, 1, &vertexShaderSource, NULL); glShaderSource(vertexShader, 1, &vertexShaderSource, NULL);
glCompileShader(vertexShader); glCompileShader(vertexShader);
@@ -66,7 +60,7 @@ int main() {
glGetShaderInfoLog(vertexShader, 512, NULL, infoLog); glGetShaderInfoLog(vertexShader, 512, NULL, infoLog);
std::cout << "ERROR::SHADER::VERTEX::COMPILATION_FAILED\n" std::cout << "ERROR::SHADER::VERTEX::COMPILATION_FAILED\n"
<< infoLog << std::endl; << infoLog << std::endl;
} //check if compilation succesful } // check if compilation succesful
const char *fragmentShaderSource = const char *fragmentShaderSource =
"#version 330 core\n" "#version 330 core\n"
"layout (location = 0) in vec3 aPos;\n" "layout (location = 0) in vec3 aPos;\n"
@@ -78,42 +72,73 @@ int main() {
unsigned int fragmentShader; unsigned int fragmentShader;
fragmentShader = glCreateShader(GL_FRAGMENT_SHADER); fragmentShader = glCreateShader(GL_FRAGMENT_SHADER);
glShaderSource(fragmentShader, 1, &fragmentShaderSource, NULL); glShaderSource(fragmentShader, 1, &fragmentShaderSource, NULL);
glCompileShader(fragmentShader); //compile fragment shader glCompileShader(fragmentShader); // compile fragment shader
unsigned int shaderProgram; unsigned int shaderProgram;
shaderProgram = glCreateProgram(); //create shader program shaderProgram = glCreateProgram(); // create shader program
//attaching shaders to our program // attaching shaders to our program
glAttachShader(shaderProgram, vertexShader); glAttachShader(shaderProgram, vertexShader);
glAttachShader(shaderProgram, fragmentShader); glAttachShader(shaderProgram, fragmentShader);
glLinkProgram(shaderProgram); glLinkProgram(shaderProgram);
glUseProgram(shaderProgram); //use it NOW glUseProgram(shaderProgram); // use it NOW
//not needed anymore they're linked // not needed anymore they're linked
glDeleteShader(vertexShader); glDeleteShader(vertexShader);
glDeleteShader(fragmentShader); glDeleteShader(fragmentShader);
//tell OpenGL's stupid existence how to interpret data // Vertex data
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(float), (void *)0); float vertices[] = {-0.5f, -0.5f, 0.0f, 0.5f, -0.5f, 0.0f, 0.0f, 0.5f, 0.0f};
glEnableVertexAttribArray(0);
// 0. copy our vertices array in a buffer for OpenGL to use unsigned int VBO, VAO;
glGenBuffers(1, &VBO);
// bind vertex object
glGenVertexArrays(1, &VAO);
glBindBuffer(GL_ARRAY_BUFFER, VBO); glBindBuffer(GL_ARRAY_BUFFER, VBO);
glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW); glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);
// 1. then set the vertex attributes pointers
// tell OpenGL's stupid existence how to interpret data
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(float), (void *)0); glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(float), (void *)0);
glEnableVertexAttribArray(0); glEnableVertexAttribArray(0);
// 2. use our shader program when we want to render an object
glUseProgram(shaderProgram);
// 3. now draw the object
unsigned int VAO; while (!glfwWindowShouldClose(window)) {
glGenVertexArrays(1, &VAO); // input
// -----
processInput(window);
// render
// ------
glClearColor(0.2f, 0.3f, 0.3f, 1.0f);
glClear(GL_COLOR_BUFFER_BIT);
// draw our first triangle
glUseProgram(shaderProgram);
glBindVertexArray(
VAO); // seeing as we only have a single VAO there's no need to bind it
// every time, but we'll do so to keep things a bit more organized
glDrawArrays(GL_TRIANGLES, 0, 3);
// glBindVertexArray(0); // no need to unbind it every time
// glfw: swap buffers and poll IO events (keys pressed/released, mouse moved
// etc.)
// -------------------------------------------------------------------------------
glfwSwapBuffers(window);
glfwPollEvents();
}
// optional: de-allocate all resources once they've outlived their purpose:
// ------------------------------------------------------------------------
glDeleteVertexArrays(1, &VAO);
glDeleteBuffers(1, &VBO);
glDeleteProgram(shaderProgram);
// glfw: terminate, clearing all previously allocated GLFW resources.
// ------------------------------------------------------------------
glfwTerminate(); glfwTerminate();
return 0; return 0;
} }
void framebuffer_size_callback(GLFWwindow *window, int width, int height) { void framebuffer_size_callback(GLFWwindow *window, int width, int height) {
glViewport(0, 0, width, height); glViewport(0, 0, width, height);
} }

4
pog.h Normal file
View File

@@ -0,0 +1,4 @@
#include <GLFW/glfw3.h>
void framebuffer_size_callback(GLFWwindow* window, int width, int height);
void processInput(GLFWwindow *window);

6
vertex_shader.glsl Normal file
View File

@@ -0,0 +1,6 @@
#version 330 core
layout (location = 0) in vec3 aPos;
void main()
{
gl_Position = vec4(aPos.x, aPos.y, aPos.z, 1.0);
}