My first OpenGL tests under OSX 10.8
These last months I worked (and I still work) on my new 3d lib that will be used in all my new tools. This lib is cross-platform and supports Windows, Linux and now OS X.
Jul 26, 2010. Global Nav Open Menu Global Nav Close Menu; Apple; Shopping Bag +. Search Support. 9/10 (39 Stimmen) - Download OpenGL kostenlos. Optimieren Sie die Anzeige von 2D-/3D-Grafiken in Software und Videospielen, indem Sie OpenGL kostenlos herunterladen, die unverzichtbare Grafikbibliothek. OpenGL ist eine Reihe von 2D- und 3D-Grafikentwicklungssprachen, die in den. Opengl 4.1 free download - OpenGL, Descent OpenGL, OpenGL Extensions Viewer, and many more programs.
I could enter in Mac’s world thanks to a MacBook Pro (with a 15-inch Retina Rugrats munchin land download mac. display). I code with this laptop for some weeks now and I thought it was time to write a bit about the first contact with OpenGL under OSX from the point of view of a Windows developer…
One of the first things I do when I arrive on a new OS is to look at the OpenGL support and extensions. I did it for Linux (see Linux: Mesa, Gallium3D, Nouveau…) and now I do it for OSX.
The MacBook Pro Retina 15-inch offers three kinds of OpenGL renderers: two hardware renderers and one software renderer (first time I play with an OpenGL software renderer). The graphics hardware of the MacBook Pro Retina includes the integraded Intel Graphics HD 4000 GPU (part of the Ivy Bridge Core i7 processor) and a discrete NVIDIA GeForce GT 650M with 1GB of dedicated memory.
OSX 10.8 supports OpenGL 2.1 and OpenGL 3.2 core profile. The compatibility profile for OpenGL 3.2 is not available on OSX. Once my 3d lib started to run on OSX, I checked the OpenGL extensions available on my rMBP and they were exactly the same than those listed on Apple OpenGL capabilities tables for OSX 10.8, 10.7 and 10.6:
With an OpenGL 3.2 core context, 15 extensions are exposed for the software renderer (a highly optimized floating point CPU-based renderer), 16 extensions for the GT 650M and 13 for the HD 4000. It’s useless to list them here, just check the capabilities tables. So if you plan to add OpenGL 3.2 support for your software under OSX 10.6 (Snow Leopard), check the tables before: it’s not possible, OpenGL 3.2 being only available on OSX 10.7 (Lion) and OSX 10.8 (Mountain Lion). And how many extensions are exposed for the HD 4000 with an OpenGL 2.1 context under OSX 10.8? Check the table the right table and I bet you’ll find 123. This is one of the first surprises: OpenGL features are strictly defined on OSX while this is not the case in Windows or Linux worlds. This is nice because you can know in advance if your soft will work fine on a particular OSX version, but at the same time, latest features of the GPU can’t be exploited (OpenGL 4 for example). This under-control situation looks like D3D one, we lose the ability of OpenGL extensions to expose new features. NVIDIA has added a cool feature in GTX 600 called bindless textures. On Windows and Linux, bindless textures were quikly available thanks to OpenGL extensions while that was not the case for D3D. Actually I’m a bit too sever because some beyond GL3.2 extensions are exposed but you can count them with one hand ?
The first time I checked the extensions exposed for the GT 650M with the OpenGL 3.2 context, I saw only 16 extensions. I thought the GL 3.2 support was far from complete. I was wrong. On Windows, when you ask for a GL 3 core profile, you retrieve all OpenGL extensions because they are not part of the OpenGL core libraries (GL 1.1 is the core on Windows). With latest R310.33, no less than 311 OpenGL extensions (I don’t count the WGL ones) are exposed. On OSX, OpenGL is fully integrated in the system and is the foundation for hardware-accelerated graphics (Quartz Extreme, the GPU layer of Quartz). That explains why there are only 16 extensions on OSX compared to the hundred ones on Windows: all extensions of OpenGL 3.2 are part of the OpenGL core libraries on OSX. Then, once a GL 3.2 context is created and made current, you can directly call glCreateShader() for example. That was another surprise fro me. On Windows (and Linux), you have to fetch entry points (function pointers) before calling OpenGL functions. You can do this yourself or by using OpenGL extensions loaders such as GLEW. On OSX, extensions loaders are somewhat useless to load OpenGL 3.2 functions but you can still use them (the extensions loaders), they will give you all function pointers so you can use the same code to initialize OpenGL in your cross-platform app. And for an OpenGL 2.1 context, extensions loaders are useful to get an access to all non-GL2.1 features.
Now the question: what are those 16 extensions? They are related to functionalities that are not included in OpenGL 3.2 spec, like GL_APPLE_xxxx extensions or new GL_ARB_xxx. By the way, all GL_ARB_xxx extensions exposed (GL_ARB_instanced_arrays, GL_ARB_occlusion_query2, GL_ARB_shader_bit_encoding and GL_ARB_timer_query) are part of the OpenGL 3.3 specifications, that means that a subset of OpenGL 3.3 is supported on OSX.
Now let’s see what APIs are available to make the link between OpenGL and the windowing system, also called the render window. On Windows, there is only one API called WGL. WGL makes the connection between OpenGL and the Win32 API. On Linux, same thing, one API this time called GLX that links OpenGL to the X11 windowing system. On OSX there are… four APIs: CGL, AGL, NSOpenGL and GLX.
1 – CGL (Core OpenGL) is the lowest API available in the GL-windowing API stack. All other APIs rely on it. CGL is not related to a particular windowing interface and alone, CGL can be used only in fullscreen applications. Used alone is important, because and that’s the strength of CGL, you can use it with other interfaces like GLX or NSOpenGL.
2 – AGL is the Carbon interface related API. Carbon is a 32-bit only windowing system and is no longer supported by Apple. Of course a Carbon app can still run on OSX and you can still code an AGL-based demo, but this API is clearly deprecated.
3 – GLX… the Linux one? Yes, man! OSX is based on a Unix core (Mach + BSD) and supports X11 via the XQuartz project. XQuartz is a version of the X.Org X Window System that runs on OSX. On OSX 10.8, X11 is not available by default and you have to install XQuartz to compile and run X11-based applications. The nice news, is that the compilation of a Linux / X11 app under OSX is straightforward. I successfully compiled a the Linux version of the successor of GeeXLab under OSX without problem, nor headache! But it seems that GLX/X11 is limited to OpenGL 2.1 on OSX. I didn’t manage to create an OpenGL 3.2 core profile (if someone knows the tip…). The support of X11 / GLX is a nice thing for those who need to quickly port a Linux app on OSX.
The following screenshot shows the app I’m working on: GLSL Hacker, a cross-platform version of GeeXLab that runs on Windows, Linux and OSX. The screenshot shows the X11 version compiled under OSX (for the screenshot, I used a shader from GLSL Sandbox) :
The OSX/X11 version of GLSL Hacker running a GLSL Sandbox demo.
Thanks to the X11 support in OSX, I could quickly compile and test the Linux version under OSX. Great!
4 – NSOpenGL from the Cocoa framework. Cocoa is the API of choice for buidling modern OpenGL applications under OSX. Cocoa is the successor of Carbon and is a full 64-bit windowing system. Combined with CGL, you can create and customize your OpenGL contexts: vsync, gl 3.2 core, fullscreen software renderer, etc… More on Cocoa later ? Now I spend my time on updating my apps for Cocoa and here is the first application that will be released soon:
GpuTest: a Cocoa / OpenGL app
This screenshot shows GpuTest with a furry torus burning the GT 650M of the MacBook Pro (really noisy ? ). GPU Test is a small cross-platform OpenGL based benchmark tool that packs in the first version tests based on FurMark and TesssMark. There is also a geometry instancing test… The 3D engine used by GpuTest is the same than the one used by GLSL Hacker in the OSX/X11 test but this time in a Cocoa window. Next big job: a Cocoa version of GLSL Hacker!
I found the creation of OpenGL contexts easier than on Windows, especially when you need stuff like MSAA. And the fullscreen management… or transparent OpenGL windows (look at the first header image of this post)… so simple!
GpuTest – FurMark in fullscreen on the second monitor on OSX
Another thing I really appreciated is the window resizing. My GPU tools usually work with two threads: one main thread for the app GUI and one thread for the rendering. On Windows and Linux, I didn’t manage to get a proper resizing: when the window is resized, we see tearing, flashing and other undesirable effects (I did all possible tests on Windows, playing with window messages and notifications such as WM_PAINT, WM_ERASEBKGND (with and without Aero), but nothing to do. On OSX, the window resizing was perfect at the first time. No flashing nor tearing, only a smooth resizing. In conclusion, I would say that my first contact with OpenGL on OSX is rather positive. And once that Objective-C basics are assimilated it’s quite easy to start coding OpenGL in a Cocoa window. I tested my apps on several GPUs (Intel HD 4000, GeForce GT 650M, GeForce 320M, Radeon HD 4870, Radeon HD 6750M) under OSX 10.7 and OSX 10.8 and all my GLSL shaders have worked fine immediatly (on Windows and Linux, there are still surprises when you code a shader on GeForce and test it on Radeon). The thing I found not very handy was the glext.h file, part of the OpenGL framework. My code relies on the official glext.h you can download from OpenGL.org and I couldn’t compile my code with Apple’s glext.h because all function pointers defines are not present… Actually they are present but you have to uncomment the define GL_EXT_FUNCTION_POINTERS in glext.h (I must say I didnt see this define the first time). The last thing: I want to see my tessellation code running on OSX! I need OpenGL 4! Come on Apple, give us OpenGL 4 to justify all these GL4 GPUs on latest Mac systems! I hope I didn’t write too many mistaken things about OSX and OpenGL, so do not hesitate to point them out and fix them with a comment. Now it’s time to release the first version of GpuTest… |
Related posts:
Example
1. Install GLFW
Dino crisis free download. First step is to create an OpenGL window. GLFW is an Open Source, multi-platform library for creating windows with OpenGL, to install GLFW first download its files from www.glfw.org
Msm download tool for mac. Extract the GLFW folder and its contents will look like this
Download and install CMake to build GLFW. Goto www.cmake.org/download/, download CMake and install for MAC OS X
If Xcode is not installed. Download and install Xcode from Mac App Store.
Create a new folder Build inside the GLFW folder
Open CMake, click on Browse Source button to select the GLFW folder (make sure that CMakeLists.txt) is located inside that folder. After that, click on Browse Build button and select the newly created Build folder in previous step.
Now Click on Configure button and select Xcode as generator with Use default native compilers option, and click Done.
Tick on BUILD_SHARED_LIBS option and then click on Configure button again and finally click Generate button.
After generation CMake should look like this
Now Open Finder and goto /usr, create a folder name local if not already there. Open the local folder and create two folders include and lib if not already there.
Now open the GLFW folder and goto Build (where CMake had built the files). Open GLFW.xcodeproj file in Xcode.
Select install > My Mac and then click on run (Play shaped button).
It is now successfully installed (ignore the warnings).
To make sure Open Finder and goto /usr/local/lib folder and three GLFW library files will be already present there (If not then open Build folder inside GLFW folder and go to src/Debug copy all files to /usr/local/lib)
Open Finder and goto /usr/local/include and a GLFW folder will be already present there with two header files inside it by name of glfw3.h and glfw3native.h
2. Install GLEW
GLEW is a cross-platform library that helps in querying and loading OpenGL extensions. It provides run-time mechanisms for determining which OpenGL extensions are supported on the target platform. It is only for modern OpenGL (OpenGL version 3.2 and greater which requires functions to be determined at runtime). To install first download its files from glew.sourceforge.net
Extract the GLFW folder and its contents will look like this.
Now open Terminal, navigate to GLEW Folder and type the following commands
Now GLEW is successfully installed. To make sure its installed, Open Finder, go to /usr/local/include and a GL folder will be already present there with three header files inside it by name of glew.h, glxew.h and wglew.h
![Opengl 4.1 Mac Download Opengl 4.1 Mac Download](/uploads/1/2/6/8/126865320/236308527.png)
Open Finder and go to /usr/local/lib and GLEW library files will be already present there
Opengl 4.3 Download Windows 10
3. Test and Run
Now we have successfully installed GLFW and GLEW. Its time to code. Open Xcode and create a new Xcode project. Select Command Line Tool then proceed next and select C++ as language.
Xcode will create a new command line project.
Click on project name, and under Build Settings tab switch from Basic to All, under Search Paths section, add /usr/local/include in Header Search Paths and add /usr/local/lib in Library Search Paths
Click on project name, and under Build Phases tab and under Link With Binary Libraries add OpenGL.framework and also add recently created GLFW and GLEW libraries from /usr/local/lib
Now we are ready to code in Modern Open GL 4.1 on macOS using C++ and Xcode. The following code will create an OpenGL Window using GLFW with Blank Screen Output.
![4.1 4.1](/uploads/1/2/6/8/126865320/924261277.jpg)
Opengl Driver Download
Related Tags