Crossing out Integrated Circuits is due to the fact that most of the system requirements of 3D- and Render programs do not support Integrated Graphics. But if that is correct seeing the new specs and the support of the newest OpenGL and OpenCL support of Intel Iris Pro and other new issued models? The answer is at the software makers. They have to check if and with what type Intel Graphics it is possible. Communication in this respect is rather slow to say the least.
Home page OpenGL
Al jaren als Open Source beschreven en aangeduid, maar OpenGL is dat niet. OpenGL betekent dat het vrij is voor gebruik op welk platform dan ook. De broncode, zoals bij Open Source gebruikelijk, is niet beschikbaar. Wel zijn er uitgebreide Coding Resources om alle functies te beschrijven die kunnen worden toegepast door de programmeur.
OpenGL is a software interface to graphics hardware. This interface consists of about 150 distinct commands that you use to specify the objects and operations needed to produce interactive three-dimensional applications.
OpenGL is an open, cross-platform graphics standard with broad industry support. OpenGL greatly eases the task of writing real-time 2D or 3D graphics applications by providing a mature, well-documented graphics processing pipeline that supports the abstraction of current and future hardware accelerators.
In deze Wiki wordt OpenGL nog eens duidelijk uitgelegd, met alle informatie die u wenst.
OpenGL bij NVIDIA
Originally developed by Silicon Graphics in the early '90s, OpenGL has become the most widely-used open graphics standard in the world.. NVIDIA supports OpenGL and a complete set of OpenGL extensions, designed to give you maximum performance on our GPUs. NVIDIA continues to support OpenGL as well through technical papers and our large set of examples on our NVIDIA Graphics SDK.
The Khronos Group is an open consortium of over 100 companies that have an interest in graphics and compute APIs. Along with OpenGL and OpenGL ES, it also manages OpenCL, OpenVG, EGL, WebGL, COLLADA and number of other media, sensor and vision-centric standards. There are several tiers of membership. The highest level of membership is known as a Promoter member, of which there are currently 12. They are listed here, and are AMD, (Apple in the past), ARM, Epic Games, Imagination Technologies, Intel, Nokia, NVIDIA, Qualcomm, Samsung, Sony and Vivante. Promoter members hold a seat on the board of directors at Khronos. This board has final sign off on new specifications, and determines things such as funding for working groups and the general direction of Khronos itself.
Open GL en Apple computers
Lijst met OpenGL Capabilities Tables van Apple zelf
met alle versies van OpenGL keurig gerubriceerd.
Apple en OpenGL Extensions Guide
OpenGL Extensions Guide is a reference for the extensions that OS X supports. The guide provides a short summary of each extension, a link to the official specification, availability information, and hardware renderer support.
Apple en OpenGL
On October 22, 2013, Apple released OS X Mavericks, also known as OS X version 10.9. This version of the operating system included a long awaited update to the supported version of OpenGL. The 6th edition of the OpenGL SuperBible is about OpenGL version 4.3, and unfortunately, Apple's latest and greatest only supports version 4.1 of the API. As OpenGL 4.1 was released on July 26, 2010, this puts OS X more than three years behind. However, not all of the book's samples make use of all of the latest features, and it's possible to run many of them on version 4.1 of the API. I've ported what I can.
OSX 10.9 Mac Book Pro
Porting Samples to Mac
Posted on November 11, 2013 by graham 10
What Works, What Doesn't
Now, there are clearly some samples that arenÄôt going to run on OpenGL 4.1. For instance, anything that uses compute shaders (the depth-of-field and flocking samples, for example), shader storage buffers (the fragmentlist sample), atomic counters or image loads and stores isnÄôt going to port. Luckily, although the Mac OpenGL implementation is only version 4.1, it does have a couple of extensions from OpenGL 4.2 Äî GL_ARB_internalformat_query and GL_ARB_texture_storage, the latter of which is used by the sb6 framework's texture loader.
To be fair, the book's preface does say that the samples have been tested on Mac. We've received a couple of poor reviews on Amazon because the code isnÄôt usable on Mac. For my day job, IÄôm the architect of AMD's PC OpenGL driver, which we use for Windows and Linux. My cube neighbor is the architect for AMDÄôs Mac driver. Apple can be pretty secretive about whatÄôs coming up and when, and all I had to go on when I wrote that preface (back in January of 2013) was insider knowledge of what my neighbor was working on. Even he doesnÄôt know whatÄôs going to be in the next OS version or when it might release. However, it seemed that he was making pretty good progress and that I'd have a shot at building Mac versions of the samples by the time the book shipped. So much for my ability to predict the future.
Unlike Windows and Linux, where the hardware vendor ships drivers which determine the version of OpenGL available on your machine, on the Mac platform, big chunks of the OpenGL stack are part of the operating system and so an OS update is required to bump the OpenGL version. Hence, although AMD, NVIDIA and Intel have all had OpenGL 4.x capable hardware shipping in Mac platforms for some time, we needed to wait until the 10.9 Mavericks update to actually expose it. Step 1, then, is to update the operating system to the latest available. After a quick stop off at the App Store, and a rather large, 5GiB free download (which is excellent), I was installing OS X 10.9 Mavericks on my trusty Mac Book Pro.
OS X 10.9 on Mac Book Pro
Of course, the next step is to install XCode, which includes all the developer tools. WhatÄôs more to say about XCode? It seems that people either love it or hate it. I wouldn't say I love it. IÄôve used a lot of development environments in the past. While I'm most comfortable with Visual Studio, IÄôve had spells with Borland's C++ Builder IDE, KDevelop, Anjuta, Eclipse, and Qt Creator. XCode is different and I would imagine would take a lot of getting used to. I was able to coerce CMake into generating XCode project files for the samples. But, once loaded into XCode, getting things to build was close to impossible. It was difficult to navigate the project, difficult to see what was going wrong, and an extremely frustrating experience.
First Pass at SuperBible 6 Samples in Xcode
In the end, I opted to generate regular Makefiles at the command prompt. This seemed much more straight forward, and after a short time, I had everything building and linking. Upon running the first example, it crashed almost immediately. Now, this may be an artifact of the version of GLFW that IÄôve used for the projects, but it seems that if you ask for GLFW_ OPENGL _VERSION_MAJOR as 4 and GLFW_OPENGL_ VERSION_MINOR as 1 (i.e., ask for OpenGL 4.1), context creation will fail. However, if you set GLFW_ OPENGL_ VERSION_MAJOR to 3 and GLFW_ OPENGL_ VERSION _MINOR to 2 (ask for OpenGL 3.2), you'll get a 4.1 context. You also need to ask for a forward compatible context.
Debugging this was a pain. XCode wouldn't cooperate. I couldn't get it to debug anything it didn't build, and I couldn't get it to build my samples. Time to whip out the trusty command line debugger, gdb. Except, with Mavericks, gdb is gone and now we have lldb. lldb seems good. I'm not quite sure why a whole new debugger is necessary. I'm certain that lldb does some pretty neat things that gdb can't do, but for the things that are the same (setting breakpoints, for example), it seems to be different (and therefore unfamiliar) for the sake of it. Learning a new debugger just to step through sample applications I know already work was yet more pain.
For the most part, modifying the #version declaration in the shaders to request version 410 core rather than 430 was sufficient to get the samples working. Of course, dropping the shading language version meant that I couldnÄôt make use of some of the convenience functions that have been incorporated recently, such as some forms of implicit conversion and promotion from scalar to vector. I fixed the most trivial of these and was fairly quickly up and running with the first few samples.
OpenGL SuperBible Samples Running on Mac OS X 10.9
The biggest issue was the lack of explicit binding declarations on sampler uniforms in GLSL. These allow you to write, directly in the shader code, the texture unit that a sampler corresponds to. The type of declaration I'm referring to looks like this:
There's a few more conspicuously absent features in the Mavericks OpenGL implementation. As the ARB has produced new features in OpenGL, we've gone to some effort to document them not only in the core specification, but as extensions as well. This allows vendors and implementers to ship a baseline OpenGL version, but cherry-pick a couple of handy features on top of them. As I mentioned, Apple has done this with GL_ARB_internalformat_query and GL_ARB_texture_storage, but there's nothing more beyond the core features of OpenGL 4.1 and a couple of vendor extensions.
specifications about header files, documenation and related API's including GLU, GLX and WGL. Further the use of extensions to these API's.
OpenGL wordt ondermeer door het bekende 3D-programma SketchUp Pro gebruikt om op een gemakkelijke manier 3D modellen te ontwerpen. Welke daarna indien gewenst als input kunnen worden gebruikt voor een render programma.
SketchUp Pro is een van de vele 3D tekenprogramma's die als voorwaarde stelt dat de gebruikte computer "Voor de volle 100% OpenGL compatibel moet zijn". Of te wel de gebruikte grafische kaart moet OpenGL ten volle ondersteunen. En dat lijkt makkelijker dan de praktijk uitwijst. Er zijn nl. behoorlijk wat grafische kaarten die een belangrijk deel (subset) van OpenGL ondersteunen. En dat zijn vaak de GAME kaarten. In de meeste gevallen gaat dat echter goed, een redelijk moderne grafische kaart van AMD of NVIDIA van een bepaald niveau zal zonder meer in de technische gegevens de OpenGL generatie aangeven. Of het hier om een subset gaat, wordt meestal niet vermeld.
Ook bij de bekende Rhino zijn er restricties voor het gebruik van Intel Graphics
Intel graphics cards
Rhino 5 SR11 runs on Intel HD3000 and newer chipsets. Common hardware that includes these newer chipsets are 13Äú Apple MacBooks and Microsoft Surface Pro tablets. These are not high performance cards.
Pre-HD3000 Intel graphics chips are not recommended
Alhoewel OpenGL wel door Intel integrated graphics wordt ondersteund, vermelden veel 3D- en render programma's bij de systeem eisen dat " Intel graphics will not be supported."
Of dat altijd helemaal terecht is valt te bezien. De nieuwste series van Intel graphics bieden meer geheugen en redelijk laatste generatie versies van OpenGL en DirectX. Let op OpenCL is lang niet altijd beschikbaar. Het nadeel is dat RAM geheugen afgepakt wordt uit de hoeveelheid geheugen. En dat is per definitie tientallen malen trager dan VRAM van de GPU.
Zie ook de speciale HD Graphics pagina op deze site.
Bij GAME programma
"Intel graphics chipsets are NOT supported"
"Intel graphics chipsets are NOT supported"
Solution for graphics issues on some Intel graphics chipsets in Fedora 22
What does not supported Integrated Graphics mean?
What is OpenGL?
OpenGL stands for Open Graphics Library. It is a specification of an API for rendering graphics, usually in 3D. OpenGL implementations are libraries that implement the API defined by the specification.
Graphics cards usually have an OpenGL implementation. Because the OpenGL specification is not platform-specific, it is possible to write an application that will be possible to use against many different types of graphics cards. It also increases the chance that the application will continue to work when new hardware will become available.
What is NOT OpenGL?
The OpenGL API only deals with rendering graphics. OpenGL does not provide functions for animations, timing, file IO, image file format processing, GUI, and so forth. OpenGL is concerned only about rendering.
GLUT is not OpenGL. It is not a part of OpenGL; it is simply a library that is used by some users to create an OpenGL window.
Who maintains the OpenGL specification?
The specification is maintained by OpenGL Architectural Review Board or ARB.
What platforms have GL?
Windows: 95 and above
Mac OSX: all versions
Linux: OpenGL is provided by open source drivers and MESA library, or by proprietary drivers.
FreeBSD: OpenGL is provided by open source drivers and MESA library or proprietary Nvidia drivers.
What 3D-file format should I use?
Newcomers often wonder what 3D file format for their mesh data to use for their project.
OpenGL does not load files; therefore, you can use any mesh format you wish. This also means that you must provide the appropriate loading code yourself; OpenGL won't help you.
There are several file format alternatives, with different capabilities. All of these formats (and more) can be loaded by the Open Asset Import library.
This is a simple text format for mesh data. Each .obj file holds a single mesh. Obj files can reference material files, stored in the less-frequently-used .mtl format. Meshes in this format may only contain positions, normals and optionally a single texture coordinate.
This is a binary mesh format. This format contains materials and can store multiple named meshes in a single file.
Quake 2 .md2 and Quake 3 .md3
These are binary mesh formats. The formats do not contain material information, and they only technically store a single mesh. They do have support for keyframe animation, so a single mesh file would contain all of the animation keyframes, as well as animation data.
This is an XML-based mesh file format. It can store pretty much anything; it is primarily used for document exchange between different 3D modelling packages.
OpenGL for OS X
Who's on Board by OpenGL?
What you do not see is Microsoft !
Comparison of OpenGL and Direct3D
Direct3D application development generally targets the Microsoft Windows platform. The OpenGL API is an open standard, and implementations exist for a wide variety of platforms.
Direct3D and OpenGL are competing application programming interfaces (APIs) which can be used in applications to render 2D and 3D computer graphics. Hardware acceleration of this process has been commonplace since approximately 1999.[dubious discuss] As of 2005 [update], graphics processing units (GPUs) almost always implement a particular version of both of these APIs, such as these examples: DirectX 9 and OpenGL 2 circa 2004; DirectX 10 and OpenGL 3 circa 2008; and most recently, DirectX 11 and OpenGL 4 circa 2011. GPUs that support more recent versions of the standards are backwards-compatible with applications that utilize the older standards; for example, one can run older DirectX 9 games on a more recent DirectX 11-certified GPU.
Windows tegenhanger: DirectX
Windows 10 Insider Preview offers new opportunities to create, distribute, and monetize games. Learn about porting and publishing your game.
Choose DirectX and C++ for your Windows games
DirectX gives the highest fidelity and richest experiences in 3D gaming. DirectX supports a wide range of graphics feature levels, from DirectX 9.1 to all the latest hardware features exposed in DirectX 11 and 12. DirectX allows you to tailor your game to every PC, from power-efficient ARM-based portable tablets, to over-clocked multi-GPU gamer rigs.
Some information relates to pre-released product which may be substantially modified before it's commercially released. Microsoft makes no warranties, express or implied, with respect to the information provided here.
Direct3D 12 provides an API and platform that allows apps to take advantage of the graphics and computing capabilities of PCs equipped with one or more Direct3D 12-compatible GPUs.
What is Direct3D 12?
DirectX 12 introduces the next version of Direct3D, the 3D graphics API at the heart of DirectX. This version of Direct3D is faster and more efficient than any previous version. Direct3D 12 enables richer scenes, more objects, more complex effects, and full utilization of modern GPU hardware.
Understanding Direct3D 12
To write 3D games and apps for Windows 10 Insider Preview and Windows 10 Mobile Insider Preview, you must understand the basics of the Direct3D 12 technology, and how to prepare to use it in your games and apps.
Work Submission in Direct3D 12
To improve the CPU efficiency of Direct3D apps, Direct3D 12 no longer supports an immediate context associated with a device. Instead, apps record and then submit command lists, which contain drawing and resource management calls. These command lists can be submitted from multiple threads to one or more command queues, which manage the execution of the commands. This fundamental change increases single-threaded efficiency by allowing apps to pre-compute rendering work for later re-use, and it takes advantage of multi-core systems by spreading rendering work across multiple threads.
Why OpenGL and not DirectX?
On Windows, it's a fact that the DirectX graphics drivers are better maintained than the OpenGL graphics drivers. This is caused by the vicious cycle of vendor support. As game developers are driven from OpenGL to DirectX by other factors, the graphics card manufacturers (vendors) get less bug reports for their OpenGL drivers, extensions and documentation. This results in shakier OpenGL drivers, leading even more game developers to switch from OpenGL to DirectX. The cycle repeats.
Similarly, it's a fact that more gaming graphics programmers know how to use DirectX than OpenGL, so it's cheaper (less training required) to make a game using DirectX than OpenGL. This is the result of another vicious cycle: as more game projects use DirectX, more programmers have to learn how to use it. As more programmers learn to use it, it becomes cheaper for game projects to use DirectX than to use OpenGL.
Return of the DirectX vs. OpenGL Debates