Unity-Technologies
/
emscripten
зеркало из https://github.com/Unity-Technologies/emscripten.git
1
0
Форкнуть 0
Код Задачи Пакеты Проекты Релизы Вики Активность
emscripten/tests/glfw.c

424 строки
14 KiB
C
Исходник Ответственный История

/*
* Copyright 2013 The Emscripten Authors. All rights reserved.
* Emscripten is available under two separate licenses, the MIT license and the
* University of Illinois/NCSA Open Source License. Both these licenses can be
* found in the LICENSE file.
*/
#include <stdlib.h>
#include <GL/glfw.h>
#include <stdio.h>
#include <assert.h>
#include <emscripten/emscripten.h>
void Init(void);
void Shut_Down(int return_code);
void Iteration(void);
void Draw_Square(float red, float green, float blue);
void Draw(void);
void OnKeyPressed( int key, int action );
void OnCharPressed( int character, int action );
char* GetKeyName(int key);
char* GetParamName(int param);
int OnClose();
void OnResize( int width, int height );
void OnRefresh();
void OnMouseClick( int button, int action );
void OnMouseMove( int x, int y );
void OnMouseWheel( int pos );
void PullInfo();
int params[] = {GLFW_OPENED, GLFW_ACTIVE, GLFW_ICONIFIED, GLFW_ACCELERATED, GLFW_RED_BITS, GLFW_GREEN_BITS, GLFW_BLUE_BITS, GLFW_ALPHA_BITS, GLFW_DEPTH_BITS, GLFW_STENCIL_BITS, GLFW_REFRESH_RATE, GLFW_ACCUM_RED_BITS, GLFW_ACCUM_GREEN_BITS, GLFW_ACCUM_BLUE_BITS, GLFW_ACCUM_ALPHA_BITS, GLFW_AUX_BUFFERS, GLFW_STEREO, GLFW_WINDOW_NO_RESIZE, GLFW_FSAA_SAMPLES, GLFW_OPENGL_VERSION_MAJOR, GLFW_OPENGL_VERSION_MINOR, GLFW_OPENGL_FORWARD_COMPAT, GLFW_OPENGL_DEBUG_CONTEXT, GLFW_OPENGL_PROFILE};
unsigned int nb_params = sizeof(params) / sizeof(int);
int features[] = {GLFW_MOUSE_CURSOR, GLFW_STICKY_KEYS, GLFW_STICKY_MOUSE_BUTTONS, GLFW_SYSTEM_KEYS, GLFW_KEY_REPEAT, GLFW_AUTO_POLL_EVENTS};
unsigned int nb_features = sizeof(features) / sizeof(int);
// Will be set to 1 as soon as OnResize callback is called
int on_resize_called = 0;
float rotate_y = 0,
rotate_z = 0;
const float rotations_per_tick = .2;
// the time of the previous frame
double old_time;
int main(void)
{
Init();
old_time = glfwGetTime();
emscripten_set_main_loop (Iteration, 0, 1);
Shut_Down(0);
}
void Init()
{
const int window_width = 800,
window_height = 600;
if (glfwInit() != GL_TRUE)
Shut_Down(1);
glfwEnable(GLFW_KEY_REPEAT); // test for issue #3059
int red_bits = glfwGetWindowParam(GLFW_RED_BITS);
glfwOpenWindowHint(GLFW_RED_BITS, 8);
assert(glfwGetWindowParam(GLFW_RED_BITS) == 8);
glfwOpenWindowHint(GLFW_RED_BITS, red_bits);
// 800 x 600, 16 bit color, no depth, alpha or stencil buffers, windowed
if (glfwOpenWindow(window_width, window_height, 5, 6, 5,
0, 0, 0, GLFW_WINDOW) != GL_TRUE)
Shut_Down(1);
glfwSetWindowTitle("The GLFW Window");
glfwSetKeyCallback(OnKeyPressed);
glfwSetCharCallback(OnCharPressed);
glfwSetWindowCloseCallback(OnClose);
glfwSetWindowSizeCallback(OnResize);
if (!on_resize_called)
{
Shut_Down(1);
}
glfwSetWindowRefreshCallback(OnRefresh);
glfwSetMouseWheelCallback(OnMouseWheel);
glfwSetMousePosCallback(OnMouseMove);
glfwSetMouseButtonCallback(OnMouseClick);
// set the projection matrix to a normal frustum with a max depth of 50
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
float aspect_ratio = ((float)window_height) / window_width;
glFrustum(.5, -.5, -.5 * aspect_ratio, .5 * aspect_ratio, 1, 50);
glMatrixMode(GL_MODELVIEW);
PullInfo();
}
void Shut_Down(int return_code)
{
glfwTerminate();
exit(return_code);
}
void Iteration()
{
// calculate time elapsed, and the amount by which stuff rotates
double current_time = glfwGetTime(),
delta_rotate = (current_time - old_time) * rotations_per_tick * 360;
old_time = current_time;
if (glfwGetKey(GLFW_KEY_LEFT) == GLFW_PRESS)
rotate_y += delta_rotate;
if (glfwGetKey(GLFW_KEY_RIGHT) == GLFW_PRESS)
rotate_y -= delta_rotate;
// z axis always rotates
rotate_z += delta_rotate;
// clear the buffer
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
// draw the figure
Draw();
// Test that glfwSwapInterval doesn't crash (although we don't test actual timings)
static int i = 0;
glfwSwapInterval(i);
if (i < 2) ++i;
// swap back and front buffers
glfwSwapBuffers();
}
void Draw(void)
{
int width, height, x;
double t;
t = glfwGetTime ();
glfwGetMousePos (&x, NULL);
// Get window size (may be different than the requested size)
glfwGetWindowSize (&width, &height);
// Special case: avoid division by zero below
height = height > 0 ? height : 1;
glViewport (0, 0, width, height);
// Clear color buffer to black
glClearColor (0.1f, 0.2f, 0.3f, 0.0f);
glClear (GL_COLOR_BUFFER_BIT);
// Select and setup the projection matrix
glMatrixMode (GL_PROJECTION);
glLoadIdentity ();
gluPerspective (65.0f, (GLfloat) width / (GLfloat) height, 1.0f, 100.0f);
// Select and setup the modelview matrix
glMatrixMode (GL_MODELVIEW);
glLoadIdentity ();
gluLookAt (0.0f, 1.0f, 0.0f, // Eye-position
0.0f, 20.0f, 0.0f, // View-point
0.0f, 0.0f, 1.0f); // Up-vector
// Draw a rotating colorful triangle
//glTranslatef (0.0f, 14.0f, 0.0f);
glTranslatef (0.0f, 1.0f, 0.0f);
glRotatef (0.3f * (GLfloat) x + (GLfloat) t * 100.0f, 0.0f, 0.0f, 1.0f);
glBegin (GL_TRIANGLES);
glColor3f (1.0f, 0.0f, 0.0f);
glVertex3f (-5.0f, 0.0f, -4.0f);
glColor3f (0.0f, 1.0f, 0.0f);
glVertex3f (5.0f, 0.0f, -4.0f);
glColor3f (0.0f, 0.0f, 1.0f);
glVertex3f (0.0f, 0.0f, 6.0f);
glEnd ();
// Swap buffers
glfwSwapBuffers ();
}
void OnCharPressed( int character, int action ){
if(action == GLFW_PRESS)
printf("'%c' (%i) char is pressed\n", character, character);
if(action == GLFW_RELEASE)
printf("'%c' (%i) char is released\n", character, character);
}
char* GetKeyName(int key){
switch(key){
case GLFW_KEY_UNKNOWN: return "unknown";
case GLFW_KEY_SPACE: return "space";
case GLFW_KEY_SPECIAL: return "special";
case GLFW_KEY_ESC: return "escape";
case GLFW_KEY_F1 : return "F1";
case GLFW_KEY_F2 : return "F2";
case GLFW_KEY_F3 : return "F3";
case GLFW_KEY_F4 : return "F4";
case GLFW_KEY_F5 : return "F5";
case GLFW_KEY_F6 : return "F6";
case GLFW_KEY_F7 : return "F7";
case GLFW_KEY_F8 : return "F8";
case GLFW_KEY_F9 : return "F9";
case GLFW_KEY_F10: return "F10";
case GLFW_KEY_F11: return "F11";
case GLFW_KEY_F12: return "F12";
case GLFW_KEY_F13: return "F13";
case GLFW_KEY_F14: return "F14";
case GLFW_KEY_F15: return "F15";
case GLFW_KEY_F16: return "F16";
case GLFW_KEY_F17: return "F17";
case GLFW_KEY_F18: return "F18";
case GLFW_KEY_F19: return "F19";
case GLFW_KEY_F20: return "F20";
case GLFW_KEY_F21: return "F21";
case GLFW_KEY_F22: return "F22";
case GLFW_KEY_F23: return "F23";
case GLFW_KEY_F24: return "F24";
case GLFW_KEY_F25: return "F25";
case GLFW_KEY_UP : return "up";
case GLFW_KEY_DOWN: return "down";
case GLFW_KEY_LEFT: return "left";
case GLFW_KEY_RIGHT: return "right";
case GLFW_KEY_LSHIFT: return "left shift";
case GLFW_KEY_RSHIFT: return "right shift";
case GLFW_KEY_LCTRL: return "left ctrl";
case GLFW_KEY_RCTRL: return "right ctrl";
case GLFW_KEY_LALT: return "left alt";
case GLFW_KEY_RALT: return "right alt";
case GLFW_KEY_TAB: return "tab";
case GLFW_KEY_ENTER: return "enter";
case GLFW_KEY_BACKSPACE: return "backspace";
case GLFW_KEY_INSERT: return "insertr";
case GLFW_KEY_DEL: return "del";
case GLFW_KEY_PAGEUP: return "page up";
case GLFW_KEY_PAGEDOWN: return "page down";
case GLFW_KEY_HOME: return "home";
case GLFW_KEY_END: return "end";
case GLFW_KEY_KP_0: return "0";
case GLFW_KEY_KP_1: return "1";
case GLFW_KEY_KP_2: return "2";
case GLFW_KEY_KP_3: return "3";
case GLFW_KEY_KP_4: return "4";
case GLFW_KEY_KP_5: return "5";
case GLFW_KEY_KP_6: return "6";
case GLFW_KEY_KP_7: return "7";
case GLFW_KEY_KP_8: return "8";
case GLFW_KEY_KP_9: return "9";
case GLFW_KEY_KP_DIVIDE: return "/";
case GLFW_KEY_KP_MULTIPLY: return "*";
case GLFW_KEY_KP_SUBTRACT: return "-";
case GLFW_KEY_KP_ADD: return "+";
case GLFW_KEY_KP_DECIMAL: return ".";
case GLFW_KEY_KP_EQUAL: return "=";
case GLFW_KEY_KP_ENTER: return "enter";
case GLFW_KEY_KP_NUM_LOCK: return "num lock";
case GLFW_KEY_CAPS_LOCK: return "caps lock";
case GLFW_KEY_SCROLL_LOCK: return "scroll lock";
case GLFW_KEY_PAUSE: return "pause";
case GLFW_KEY_LSUPER: return "left super";
case GLFW_KEY_RSUPER: return "right super";
case GLFW_KEY_MENU: return "menu";
}
char* chr = malloc(2*sizeof(char));
chr[0] = key;
chr[1] = '\0';
return chr;
}
char* GetParamName(int param){
switch(param){
case GLFW_WINDOW : return "GLFW_WINDOW";
case GLFW_FULLSCREEN : return "GLFW_FULLSCREEN";
case GLFW_OPENED : return "GLFW_OPENED";
case GLFW_ACTIVE : return "GLFW_ACTIVE";
case GLFW_ICONIFIED : return "GLFW_ICONIFIED";
case GLFW_ACCELERATED : return "GLFW_ACCELERATED";
case GLFW_RED_BITS : return "GLFW_RED_BITS";
case GLFW_GREEN_BITS : return "GLFW_GREEN_BITS";
case GLFW_BLUE_BITS : return "GLFW_BLUE_BITS";
case GLFW_ALPHA_BITS : return "GLFW_ALPHA_BITS";
case GLFW_DEPTH_BITS : return "GLFW_DEPTH_BITS";
case GLFW_STENCIL_BITS : return "GLFW_STENCIL_BITS";
case GLFW_REFRESH_RATE : return "GLFW_REFRESH_RATE";
case GLFW_ACCUM_RED_BITS : return "GLFW_ACCUM_RED_BITS";
case GLFW_ACCUM_GREEN_BITS : return "GLFW_ACCUM_GREEN_BITS";
case GLFW_ACCUM_BLUE_BITS : return "GLFW_BLUE_BITS";
case GLFW_ACCUM_ALPHA_BITS : return "GLFW_ALPHA_BITS";
case GLFW_AUX_BUFFERS : return "GLFW_AUX_BUFFERS";
case GLFW_STEREO : return "GLFW_STEREO";
case GLFW_WINDOW_NO_RESIZE : return "GLFW_WINDOW_NO_RESIZE";
case GLFW_FSAA_SAMPLES : return "GLFW_FSAA_SAMPLES";
case GLFW_OPENGL_VERSION_MAJOR : return "GLFW_OPENGL_VERSION_MAJOR";
case GLFW_OPENGL_VERSION_MINOR : return "GLFW_OPENGL_VERSION_MINOR";
case GLFW_OPENGL_FORWARD_COMPAT : return "GLFW_OPENGL_FORWARD_COMPAT";
case GLFW_OPENGL_DEBUG_CONTEXT : return "GLFW_OPENGL_DEBUG_CONTEXT";
case GLFW_OPENGL_PROFILE : return "GLFW_OPENGL_PROFILE";
case GLFW_OPENGL_CORE_PROFILE : return "GLFW_OPENGL_CORE_PROFILE | GLFW_PRESENT";
case GLFW_OPENGL_COMPAT_PROFILE : return "GLFW_OPENGL_COMPAT_PROFILE | GLFW_AXES";
case GLFW_MOUSE_CURSOR : return "GLFW_MOUSE_CURSOR";
case GLFW_STICKY_KEYS : return "GLFW_STICKY_KEYS";
case GLFW_STICKY_MOUSE_BUTTONS : return "GLFW_STICKY_MOUSE_BUTTONS";
case GLFW_SYSTEM_KEYS : return "GLFW_SYSTEM_KEYS";
case GLFW_KEY_REPEAT : return "GLFW_KEY_REPEAT";
case GLFW_AUTO_POLL_EVENTS : return "GLFW_AUTO_POLL_EVENTS";
case GLFW_WAIT : return "GLFW_WAIT";
case GLFW_NOWAIT : return "GLFW_NOWAIT";
case GLFW_BUTTONS : return "GLFW_BUTTONS";
case GLFW_NO_RESCALE_BIT : return "GLFW_NO_RESCALE_BIT";
case GLFW_ORIGIN_UL_BIT : return "GLFW_ORIGIN_UL_BIT";
case GLFW_BUILD_MIPMAPS_BIT : return "GLFW_BUILD_MIPMAPS_BIT";
case GLFW_ALPHA_MAP_BIT : return "GLFW_ALPHA_MAP_BIT";
default : return "Invalid param";
}
}
void OnKeyPressed( int key, int action ){
const char* key_name = GetKeyName(key);
if(key_name == 0)
return;
if(action == GLFW_PRESS)
printf("'%s' (%i) key is pressed\n", key_name, key);
if(action == GLFW_RELEASE)
printf("'%s' (%i) key is released\n", key_name, key);
if(action == GLFW_RELEASE && key == GLFW_KEY_ENTER)
PullInfo();
}
int OnClose(){
printf("Closed\n");
return 0;
}
void OnRefresh(){
printf("Refresh\n");
}
void OnResize( int width, int height ){
on_resize_called = 1;
printf("Resizing to %i %i\n", width, height);
}
void OnMouseClick( int button, int action ){
if(action == GLFW_PRESS)
printf("Mouse button %i has been pressed\n", button);
if(action == GLFW_RELEASE)
printf("Mouse button %i has been released\n", button);
}
void OnMouseMove( int x, int y ){
int lState = glfwGetMouseButton(GLFW_MOUSE_BUTTON_LEFT);
if (lState == GLFW_PRESS)
printf("Dragged %i to %i %i\n", GLFW_MOUSE_BUTTON_LEFT, x, y);
if(lState == GLFW_RELEASE)
printf("Moved %i to %i %i\n", GLFW_MOUSE_BUTTON_LEFT, x, y);
}
void OnMouseWheel( int pos ){
printf("Mouse wheel has been moved to %i\n", pos);
}
void PullInfo(){
printf("================================================================================\n");
int major, minor, rev;
glfwGetVersion(&major, &minor, &rev);
printf("GLFW version is %i.%i.%i\n", major, minor, rev);
int width, height;
glfwGetWindowSize(&width, &height);
printf("Window size is %i %i\n", width, height);
int status = glfwGetKey(GLFW_KEY_LCTRL);
if(status == GLFW_PRESS)
printf("Left control is pressed\n");
else
printf("Left control is released\n");
status = glfwGetMouseButton(GLFW_MOUSE_BUTTON_1);
if(status == GLFW_PRESS)
printf("Mouse button 1 is pressed\n");
else
printf("Mouse button 1 is released\n");
int x, y;
glfwGetMousePos(&x, &y);
printf("Mouse position is %i %i\n", x, y);
int wheel = glfwGetMouseWheel();
printf("Mouse wheel pos is %i\n", wheel);
double time = glfwGetTime();
printf("Time is %f\n", time);
glfwGetGLVersion(&major, &minor, &rev);
printf("GL version is %i.%i.%i\n", major, minor, rev);
int proc = glfwGetNumberOfProcessors();
printf("%i processors are available\n", proc);
unsigned int i;
for(i = 0; i<nb_params; i++)
printf(" - %-27s : %i\n", GetParamName(params[i]), glfwGetWindowParam(params[i]));
const char* extension = "WEBGL_compressed_texture_s3tc";
printf("'%s' extension is %s.\n", extension, glfwExtensionSupported(extension) ? "supported" : "not supported");
extension = "GL_EXT_framebuffer_object";
printf("'%s' extension is %s.\n", extension, glfwExtensionSupported(extension) ? "supported" : "not supported");
extension = "glBindBuffer";
void* proc_addr = glfwGetProcAddress(extension);
printf("'%s' extension proc address is %p.\n", extension, proc_addr);
printf("Sleeping 1 sec...\n");
glfwSleep(1);
printf("...Done.\n");
printf("================================================================================\n");
#ifdef REPORT_RESULT
REPORT_RESULT(1);
#endif
}
Ссылка в новой задаче Показать git blame Копировать постоянную ссылку