| //======================================================================== |
| // GLFW 3.3 OSMesa - www.glfw.org |
| //------------------------------------------------------------------------ |
| // Copyright (c) 2016 Google Inc. |
| // Copyright (c) 2006-2016 Camilla Löwy <elmindreda@glfw.org> |
| // |
| // This software is provided 'as-is', without any express or implied |
| // warranty. In no event will the authors be held liable for any damages |
| // arising from the use of this software. |
| // |
| // Permission is granted to anyone to use this software for any purpose, |
| // including commercial applications, and to alter it and redistribute it |
| // freely, subject to the following restrictions: |
| // |
| // 1. The origin of this software must not be misrepresented; you must not |
| // claim that you wrote the original software. If you use this software |
| // in a product, an acknowledgment in the product documentation would |
| // be appreciated but is not required. |
| // |
| // 2. Altered source versions must be plainly marked as such, and must not |
| // be misrepresented as being the original software. |
| // |
| // 3. This notice may not be removed or altered from any source |
| // distribution. |
| // |
| //======================================================================== |
| |
| #include <stdlib.h> |
| #include <string.h> |
| #include <assert.h> |
| |
| #include "internal.h" |
| |
| |
| static void makeContextCurrentOSMesa(_GLFWwindow* window) |
| { |
| if (window) |
| { |
| int width, height; |
| _glfwPlatformGetFramebufferSize(window, &width, &height); |
| |
| // Check to see if we need to allocate a new buffer |
| if ((window->context.osmesa.buffer == NULL) || |
| (width != window->context.osmesa.width) || |
| (height != window->context.osmesa.height)) |
| { |
| free(window->context.osmesa.buffer); |
| |
| // Allocate the new buffer (width * height * 8-bit RGBA) |
| window->context.osmesa.buffer = calloc(4, width * height); |
| window->context.osmesa.width = width; |
| window->context.osmesa.height = height; |
| } |
| |
| if (!OSMesaMakeCurrent(window->context.osmesa.handle, |
| window->context.osmesa.buffer, |
| GL_UNSIGNED_BYTE, |
| width, height)) |
| { |
| _glfwInputError(GLFW_PLATFORM_ERROR, |
| "OSMesa: Failed to make context current"); |
| return; |
| } |
| } |
| |
| _glfwPlatformSetTls(&_glfw.contextSlot, window); |
| } |
| |
| static GLFWglproc getProcAddressOSMesa(const char* procname) |
| { |
| return (GLFWglproc) OSMesaGetProcAddress(procname); |
| } |
| |
| static void destroyContextOSMesa(_GLFWwindow* window) |
| { |
| if (window->context.osmesa.handle) |
| { |
| OSMesaDestroyContext(window->context.osmesa.handle); |
| window->context.osmesa.handle = NULL; |
| } |
| |
| if (window->context.osmesa.buffer) |
| { |
| free(window->context.osmesa.buffer); |
| window->context.osmesa.width = 0; |
| window->context.osmesa.height = 0; |
| } |
| } |
| |
| static void swapBuffersOSMesa(_GLFWwindow* window) |
| { |
| // No double buffering on OSMesa |
| } |
| |
| static void swapIntervalOSMesa(int interval) |
| { |
| // No swap interval on OSMesa |
| } |
| |
| static int extensionSupportedOSMesa(const char* extension) |
| { |
| // OSMesa does not have extensions |
| return GLFW_FALSE; |
| } |
| |
| |
| ////////////////////////////////////////////////////////////////////////// |
| ////// GLFW internal API ////// |
| ////////////////////////////////////////////////////////////////////////// |
| |
| GLFWbool _glfwInitOSMesa(void) |
| { |
| int i; |
| const char* sonames[] = |
| { |
| #if defined(_GLFW_OSMESA_LIBRARY) |
| _GLFW_OSMESA_LIBRARY, |
| #elif defined(_WIN32) |
| "libOSMesa.dll", |
| "OSMesa.dll", |
| #elif defined(__APPLE__) |
| "libOSMesa.8.dylib", |
| #elif defined(__CYGWIN__) |
| "libOSMesa-8.so", |
| #else |
| "libOSMesa.so.8", |
| "libOSMesa.so.6", |
| #endif |
| NULL |
| }; |
| |
| if (_glfw.osmesa.handle) |
| return GLFW_TRUE; |
| |
| for (i = 0; sonames[i]; i++) |
| { |
| _glfw.osmesa.handle = _glfw_dlopen(sonames[i]); |
| if (_glfw.osmesa.handle) |
| break; |
| } |
| |
| if (!_glfw.osmesa.handle) |
| { |
| _glfwInputError(GLFW_API_UNAVAILABLE, "OSMesa: Library not found"); |
| return GLFW_FALSE; |
| } |
| |
| _glfw.osmesa.CreateContextExt = (PFN_OSMesaCreateContextExt) |
| _glfw_dlsym(_glfw.osmesa.handle, "OSMesaCreateContextExt"); |
| _glfw.osmesa.CreateContextAttribs = (PFN_OSMesaCreateContextAttribs) |
| _glfw_dlsym(_glfw.osmesa.handle, "OSMesaCreateContextAttribs"); |
| _glfw.osmesa.DestroyContext = (PFN_OSMesaDestroyContext) |
| _glfw_dlsym(_glfw.osmesa.handle, "OSMesaDestroyContext"); |
| _glfw.osmesa.MakeCurrent = (PFN_OSMesaMakeCurrent) |
| _glfw_dlsym(_glfw.osmesa.handle, "OSMesaMakeCurrent"); |
| _glfw.osmesa.GetColorBuffer = (PFN_OSMesaGetColorBuffer) |
| _glfw_dlsym(_glfw.osmesa.handle, "OSMesaGetColorBuffer"); |
| _glfw.osmesa.GetDepthBuffer = (PFN_OSMesaGetDepthBuffer) |
| _glfw_dlsym(_glfw.osmesa.handle, "OSMesaGetDepthBuffer"); |
| _glfw.osmesa.GetProcAddress = (PFN_OSMesaGetProcAddress) |
| _glfw_dlsym(_glfw.osmesa.handle, "OSMesaGetProcAddress"); |
| |
| if (!_glfw.osmesa.CreateContextExt || |
| !_glfw.osmesa.DestroyContext || |
| !_glfw.osmesa.MakeCurrent || |
| !_glfw.osmesa.GetColorBuffer || |
| !_glfw.osmesa.GetDepthBuffer || |
| !_glfw.osmesa.GetProcAddress) |
| { |
| _glfwInputError(GLFW_PLATFORM_ERROR, |
| "OSMesa: Failed to load required entry points"); |
| |
| _glfwTerminateOSMesa(); |
| return GLFW_FALSE; |
| } |
| |
| return GLFW_TRUE; |
| } |
| |
| void _glfwTerminateOSMesa(void) |
| { |
| if (_glfw.osmesa.handle) |
| { |
| _glfw_dlclose(_glfw.osmesa.handle); |
| _glfw.osmesa.handle = NULL; |
| } |
| } |
| |
| #define setAttrib(a, v) \ |
| { \ |
| assert((size_t) (index + 1) < sizeof(attribs) / sizeof(attribs[0])); \ |
| attribs[index++] = a; \ |
| attribs[index++] = v; \ |
| } |
| |
| GLFWbool _glfwCreateContextOSMesa(_GLFWwindow* window, |
| const _GLFWctxconfig* ctxconfig, |
| const _GLFWfbconfig* fbconfig) |
| { |
| OSMesaContext share = NULL; |
| const int accumBits = fbconfig->accumRedBits + |
| fbconfig->accumGreenBits + |
| fbconfig->accumBlueBits + |
| fbconfig->accumAlphaBits; |
| |
| if (ctxconfig->client == GLFW_OPENGL_ES_API) |
| { |
| _glfwInputError(GLFW_API_UNAVAILABLE, |
| "OSMesa: OpenGL ES is not available on OSMesa"); |
| return GLFW_FALSE; |
| } |
| |
| if (ctxconfig->share) |
| share = ctxconfig->share->context.osmesa.handle; |
| |
| if (OSMesaCreateContextAttribs) |
| { |
| int index = 0, attribs[40]; |
| |
| setAttrib(OSMESA_FORMAT, OSMESA_RGBA); |
| setAttrib(OSMESA_DEPTH_BITS, fbconfig->depthBits); |
| setAttrib(OSMESA_STENCIL_BITS, fbconfig->stencilBits); |
| setAttrib(OSMESA_ACCUM_BITS, accumBits); |
| |
| if (ctxconfig->profile == GLFW_OPENGL_CORE_PROFILE) |
| { |
| setAttrib(OSMESA_PROFILE, OSMESA_CORE_PROFILE); |
| } |
| else if (ctxconfig->profile == GLFW_OPENGL_COMPAT_PROFILE) |
| { |
| setAttrib(OSMESA_PROFILE, OSMESA_COMPAT_PROFILE); |
| } |
| |
| if (ctxconfig->major != 1 || ctxconfig->minor != 0) |
| { |
| setAttrib(OSMESA_CONTEXT_MAJOR_VERSION, ctxconfig->major); |
| setAttrib(OSMESA_CONTEXT_MINOR_VERSION, ctxconfig->minor); |
| } |
| |
| if (ctxconfig->forward) |
| { |
| _glfwInputError(GLFW_VERSION_UNAVAILABLE, |
| "OSMesa: Forward-compatible contexts not supported"); |
| return GLFW_FALSE; |
| } |
| |
| setAttrib(0, 0); |
| |
| window->context.osmesa.handle = |
| OSMesaCreateContextAttribs(attribs, share); |
| } |
| else |
| { |
| if (ctxconfig->profile) |
| { |
| _glfwInputError(GLFW_VERSION_UNAVAILABLE, |
| "OSMesa: OpenGL profiles unavailable"); |
| return GLFW_FALSE; |
| } |
| |
| window->context.osmesa.handle = |
| OSMesaCreateContextExt(OSMESA_RGBA, |
| fbconfig->depthBits, |
| fbconfig->stencilBits, |
| accumBits, |
| share); |
| } |
| |
| if (window->context.osmesa.handle == NULL) |
| { |
| _glfwInputError(GLFW_VERSION_UNAVAILABLE, |
| "OSMesa: Failed to create context"); |
| return GLFW_FALSE; |
| } |
| |
| window->context.makeCurrent = makeContextCurrentOSMesa; |
| window->context.swapBuffers = swapBuffersOSMesa; |
| window->context.swapInterval = swapIntervalOSMesa; |
| window->context.extensionSupported = extensionSupportedOSMesa; |
| window->context.getProcAddress = getProcAddressOSMesa; |
| window->context.destroy = destroyContextOSMesa; |
| |
| return GLFW_TRUE; |
| } |
| |
| #undef setAttrib |
| |
| |
| ////////////////////////////////////////////////////////////////////////// |
| ////// GLFW native API ////// |
| ////////////////////////////////////////////////////////////////////////// |
| |
| GLFWAPI int glfwGetOSMesaColorBuffer(GLFWwindow* handle, int* width, |
| int* height, int* format, void** buffer) |
| { |
| void* mesaBuffer; |
| GLint mesaWidth, mesaHeight, mesaFormat; |
| _GLFWwindow* window = (_GLFWwindow*) handle; |
| assert(window != NULL); |
| |
| _GLFW_REQUIRE_INIT_OR_RETURN(GLFW_FALSE); |
| |
| if (!OSMesaGetColorBuffer(window->context.osmesa.handle, |
| &mesaWidth, &mesaHeight, |
| &mesaFormat, &mesaBuffer)) |
| { |
| _glfwInputError(GLFW_PLATFORM_ERROR, |
| "OSMesa: Failed to retrieve color buffer"); |
| return GLFW_FALSE; |
| } |
| |
| if (width) |
| *width = mesaWidth; |
| if (height) |
| *height = mesaHeight; |
| if (format) |
| *format = mesaFormat; |
| if (buffer) |
| *buffer = mesaBuffer; |
| |
| return GLFW_TRUE; |
| } |
| |
| GLFWAPI int glfwGetOSMesaDepthBuffer(GLFWwindow* handle, |
| int* width, int* height, |
| int* bytesPerValue, |
| void** buffer) |
| { |
| void* mesaBuffer; |
| GLint mesaWidth, mesaHeight, mesaBytes; |
| _GLFWwindow* window = (_GLFWwindow*) handle; |
| assert(window != NULL); |
| |
| _GLFW_REQUIRE_INIT_OR_RETURN(GLFW_FALSE); |
| |
| if (!OSMesaGetDepthBuffer(window->context.osmesa.handle, |
| &mesaWidth, &mesaHeight, |
| &mesaBytes, &mesaBuffer)) |
| { |
| _glfwInputError(GLFW_PLATFORM_ERROR, |
| "OSMesa: Failed to retrieve depth buffer"); |
| return GLFW_FALSE; |
| } |
| |
| if (width) |
| *width = mesaWidth; |
| if (height) |
| *height = mesaHeight; |
| if (bytesPerValue) |
| *bytesPerValue = mesaBytes; |
| if (buffer) |
| *buffer = mesaBuffer; |
| |
| return GLFW_TRUE; |
| } |
| |
| GLFWAPI OSMesaContext glfwGetOSMesaContext(GLFWwindow* handle) |
| { |
| _GLFWwindow* window = (_GLFWwindow*) handle; |
| _GLFW_REQUIRE_INIT_OR_RETURN(NULL); |
| |
| if (window->context.client == GLFW_NO_API) |
| { |
| _glfwInputError(GLFW_NO_WINDOW_CONTEXT, NULL); |
| return NULL; |
| } |
| |
| return window->context.osmesa.handle; |
| } |
| |