static EM_BOOL _fullscreen_change_callback(int event_type, const EmscriptenFullscreenChangeEvent *event, void *user_data) { ERR_FAIL_COND_V(event_type!=EMSCRIPTEN_EVENT_FULLSCREENCHANGE, false); OS_JavaScript* os = static_cast<OS_JavaScript*>(user_data); String id = String::utf8(event->id); // empty id is canvas if (id.empty() || id=="canvas") { OS::VideoMode vm = os->get_video_mode(); // this event property is the only reliable information on // browser fullscreen state vm.fullscreen = event->isFullscreen; if (event->isFullscreen) { vm.width = event->screenWidth; vm.height = event->screenHeight; os->set_video_mode(vm); emscripten_set_canvas_size(vm.width, vm.height); } else { os->set_video_mode(vm); if (!os->is_window_maximized()) { os->set_window_size(_windowed_size); } } } return false; }
int main(int argc, char *argv[]) { SDL_Surface *screen; // Slightly different SDL initialization if ( SDL_Init(SDL_INIT_VIDEO) != 0 ) { printf("Unable to initialize SDL: %s\n", SDL_GetError()); return 1; } // Test 1: Check that initializing video mode with size (0,0) will use the size from the <canvas> element. screen = SDL_SetVideoMode( 0, 0, 16, SDL_OPENGL ); // *changed* // Test 2: Check that getting current canvas size works. int w, h, fs; emscripten_get_canvas_size(&w, &h, &fs); printf("w:%d,h:%d\n", w,h); assert(w == 700); assert(h == 200); // Test 3: Check that resizing the canvas works as well. emscripten_set_canvas_size(640, 480); emscripten_get_canvas_size(&w, &h, &fs); printf("w:%d,h:%d\n", w,h); assert(w == 640); assert(h == 480); SDL_Quit(); REPORT_RESULT(1); return 0; }
void GlContext::resize(uint32_t _width, uint32_t _height, uint32_t _flags) { # if BX_PLATFORM_ANDROID if (NULL != m_display) { EGLNativeWindowType nwh = (EGLNativeWindowType )g_platformData.nwh; eglMakeCurrent(m_display, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT); eglDestroySurface(m_display, m_surface); m_surface = eglCreateWindowSurface(m_display, m_config, nwh, NULL); BGFX_FATAL(m_surface != EGL_NO_SURFACE, Fatal::UnableToInitialize, "Failed to create surface."); EGLBoolean success = eglMakeCurrent(m_display, m_surface, m_surface, m_context); BGFX_FATAL(success, Fatal::UnableToInitialize, "Failed to set context."); EGLint format; eglGetConfigAttrib(m_display, m_config, EGL_NATIVE_VISUAL_ID, &format); ANativeWindow_setBuffersGeometry( (ANativeWindow*)g_platformData.nwh, _width, _height, format); } # elif BX_PLATFORM_EMSCRIPTEN emscripten_set_canvas_size(_width, _height); # else BX_UNUSED(_width, _height); # endif // BX_PLATFORM_* if (NULL != m_display) { bool vsync = !!(_flags&BGFX_RESET_VSYNC); eglSwapInterval(m_display, vsync ? 1 : 0); } }
void EmRenderWindow::initContext() { printf("Setting Emscripten Canvas size\n"); emscripten_set_canvas_size(m_width, m_height); EmscriptenWebGLContextAttributes attrs; emscripten_webgl_init_context_attributes(&attrs); attrs.depth = 1; attrs.stencil = 1; attrs.antialias = 1; attrs.majorVersion = 2; attrs.minorVersion = 0; assert(emscripten_webgl_get_current_context() == 0); printf("Creating Emscripten WebGL context\n"); m_window = emscripten_webgl_create_context("canvas", &attrs); printf("Created Emscripten WebGL context %i\n", m_window); emscripten_webgl_make_context_current(m_window); #if defined TOY_PLATFORM_LINUX || defined TOY_PLATFORM_BSD m_nativeHandle = (void*)(uintptr_t)glfwGetX11Window(_window); #elif defined TOY_PLATFORM_OSX m_nativeHandle = glfwGetCocoaWindow(_window); #elif defined TOY_PLATFORM_WINDOWS m_nativeHandle = glfwGetWin32Window(m_glWindow); #endif }
void Application::run() { #ifndef EMSCRIPTEN while (!glfwWindowShouldClose(m_window)) { #else int w = 0, h = 0; glfwGetFramebufferSize(m_window, &w, &h); if (w == 0 || h == 0) { printf("setting canvas size"); emscripten_set_canvas_size(640, 480); } audioUpdate(); #endif if (m_on) { glClearColor(1, 0, 0, 1); } else { glClearColor(0, 0, 0, 1); } m_on = !m_on; glClear(GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT); glfwSwapBuffers(m_window);// Swap front and back buffers glfwPollEvents(); // Poll for and process events #ifndef EMSCRIPTEN } #endif }
int main(int argc, char *argv[]) { emscripten_set_canvas_size(800, 600); rarch_main(argc, argv); emscripten_set_main_loop(emscripten_mainloop, g_settings.video.vsync ? 0 : INT_MAX, 1); return 0; }
int main(int argc, char *argv[]) { settings_t *settings = config_get_ptr(); emscripten_set_canvas_size(800, 600); rarch_main(argc, argv, NULL); emscripten_set_main_loop(emscripten_mainloop, settings->video.vsync ? 0 : INT_MAX, 1); return 0; }
int EMSCRIPTEN_KEEPALIVE setscreensize(int yes) { int w, h, f; emscripten_get_canvas_size(&w, &h, &f); if (1 || f == 0) { w = emscripten_run_script_int("window.innerWidth"); h = emscripten_run_script_int("window.innerHeight"); emscripten_set_canvas_size(w, h); } expose(); return yes; }
void PlatformResizeGLContext( FPlatformOpenGLDevice* Device, FPlatformOpenGLContext* Context, uint32 SizeX, uint32 SizeY, bool bFullscreen, bool bWasFullscreen, GLenum BackBufferTarget, GLuint BackBufferResource) { check(Context); VERIFY_GL_SCOPE(); // we can't resize with the win32 emu right now -- we have no way of resizing the window. #if !PLATFORM_HTML5_WIN32 emscripten_set_canvas_size(SizeX, SizeY); #endif glViewport(0, 0, SizeX, SizeY); //@todo-mobile Do we need to clear here? glClearColor(0, 0, 0, 0); glClear(GL_COLOR_BUFFER_BIT); }
static EM_BOOL _browser_resize_callback(int event_type, const EmscriptenUiEvent *ui_event, void *user_data) { ERR_FAIL_COND_V(event_type!=EMSCRIPTEN_EVENT_RESIZE, false); OS_JavaScript* os = static_cast<OS_JavaScript*>(user_data); // the order in which _browser_resize_callback and // _fullscreen_change_callback are called is browser-dependent, // so try adjusting for fullscreen in both if (os->is_window_fullscreen() || os->is_window_maximized()) { OS::VideoMode vm = os->get_video_mode(); vm.width = ui_event->windowInnerWidth; vm.height = ui_event->windowInnerHeight; os->set_video_mode(vm); emscripten_set_canvas_size(ui_event->windowInnerWidth, ui_event->windowInnerHeight); } return false; }
void GlContext::resize(uint32_t _width, uint32_t _height, uint32_t _flags) { # if BX_PLATFORM_ANDROID if (NULL != m_display) { EGLint format; eglGetConfigAttrib(m_display, m_config, EGL_NATIVE_VISUAL_ID, &format); ANativeWindow_setBuffersGeometry( (ANativeWindow*)g_platformData.nwh, _width, _height, format); } # elif BX_PLATFORM_EMSCRIPTEN emscripten_set_canvas_size(_width, _height); # else BX_UNUSED(_width, _height); # endif // BX_PLATFORM_* if (NULL != m_display) { bool vsync = !!(_flags&BGFX_RESET_VSYNC); eglSwapInterval(m_display, vsync ? 1 : 0); } }
void onWindowResize(int newWidth, int newHeight, void * /*userData*/) { emscripten_set_canvas_size(newWidth, newHeight); // This probably needs that any extra elements are removed from the default shell.html. nglscene->resize(newWidth,newHeight); }
int main() { emscripten_set_canvas_size( 100, 100 ); EmscriptenWebGLContextAttributes attrs; emscripten_webgl_init_context_attributes(&attrs); attrs.enableExtensionsByDefault = 1; attrs.majorVersion = 2; attrs.minorVersion = 0; EMSCRIPTEN_WEBGL_CONTEXT_HANDLE context = emscripten_webgl_create_context( 0, &attrs ); if (!context) { attrs.majorVersion = 1; context = emscripten_webgl_create_context( 0, &attrs ); if (context) printf("Skipping test: WebGL 2.0 is not available.\n"); else printf("Test failed: WebGL is not available!\n"); #ifdef REPORT_RESULT // We did not have WebGL 2, but were able to init WebGL 1? In that case, gracefully skip this test with the current browser not supporting this one. int result = context ? 0 : 12365; REPORT_RESULT(); #endif return 0; } emscripten_webgl_make_context_current(context); // Textures // int mips = 10; int sizeO = 512; unsigned short* data = new unsigned short[ 512 * 512 * 4 ]; //memset( data, 0, 512 * 512 * 4 ); // Create texture 1 GLuint tex1; GL_CALL( glGenTextures( 1, &tex1 ) ); GL_CALL( glBindTexture( GL_TEXTURE_CUBE_MAP, tex1 ) ); for( int i=0; i<6; ++i ) { GL_CALL( glTexImage2D( GL_TEXTURE_CUBE_MAP_POSITIVE_X+i, 0, GL_RGBA16F, sizeO, sizeO, 0, GL_RGBA, GL_HALF_FLOAT, NULL ) ); } GL_CALL( glGenerateMipmap( GL_TEXTURE_CUBE_MAP ) ); for( int i=0; i<6; ++i ) GL_CALL( glTexSubImage2D( GL_TEXTURE_CUBE_MAP_POSITIVE_X+i, 0, 0, 0, sizeO, sizeO, GL_RGBA, GL_HALF_FLOAT, data ) ); delete [] data; // Create texture 2 GLuint tex2; GL_CALL( glGenTextures( 1, &tex2 ) ); GL_CALL( glBindTexture( GL_TEXTURE_CUBE_MAP, tex2 ) ); for( int i=0; i<6; ++i ) { GL_CALL( glTexImage2D( GL_TEXTURE_CUBE_MAP_POSITIVE_X+i, 0, GL_RGBA16F, sizeO, sizeO, 0, GL_RGBA, GL_HALF_FLOAT, NULL ) ); } GL_CALL( glGenerateMipmap( GL_TEXTURE_CUBE_MAP ) ); // FBOs // // Create FBO 1 GLuint fbo1; GL_CALL( glGenFramebuffers( 1, &fbo1 ) ); GL_CALL( glBindFramebuffer( GL_FRAMEBUFFER, fbo1 ) ); for( int level=0; level<mips; ++level ) { for( int i=0; i<6; ++i ) { GL_CALL( glFramebufferTexture2D( GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_CUBE_MAP_POSITIVE_X+i, tex1, level ) ); } } IsFramebufferValid( GL_FRAMEBUFFER ); // Create FBO 2 GLuint fbo2; GL_CALL( glGenFramebuffers( 1, &fbo2 ) ); GL_CALL( glBindFramebuffer( GL_FRAMEBUFFER, fbo2 ) ); for( int level=0; level<mips; ++level ) { for( int i=0; i<6; ++i ) { GL_CALL( glFramebufferTexture2D( GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_CUBE_MAP_POSITIVE_X+i, tex2, level ) ); glViewport( 0, 0, sizeO, sizeO ); } } IsFramebufferValid( GL_FRAMEBUFFER ); // Copy FBO 1 to 2 int nw = sizeO; GL_CALL( glBindFramebuffer( GL_READ_FRAMEBUFFER, fbo1 ) ); GL_CALL( glBindFramebuffer( GL_DRAW_FRAMEBUFFER, fbo2 ) ); for( int level=0; level<mips; ++level ) { for( int i=0; i<6; ++i ) { GL_CALL( glFramebufferTexture2D( GL_READ_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_CUBE_MAP_POSITIVE_X+i, tex1, level ) ); GL_CALL( glFramebufferTexture2D( GL_DRAW_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_CUBE_MAP_POSITIVE_X+i, tex2, level ) ); glViewport( 0, 0, nw, nw ); GL_CALL( glBlitFramebuffer( 0, 0, nw, nw, 0, 0, nw, nw, GL_COLOR_BUFFER_BIT, GL_NEAREST ) ); } nw /= 2; } GL_CALL( glBindFramebuffer( GL_READ_FRAMEBUFFER, 0 ) ); GL_CALL( glBindFramebuffer( GL_DRAW_FRAMEBUFFER, 0 ) ); #ifdef REPORT_RESULT int result = 0; REPORT_RESULT(); #endif return 0; }
void GlContext::create(uint32_t _width, uint32_t _height) { m_eglLibrary = eglOpen(); BX_UNUSED(_width, _height); EGLNativeDisplayType ndt = EGL_DEFAULT_DISPLAY; EGLNativeWindowType nwt = (EGLNativeWindowType)NULL; # if BX_PLATFORM_WINDOWS ndt = GetDC(g_bgfxHwnd); nwt = g_bgfxHwnd; # endif // BX_PLATFORM_ m_display = eglGetDisplay(ndt); BGFX_FATAL(m_display != EGL_NO_DISPLAY, Fatal::UnableToInitialize, "Failed to create display %p", m_display); EGLint major = 0; EGLint minor = 0; EGLBoolean success = eglInitialize(m_display, &major, &minor); BGFX_FATAL(success && major >= 1 && minor >= 3, Fatal::UnableToInitialize, "Failed to initialize %d.%d", major, minor); EGLint attrs[] = { EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT, # if BX_PLATFORM_ANDROID EGL_DEPTH_SIZE, 16, # else EGL_DEPTH_SIZE, 24, # endif // BX_PLATFORM_ EGL_STENCIL_SIZE, 8, EGL_NONE }; EGLint numConfig = 0; EGLConfig config; success = eglChooseConfig(m_display, attrs, &config, 1, &numConfig); BGFX_FATAL(success, Fatal::UnableToInitialize, "eglChooseConfig"); # if BX_PLATFORM_ANDROID EGLint format; eglGetConfigAttrib(m_display, config, EGL_NATIVE_VISUAL_ID, &format); ANativeWindow_setBuffersGeometry(g_bgfxAndroidWindow, _width, _height, format); nwt = g_bgfxAndroidWindow; # endif // BX_PLATFORM_ANDROID m_surface = eglCreateWindowSurface(m_display, config, nwt, NULL); BGFX_FATAL(m_surface != EGL_NO_SURFACE, Fatal::UnableToInitialize, "Failed to create surface."); EGLint contextAttrs[] = { # if BGFX_CONFIG_RENDERER_OPENGLES >= 30 EGL_CONTEXT_CLIENT_VERSION, 3, # elif BGFX_CONFIG_RENDERER_OPENGLES EGL_CONTEXT_CLIENT_VERSION, 2, # endif // BGFX_CONFIG_RENDERER_ EGL_NONE }; m_context = eglCreateContext(m_display, config, EGL_NO_CONTEXT, contextAttrs); BGFX_FATAL(m_context != EGL_NO_CONTEXT, Fatal::UnableToInitialize, "Failed to create context."); success = eglMakeCurrent(m_display, m_surface, m_surface, m_context); BGFX_FATAL(success, Fatal::UnableToInitialize, "Failed to set context."); eglSwapInterval(m_display, 0); # if BX_PLATFORM_EMSCRIPTEN emscripten_set_canvas_size(_width, _height); # endif // BX_PLATFORM_EMSCRIPTEN import(); }
void GlContext::create(uint32_t _width, uint32_t _height) { # if BX_PLATFORM_RPI bcm_host_init(); # endif // BX_PLATFORM_RPI m_eglLibrary = eglOpen(); if (NULL == g_platformData.context) { BX_UNUSED(_width, _height); EGLNativeDisplayType ndt = (EGLNativeDisplayType)g_platformData.ndt; EGLNativeWindowType nwh = (EGLNativeWindowType )g_platformData.nwh; # if BX_PLATFORM_WINDOWS if (NULL == g_platformData.ndt) { ndt = GetDC( (HWND)g_platformData.nwh); } # endif // BX_PLATFORM_WINDOWS m_display = eglGetDisplay(ndt); BGFX_FATAL(m_display != EGL_NO_DISPLAY, Fatal::UnableToInitialize, "Failed to create display %p", m_display); EGLint major = 0; EGLint minor = 0; EGLBoolean success = eglInitialize(m_display, &major, &minor); BGFX_FATAL(success && major >= 1 && minor >= 3, Fatal::UnableToInitialize, "Failed to initialize %d.%d", major, minor); BX_TRACE("EGL info:"); const char* clientApis = eglQueryString(m_display, EGL_CLIENT_APIS); BX_TRACE(" APIs: %s", clientApis); BX_UNUSED(clientApis); const char* vendor = eglQueryString(m_display, EGL_VENDOR); BX_TRACE(" Vendor: %s", vendor); BX_UNUSED(vendor); const char* version = eglQueryString(m_display, EGL_VERSION); BX_TRACE("Version: %s", version); BX_UNUSED(version); const char* extensions = eglQueryString(m_display, EGL_EXTENSIONS); BX_TRACE("Supported EGL extensions:"); dumpExtensions(extensions); EGLint attrs[] = { EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT, # if BX_PLATFORM_ANDROID EGL_DEPTH_SIZE, 16, # else EGL_DEPTH_SIZE, 24, # endif // BX_PLATFORM_ EGL_STENCIL_SIZE, 8, EGL_NONE }; EGLint numConfig = 0; success = eglChooseConfig(m_display, attrs, &m_config, 1, &numConfig); BGFX_FATAL(success, Fatal::UnableToInitialize, "eglChooseConfig"); # if BX_PLATFORM_ANDROID EGLint format; eglGetConfigAttrib(m_display, m_config, EGL_NATIVE_VISUAL_ID, &format); ANativeWindow_setBuffersGeometry( (ANativeWindow*)g_platformData.nwh, _width, _height, format); # elif BX_PLATFORM_RPI DISPMANX_DISPLAY_HANDLE_T dispmanDisplay = vc_dispmanx_display_open(0); DISPMANX_UPDATE_HANDLE_T dispmanUpdate = vc_dispmanx_update_start(0); VC_RECT_T dstRect = { 0, 0, _width, _height }; VC_RECT_T srcRect = { 0, 0, _width << 16, _height << 16 }; DISPMANX_ELEMENT_HANDLE_T dispmanElement = vc_dispmanx_element_add(dispmanUpdate , dispmanDisplay , 0 , &dstRect , 0 , &srcRect , DISPMANX_PROTECTION_NONE , NULL , NULL , DISPMANX_NO_ROTATE ); s_dispmanWindow.element = dispmanElement; s_dispmanWindow.width = _width; s_dispmanWindow.height = _height; nwh = &s_dispmanWindow; vc_dispmanx_update_submit_sync(dispmanUpdate); # endif // BX_PLATFORM_ANDROID m_surface = eglCreateWindowSurface(m_display, m_config, nwh, NULL); BGFX_FATAL(m_surface != EGL_NO_SURFACE, Fatal::UnableToInitialize, "Failed to create surface."); const bool hasEglKhrCreateContext = !!bx::findIdentifierMatch(extensions, "EGL_KHR_create_context"); const bool hasEglKhrNoError = !!bx::findIdentifierMatch(extensions, "EGL_KHR_create_context_no_error"); for (uint32_t ii = 0; ii < 2; ++ii) { bx::StaticMemoryBlockWriter writer(s_contextAttrs, sizeof(s_contextAttrs) ); EGLint flags = 0; if (hasEglKhrCreateContext) { bx::write(&writer, EGLint(EGL_CONTEXT_MAJOR_VERSION_KHR) ); bx::write(&writer, EGLint(BGFX_CONFIG_RENDERER_OPENGLES / 10) ); bx::write(&writer, EGLint(EGL_CONTEXT_MINOR_VERSION_KHR) ); bx::write(&writer, EGLint(BGFX_CONFIG_RENDERER_OPENGLES % 10) ); flags |= BGFX_CONFIG_DEBUG && hasEglKhrNoError ? 0 | EGL_CONTEXT_FLAG_NO_ERROR_BIT_KHR : 0 ; if (0 == ii) { flags |= BGFX_CONFIG_DEBUG ? 0 | EGL_CONTEXT_OPENGL_DEBUG_BIT_KHR // | EGL_OPENGL_ES3_BIT_KHR : 0 ; bx::write(&writer, EGLint(EGL_CONTEXT_FLAGS_KHR) ); bx::write(&writer, flags); } } else { bx::write(&writer, EGLint(EGL_CONTEXT_CLIENT_VERSION) ); bx::write(&writer, 2); } bx::write(&writer, EGLint(EGL_NONE) ); m_context = eglCreateContext(m_display, m_config, EGL_NO_CONTEXT, s_contextAttrs); if (NULL != m_context) { break; } BX_TRACE("Failed to create EGL context with EGL_CONTEXT_FLAGS_KHR (%08x).", flags); } BGFX_FATAL(m_context != EGL_NO_CONTEXT, Fatal::UnableToInitialize, "Failed to create context."); success = eglMakeCurrent(m_display, m_surface, m_surface, m_context); BGFX_FATAL(success, Fatal::UnableToInitialize, "Failed to set context."); m_current = NULL; eglSwapInterval(m_display, 0); } # if BX_PLATFORM_EMSCRIPTEN emscripten_set_canvas_size(_width, _height); # endif // BX_PLATFORM_EMSCRIPTEN import(); }
void ofxAppEmscriptenWindow::setWindowShape(int w, int h){ emscripten_set_canvas_size(w,h); }
int main() { setupKeys();// setup the HTML key mappings emscripten_set_canvas_size(800, 600); printf("hello world!\n"); std::ifstream f; f.open( "./data/pyramid.PropellerModel", std::ifstream::binary ); if(f.is_open()) printf("file open ok!\n"); else printf("file open not ok :< \n"); engine::sys::addLogger(new game::sys::ConsoleLogger()); printf("initting rendering\n"); gameInstance.initializeRenderer(NULL); printf("starting init()\n"); { engine::file::FileList files; gameInstance.getFileManager()->listFiles(files); engine::file::FileList::FileArray arr = files.getFiles(); LOG_INFO("listing files, count: " << arr.size()); for (unsigned i = 0; i < arr.size(); ++i) LOG_INFO(" * " << arr[i]); } gameInstance.getConsole()->execute("set defaultScene phys"); gameInstance.init(); { engine::file::FileList files; gameInstance.getFileManager()->listFiles(files); engine::file::FileList::FileArray arr = files.getFiles(); LOG_INFO("listing files, count: " << arr.size()); for (unsigned i = 0; i < arr.size(); ++i) LOG_INFO(" * " << arr[i]); } gameInstance.getConsole()->execute("echo OOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOO"); gameInstance.getConsole()->execute("ls"); gameInstance.getConsole()->execute("filemanagerlist"); gameInstance.getConsole()->execute("listcommands"); gameInstance.getConsole()->execute("listcvars"); gameInstance.getConsole()->execute("systemlist"); gameInstance.getConsole()->execute("ls"); gameInstance.getConsole()->execute("setpos -2.8281 -1.2858 1.918"); gameInstance.getConsole()->execute("bind KEY_W playerup"); gameInstance.getConsole()->execute("bind KEY_S playerdown"); gameInstance.getConsole()->execute("bind KEY_A playerleft"); gameInstance.getConsole()->execute("bind KEY_D playerright"); printf("init done\n"); printf("total of %i systems registered.\n", gameInstance.getSystemManager()->getSystemList().size()); gameInstance.update(); emscripten_set_keydown_callback(NULL, NULL, true, &keyDown); emscripten_set_keyup_callback(NULL, NULL, true, &keyUp); emscripten_set_main_loop(loop, 60, 1); return 0; }
int main(int argc, char *argv[]) { SDL_Surface *screen; // Slightly different SDL initialization if ( SDL_Init(SDL_INIT_VIDEO) != 0 ) { printf("Unable to initialize SDL: %s\n", SDL_GetError()); return 1; } SDL_GL_SetAttribute( SDL_GL_DOUBLEBUFFER, 1 ); // *new* #ifdef __EMSCRIPTEN__ // Test 1: Check that initializing video mode with size (0,0) will use the size from the <canvas> element. screen = SDL_SetVideoMode( 0, 0, 16, SDL_OPENGL ); // *changed* // Test 2: Check that getting current canvas size works. int w, h, fs; emscripten_get_canvas_size(&w, &h, &fs); printf("w:%d,h:%d\n", w,h); assert(w == 700); assert(h == 200); // Test 3: Check that resizing the canvas works as well. emscripten_set_canvas_size(640, 480); // Set the OpenGL state after creating the context with SDL_SetVideoMode #else screen = SDL_SetVideoMode( 640, 480, 16, SDL_OPENGL ); // *changed* #endif if ( !screen ) { printf("Unable to set video mode: %s\n", SDL_GetError()); return 1; } glClearColor( 0, 0, 0, 0 ); glEnable( GL_TEXTURE_2D ); // Needed when we're using the fixed-function pipeline. glViewport( 0, 0, 640, 480 ); glMatrixMode( GL_PROJECTION ); glPushMatrix(); // just for testing glLoadIdentity(); glOrtho( 0, 640, 480, 0, -1, 1 ); glMatrixMode( GL_MODELVIEW ); glLoadIdentity(); // Load the OpenGL texture GLuint texture; // Texture object handle SDL_Surface *surface; // Gives us the information to make the texture if ( (surface = IMG_Load("screenshot.png")) ) { // Check that the image's width is a power of 2 if ( (surface->w & (surface->w - 1)) != 0 ) { printf("warning: image.bmp's width is not a power of 2\n"); } // Also check if the height is a power of 2 if ( (surface->h & (surface->h - 1)) != 0 ) { printf("warning: image.bmp's height is not a power of 2\n"); } // Have OpenGL generate a texture object handle for us glGenTextures( 1, &texture ); // Bind the texture object glBindTexture( GL_TEXTURE_2D, texture ); // Set the texture's stretching properties glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR ); glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR ); //SDL_LockSurface(surface); // Add some greyness memset(surface->pixels, 0x66, surface->w*surface->h); // Edit the texture object's image data using the information SDL_Surface gives us glTexImage2D( GL_TEXTURE_2D, 0, GL_RGBA, surface->w, surface->h, 0, GL_RGBA, GL_UNSIGNED_BYTE, surface->pixels ); //SDL_UnlockSurface(surface); } else { printf("SDL could not load image.bmp: %s\n", SDL_GetError()); SDL_Quit(); return 1; } // Free the SDL_Surface only if it was successfully created if ( surface ) { SDL_FreeSurface( surface ); } // Clear the screen before drawing glClear( GL_COLOR_BUFFER_BIT ); // Bind the texture to which subsequent calls refer to glBindTexture( GL_TEXTURE_2D, texture ); glBegin( GL_QUADS ); glTexCoord2i( 0, 0 ); glVertex3f( 10, 10, 0 ); glTexCoord2i( 1, 0 ); glVertex3f( 300, 10, 0 ); glTexCoord2i( 1, 1 ); glVertex3f( 300, 128, 0 ); glTexCoord2i( 0, 1 ); glVertex3f( 10, 128, 0 ); glTexCoord2f( 0, 0.5 ); glVertex3f( 410, 10, 0 ); glTexCoord2f( 1, 0.5 ); glVertex3f( 600, 10, 0 ); glTexCoord2f( 1, 1 ); glVertex3f( 630, 200, 0 ); glTexCoord2f( 0.5, 1 ); glVertex3f( 310, 250, 0 ); glEnd(); glBegin( GL_TRIANGLE_STRIP ); glTexCoord2i( 0, 0 ); glVertex3f( 100, 300, 0 ); glTexCoord2i( 1, 0 ); glVertex3f( 300, 300, 0 ); glTexCoord2i( 1, 1 ); glVertex3f( 300, 400, 0 ); glTexCoord2i( 0, 1 ); glVertex3f( 500, 410, 0 ); glEnd(); glDisable(GL_TEXTURE_2D); glColor3ub(90, 255, 255); glBegin( GL_QUADS ); glVertex3f( 10, 410, 0 ); glVertex3f( 300, 410, 0 ); glVertex3f( 300, 480, 0 ); glVertex3f( 10, 470, 0 ); glEnd(); glBegin( GL_QUADS ); glColor3f(1.0, 0, 1.0); glVertex3f( 410, 410, 0 ); glColor3f(0, 1.0, 0); glVertex3f( 600, 410, 0 ); glColor3f(0, 0, 1.0); glVertex3f( 600, 480, 0 ); glColor3f(1.0, 1.0, 1.0); glVertex3f( 410, 470, 0 ); glEnd(); SDL_GL_SwapBuffers(); #ifndef __EMSCRIPTEN__ // Wait for 3 seconds to give us a chance to see the image SDL_Delay(3000); #endif // Now we can delete the OpenGL texture and close down SDL glDeleteTextures( 1, &texture ); SDL_Quit(); return 0; }