Elie at 14:32, 30 November 2022

2022-11-30T14:32:05Z

← Older revision		Revision as of 10:32, 30 November 2022
Line 1:		Line 1:
	C header for easy OpenGL programming. Gets rid of most boilerplate code.		C header for easy OpenGL programming.

			Gets rid of most boilerplate code. With this, you don't even implement <code>main()</code> - you implement 3 functions <code>init()</code>, <code>draw()</code>, and <code>done()</code>. For more info and examples of how to use it, check out https://github.com/Elie9001/opengl-starter-kit

	==Code==		==Code==

Elie: Created page with "C header for easy OpenGL programming. Gets rid of most boilerplate code. ==Code== /* Elie's OpenGL wrapper Creates a fullscreen vsync'd context with game-style access to keyboard & mouse. Version 1.1 */ #pragma once // This header file implements main(). // Here are the functions you must define in your own code: void init(); void draw(); void done(); /** Notes: * * The init() function is called once at startup. This is the place..."

2022-11-30T13:51:25Z

Created page with "C header for easy OpenGL programming. Gets rid of most boilerplate code. ==Code== <syntaxhighlight lang="c"> ** Elie's OpenGL wrapper Creates a fullscreen vsync'd context with game-style access to keyboard & mouse. Version 1.1 **: #pragma once // This header file implements main(). // Here are the functions you must define in your own code: void init(); void draw(); void done(); /** Notes: * * The init() function is called once at startup. This is the place..."

New page

C header for easy OpenGL programming. Gets rid of most boilerplate code.

==Code==
<syntaxhighlight lang="c">
/***
Elie's OpenGL wrapper
Creates a fullscreen vsync'd context with game-style access to keyboard & mouse.
Version 1.1
***/
#pragma once

// This header file implements main().
// Here are the functions you must define in your own code:
void init();
void draw();
void done();

/** Notes:
*
* The init() function is called once at startup. This is the place to set up your shaders, textures, display lists, etc.
* The draw() function is called at every frame. This is the place for your OpenGL drawing code, such as calling your lists etc.
* The done() function is called once at shutdown. This is the place to delete your shaders, textures, display lists, etc.
*
* The program keeps running until the user presses ESC. (This can be overridden; see below)
*
* To access keyboard and mouse within your draw() function, read the following globals:
* keymap[] : ascii keys - For example, to check if the 'W' key is held down: code: if (keymap['W']) { ... } Note that you must use uppercase letters here. Also, if you want to respond to a keypress only once when it's pressed (instead of on every frame the key is held down): code: if (keymap['W']==KEY_FRESHLY_PRESSED) { ... }
* special_keymap[] : non-ascii keys, as defined by GLUT constants.
* _mouse_dx: mouse pointer motion (as fraction of window size) per frame
* _mouse_dy: mouse pointer motion (as fraction of window size) per frame
* Or,
* if you like standard controls (W,A,S,D + arrow keys), you can use these macros:
* keyboard_dz() : forward / backward
* keyboard_dy() : jump / duck
* keyboard_dx() : strafe
*
* Other globals:
* _screen_x, _screen_y : The screen width & height, in pixels
* _screen_size : Geometric average of width & height. Useful as a general "screen size" no matter the aspect ratio. Think of it as "if all the screen's pixels were rearranged in a square, it would be how many pixels across" = sqrt(_screen_x * _screen_y)
* _global_argc, _global_argv: Same as argc & argv from main().
*
* Compiler flags needed when you use this header file:
* -ffast-math -O -lGL -lglut -lm
*
* defines available:
* #define NO_ESCAPE : Disable the default 'ESC to quit' functionality. And then you'll need the line '_exit_the_program = GL_TRUE;' somewhere in your draw() code. Otherwise your program will never quit, and you'll be stuck in fullscreen mode forever.
* Proceed with caution. Beware of accidentally making a program that never exits!
*
* #define VIEWPORT_SCALE 2.0 : This will effectively double your "viewport" size. In other words, the edges of your screen will be at coordinates -0.5 to 0.5, instead of -1.0 to 1.0.
* You might need this feature is you're using a lot of GL_POINTS with point sprites, to prevent them from popping (appearing/disappearing when they are near the screen edges). This is a workaround for OpenGL's badly-designed standard for point-sprites.
* Hopefully this won't actually render extra pixels that you never see. I benchmarked it on an old Radeon graphics card and there was no performance loss. No wasted computations as far as I know. But it should probably be tested on more hardware just to make sure.
* P.S. You can also use other values for VIEWPORT_SCALE, such as 1.2 or 1.5. Just beware of scales too big - you don't want your viewport to exceed GL_MAX_VIEWPORT_DIMS.
*
* #define USE_PRE_INIT : You get to define an extra function 'pre_init()' which gets called BEFORE the fullscreen window/context gets created. This gives you a chance to quit before the program starts, by setting _exit_the_program = GL_TRUE;
* One use-case might be: Your program requires command-line arguments, and if the args are missing, you want to only display a message in the terminal (no OpenGL).
* argc & argv are available as globals: _global_argc, _global_argv
*
* #define USE_MULTISAMPLING : Basic anti-aliasing mode. Good for triangles/quads/polygons, but useless for GL_POINTS sprites, usually.
*
* #define SHOW_ERROR_LOG : Report OpenGL errors in the terminal.
*
* #define SHOW_FRAME_RATE : Report the number of frames-per-second in the terminal.
*
*
* Author: Elie Goldman Smith
* This file is too trivial to copyright (since it's mostly boilerplate code),
* so it's in the public domain.
*
* Feel free to copy this file into any project.
**/
#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
#include <math.h>
#ifdef USE_GLEW
#include <GL/glew.h>
#else
#define GL_GLEXT_PROTOTYPES
#include <GL/gl.h>
#include <GL/glext.h>
#endif
#include <GL/glut.h>
#define RND() (rand()*(2.0f/RAND_MAX)-1.0f) // random number from -1 to 1
#define RND01() (rand()*(1.0f/RAND_MAX)) // random number from 0 to 1

int _screen_x = 8;
int _screen_y = 8;
GLfloat _screen_size = 8;

#define KEY_FRESHLY_PRESSED 3

char keymap[256] = {0};
#ifdef NO_ESCAPE
void gcb_key_down(unsigned char key, int x, int y) { keymap[toupper(key)] = keymap[tolower(key)] = KEY_FRESHLY_PRESSED; }
#else
void gcb_key_down(unsigned char key, int x, int y) { keymap[toupper(key)] = keymap[tolower(key)] = KEY_FRESHLY_PRESSED; if (key == 27) exit(0); }
#endif
void gcb_key_up (unsigned char key, int x, int y) { keymap[toupper(key)] = keymap[tolower(key)] = 0;} // XXX: toupper only works for letters, not numbers or punctuation. We should really do something more universal like keymap[shiftless(key)] and i would have to define the shiftless() function.

char special_keymap[256] = {0};
void gcb_special_key_down(int key, int x, int y) { special_keymap[(unsigned char)key] = KEY_FRESHLY_PRESSED; }
void gcb_special_key_up (int key, int x, int y) { special_keymap[(unsigned char)key] = 0; }

#define keyboard_dz() (!!keymap['W']-!!keymap['S']+!!special_keymap[GLUT_KEY_UP ]-!!special_keymap[GLUT_KEY_DOWN ] ) // forward/backward
#define keyboard_dy() (!!keymap['Q']-!!keymap['Z']+!!special_keymap[GLUT_KEY_PAGE_UP]-!!special_keymap[GLUT_KEY_PAGE_DOWN]+!!keymap['E']-!!keymap['C']) // jump/duck
#define keyboard_dx() (!!keymap['D']-!!keymap['A']+!!special_keymap[GLUT_KEY_RIGHT ]-!!special_keymap[GLUT_KEY_LEFT ] ) // strafe

int _exit_the_program = GL_FALSE;

GLfloat _mouse_x = 0; // mouse pointer position is
GLfloat _mouse_y = 0; // normalized to _screen_size
GLfloat _mouse_dx = 0;
GLfloat _mouse_dy = 0;
char _mouse_button_map[8] = {0};

void gcb_mouse_motion_with_pointer(int x, int y) {
_mouse_dx = -_mouse_x;
_mouse_dy = -_mouse_y;
_mouse_x = (x - _screen_x/2) * 2.0f/_screen_size;
_mouse_y = (y - _screen_y/2) *-2.0f/_screen_size;
_mouse_dx += _mouse_x;
_mouse_dy += _mouse_y;
}

void gcb_mouse_motion_pointerless(int x, int y) {
int center_x = _screen_x/2;
int center_y = _screen_y/2;
x -= center_x;
y -= center_y;
if (x != 0 || y != 0) {
_mouse_dx = x *-2.0f/_screen_size;
_mouse_dy = y * 2.0f/_screen_size;
glutWarpPointer(center_x, center_y);
}
_mouse_x = _mouse_y = 0;
}

void gcb_mouse_click(int button, int state, int x, int y) {
if (button >= 0 && button < 8) _mouse_button_map[button] = (state==GLUT_DOWN)*KEY_FRESHLY_PRESSED;
_mouse_x = (x - _screen_x/2) * 2.0f/_screen_size;
_mouse_y = (y - _screen_y/2) *-2.0f/_screen_size;
}

void show_mouse() {
glutMotionFunc (gcb_mouse_motion_with_pointer);
glutPassiveMotionFunc(gcb_mouse_motion_with_pointer);
glutSetCursor(GLUT_CURSOR_INHERIT);
}
void hide_mouse() {
glutMotionFunc (gcb_mouse_motion_pointerless);
glutPassiveMotionFunc(gcb_mouse_motion_pointerless);
glutSetCursor(GLUT_CURSOR_NONE);
_mouse_x = _mouse_y = 0; glutWarpPointer(_screen_x/2, _screen_y/2);
}

// btw, my 'gcb' prefix just stands for "glut call-back function"
void gcb_draw_frame()
{
draw();
if (_exit_the_program) exit(0);

// remove the KEY_FRESHLY_PRESSED
for (int i=0; i<256; i++) {
keymap[i] &= 1;
special_keymap[i] &= 1;
}
for (int i=0; i<8; i++) {
_mouse_button_map[i] &= 1;
}
// smooth out the times when mouse dx & dy don't get updated
_mouse_dx *= 0.875f;
_mouse_dy *= 0.875f;

#ifdef SHOW_FRAME_RATE
static int frame=0;
if (++frame >= 64) {
static int prev=0;
int t = glutGet(GLUT_ELAPSED_TIME);
if (prev) {
printf(" %d FPS ", (int)(frame*1000.0/(t-prev)));
fflush(stdout);
}
prev=t; frame=0;
}
#endif

glutSwapBuffers();
}

void gcb_reshape_window(int width, int height)
{
#ifdef VIEWPORT_SCALE
glViewport((GLint)( width*0.5*(1.0-VIEWPORT_SCALE)),
(GLint)(height*0.5*(1.0-VIEWPORT_SCALE)),
(GLint)( width*VIEWPORT_SCALE),
(GLint)(height*VIEWPORT_SCALE));
#else
glViewport(0, 0, (GLint)width, (GLint)height); // default behavior
#endif
_screen_x = width;
_screen_y = height;
_screen_size = sqrtf((float)_screen_x*_screen_y);
_mouse_x = _mouse_y = 0; glutWarpPointer(_screen_x/2, _screen_y/2);
}

#ifdef SHOW_ERROR_LOG
void gcb_errors(GLenum source, GLenum type, GLuint id, GLenum severity,
GLsizei length, const GLchar* message, const void* userParam) {
fprintf(stderr,"GL CALLBACK: %s type = 0x%x, severity = 0x%x, message = %s\n",
(type == GL_DEBUG_TYPE_ERROR ? "** GL ERROR **" : ""),
type, severity, message);
}
#endif
#ifdef USE_PRE_INIT
void pre_init();
#endif

int _global_argc;
char **_global_argv;

int main(int argc, char **argv) {
_global_argc = argc;
_global_argv = argv;
#ifdef USE_PRE_INIT
pre_init(); if (_exit_the_program) return 1;
#endif
#ifdef USE_MULTISAMPLING
glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE | GLUT_DEPTH | GLUT_MULTISAMPLE);
#else
glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE | GLUT_DEPTH);
#endif
glutInitWindowSize(256,144);
glutInit(&argc, argv);
glutCreateWindow("view");
#ifdef USE_GLEW
glewInit();
#endif
glutReshapeFunc(gcb_reshape_window);
glutKeyboardFunc(gcb_key_down);
glutKeyboardUpFunc(gcb_key_up);
glutSpecialFunc(gcb_special_key_down);
glutSpecialUpFunc(gcb_special_key_up);
glutSetKeyRepeat(GLUT_KEY_REPEAT_OFF);
glutMouseFunc(gcb_mouse_click);
glutMotionFunc(gcb_mouse_motion_pointerless);
glutPassiveMotionFunc(gcb_mouse_motion_pointerless);
glutSetCursor(GLUT_CURSOR_NONE);
glutDisplayFunc(gcb_draw_frame);
glutIdleFunc(gcb_draw_frame);
glutFullScreen();

#ifdef SHOW_ERROR_LOG
glEnable(GL_DEBUG_OUTPUT);
glDebugMessageCallback(gcb_errors, 0);
#endif

init();
atexit(done);
glutMainLoop();
return 0;
}

/*
// other input code that might be needed somewhere:
int mod = glutGetModifiers();
if (mod & GLUT_ACTIVE_SHIFT) {}
if (mod & GLUT_ACTIVE_CTRL) {}
if (mod & GLUT_ACTIVE_ALT) {}
*/
</syntaxhighlight>

Code:fullscreen main.h - Revision history

Elie at 14:32, 30 November 2022