Mobile intel 4 series express chipset family opengl


For chipset naming convention, please refer to the whitepaper “Quick Reference Guide to Graphics” <1>.

You watching: Mobile intel 4 series express chipset family opengl

Supported OpenGL Extensions

In the reference table, the first column states the extension; the second column gives a brief description of the extension; the 3rd column reflects the first driver variation for Windows* XP/Vista that the extension is supported. For example, for the expansion GL_ARB_point_sprite, the first version of driver in Windows XP* that supports this extension is 14.36; and the first version of driver in Windows Vista* that supports this extension is 15.11. Drivers will assistance all extensions supported by a previous version of the driver. All extensions sustained in 15.11 will certainly be supported by default in 15.14. Same is the case via Windows XP drivers, 14.38 will support all extensions sustained by 14.36. Also, 14.x suggests all driver versions of Windows XP assistance the extension. 15. x suggests all Windows Vista driver versions assistance this extension.

API Support

OpenGL API Support

Windows Vista Driver

Windows XP Driver

OpenGL 1.5



OpenGL 2.0



OpenGL 2.1



GLSL Support

GLSL (Open GL Shading language) is high level shading language which permits user to usage a C favor programming language to control the graphics pipe line for vertex and also fragment operations. GLSL supports C programming constructs like branches, loops, if-else, while, break and also continue.

GLSL Support

Windows Vista Driver

Windows XP Driver

GLSL 1.1



GLSL 1.2



ARB Extensions

OpenGL ARB extension

Short description

ARB Expansions easily accessible on all driver versions (14.x and also 15.x)


Allows multiple texture objects to be bound at the very same time through sepaprice blend settings and also map coordinates


Adds an interchallenge for delivering data to and also from the OpenGL pipeline


Define an area of a window to be conserved in memory for quick restores.


Provides a device to anti alias all GL primitives:points, lines, polygons, bitmaps, and imeras. Currently supports just MAX_SAMPLE=1. MAX_SAMPLE=4 will be sustained in future releases


Provides a mechanism to antialias all GL primitives: points, lines, polygons, bitmaps, and imperiods.


Texture setting function ADD


Provides a new texture generation scheme for cube map textures...


Allow an application to identify which WGL extensions are supported by a machine.


Provide the capcapacity to query pixel format qualities and to pick from the list of sustained layouts.


Allow prehandling of image data in background.


Allow an application to render to non visible rendering buffers (pixel buffers).


Allows OpenGL applications to use compressed texture images


Defines a second texture clamping algorithm


Supports extra geometric qualities of points.


Allows programmable texture combiner operations


Provides capabilities to usage the texture color from other texture systems as resources to the COMBINE_ARB setting attribute.


Adds brand-new operation to the texture combiner operations.


Extends the collection of texture wrap settings to include a photo twice the dimension via a mirror image


Define a brand-new texture setting feature ADD.


Produces Boolean texture value, provided to implement shadow maps


Provides a set of features to directly collection the present raster position in home window coordinates


Provides a technique for defining vertex program instruction sequences for vertex programs


Provides a technique for specifying fragment regimen instruction sequences for fragment programs.


Provides interconfront to cache vertex variety data in memory buffer objects


Used to query the number of pixels drawn by a primitive operation.


Adds a new texture target that supports 2D textures.

ARB Extensions available from vehicle drivers 14.36 and 15.11


Provides attributes for creating shader objects and program objects, for compiling shader objects and so on.


Adds programmable vertex level handling to OpenGL


Adds use to specify fragment shader objects.


Indicated open up gl shading language is supported.


Supports relaxing Open GL power-of-two size constraints across all texture targets


Allow applications to replace the existing texture collaborates via point sprite texture collaborates.


Exhas a tendency ARB_fragment_regime and ARB_fragment_shader to permit multiple output colors


Permits buffer objects to be offered not only through vertex range information, however additionally through pixel information.

ARB Expansions obtainable from vehicle drivers 14.38 and 15.13


Adds pixel styles or visuals via floating-suggest RGBA shade components.


Adds pixel formats with floating-suggest RGBA color components.


Adds texture interior styles through 16- and also 32-bit floating-suggest components.


Allows draw/review pixel information in 16-bit floating suggest format. Apply to DrawPixel ()/ReadPixel () and also to texture production attributes and also filter/color map features.

Vendor and EXT Extensions

Vendor and EXT extension

Brief description

Vendor Extensions accessible on all driver versions (14.x and 15.x)


Provide a reverse order different to image format RGBA.


Provide layouts which match memory layout of Windows DIBs.


Add a continuous shade in blending equations to rise blending capability.


Define a function that permits independent establishing of the RGB and alpha blend determinants for blending operations.


Increase the blfinishing capability by defining 2 new blfinishing equations.


Add 2 blending equations which develop the distinction of its left and also best hand also sides.


Provide an alternative for not requiring clip volume clipping for primitives.


Define an interface so that static vertex variety can be cached or precompiled.

See more: Control Panel Please Wait Until The Current Program


Include an explicit per-vertex fog coordinate to be offered in fog computations.


Provide support for packed pixels in memory.


Allow the normal vector to rerange after being multiplied by the inverse design watch matrix.


Add a second color to rasterization.


Allow maximum and minimum wrapping of stencil worths.


Add more texture compression usability for S3TC format.


Define a brand-new texture environment feature ADD.


Define a brand-new texture environment function COMBINE_EXT.


Provide a general mechanism for sustaining anisotropic texture filtering schemes.


Introduce a new texture wrap mode that supplies a texture map twice as large at the original picture.


Provide 2 brand-new texture coordinate generation modes.


Allow an application to control the periodicity of shade buffer swaps.


Changes depth worth of polygons by an offset


Supports miscellaneous resolution of color component in texture images


Provides 3 dimensional texture mapping


Allows redefining existing portion of a texture image


Defines methods to pack texture images directly from framebuffer


Allows naming of texture objects


Imposes constraints on texture level of images


Allows definition of multiple geometry primitives


Allows techniques to derive whole mipmap variety values


Texture coordinate clamping algorithm


Provides added geometric characterization of points


Additional blfinishing equation provided


Defines new depth texture format


New vertex rendering instructions


Specifies RGB components for second color


Handles multiple list of vertices in one call


Alias of GL_EXT_multi_draw_arrays


Provides a way to adjust the mipmap computations


Provide 4 additional blending components to have actually distinct results.


Adds brand-new operation to texture combiner operations.


Add brand-new texture target to support 2D textures


Allows intake of points than quads


Allows assistance of all binary texture comparichild functions


Allows two sided stencil testing and all connected stencil operations


Specifies texture information in compressed s3TC format


More texture compression assistance for FXT1 format


Used to find which WGL extensions are supported

Vendor Expansions easily accessible from motorists 14.38 and also 15.13


Allows changes to stencil format


Introduces separate RGB and alpha blfinish values


Define a basic interchallenge for illustration to rendering desticountries.

Vendor Expansions accessible from vehicle drivers 14.38 and 15.13


Add brand-new uncompressed and also compressed shade texture styles via sRGB components.


Pixel Buffer Object and also Frame Buffer Object Support

OpenGL supplies a pipelined architecture; each unit needs data from previous section to finish its job. The vertex data and pixel data are processed with the pipeline, unified and also created to the structure buffer for display screen. Rasterization is the procedure which combines geomeattempt and also pixel data and also writes as a fragment. Fragment is a things containing depth, width, color, points and also other indevelopment vital for screen. Each fragment maps to a pixel in the screen. A framework buffer is a set of buffers containing shade, depth, stencil and buildup buffers. However this framework buffer is windows device gave and also controlled by the operating system.

Frame Buffer Object (FBO)

The GL_EXT_framebuffer_object extension specifies an interconfront that allows rendering to one or even more off screen frame buffers other than the default frame buffer offered to OGL by the operating system. The development of these newly characterized rendering destinations, described as framework buffer-attachable images, provide the usability that allows:

Off display screen rendering without the window’s dimension limitationDirect rendering to textures without the requirement to use glCopyTexImage()Rendering to multiple areas via the usage of fragment shadersRendering to the stencil and depth logical buffers through the use of the freshly presented renderbuffer object.

FBO is sustained by 4 series chipsets in Vista (15.11) and XP (14.36) graphics vehicle drivers.

Pixel Buffer Object (PBO)

Pixel Buffer Object broadens vertex buffer object to store both vertex and also pixel data. ARB_vertex_buffer_object is the extension to support vertex buffers. Vertex Buffer objects (VBO) are actually produced, as soon as a glBindBuffer() function is referred to as for the first time for a offered buffer name. The 2 pixel path functions impacted by PBO are:

glDrawPixels() - draws pixels from PBO directly to the frame bufferglReadPixels() - Reads pixels directly from the framework buffer and also create the information right into PBO.

Two primary groups of features, affected by PBO are:

glTexImage*D() – Used to carry texture from the user memory to the OGL-managed memoryglGetTexImage() – Used to move texture to the user memory

Instances of Using OpenGL extensions

In this section, 2 examples present exactly how OpenGL extensions can be used.

Using GL_EXT_abgr

The initially instance illustprices the usage of the expansion GL_EXT_abgr.

GL_EXT_abgr exhas a tendency the list of color layouts in order to fit big-endian machines. In this format, the pixel color information consists of four components: alpha, blue, green, red, and also these components are stored in this order. The color of a pixel is the combicountry of blue, green and red. The alpha component is the level of color transparency. Each component has actually a value in between 0 and 255. The alpha value 0 implies complete transparency, 255 indicates opaque, and a worth in between 0 and 255 implies some degree of transparency between complete transparency and opaque.

A feature, referred to as CreateImperiods, is offered to create 4 imperiods which have actually ABGR format. The initially photo is a red square with a level of transparency (0x80 in this example). The second picture is a green square via the same level of transparency. The third photo is a blue square through the very same level of transparency. The last image is a brown square with the same degree of transparency; the brown color is a combination of green and also red components.

#incorporate "stdafx.h"#include const int iImgLen = 128;const int iImgSize = iImgLen*iImgLen;GLubyte RedImg<4*iImgSize>;GLubyte GreenImg<4*iImgSize>;GLubyte BlueImg<4*iImgSize>;GLubyte BrownImg<4*iImgSize>;void CreateImages(void){glMatrixMode(GL_PROJECTION);glLoadIdentity();gluPerspective(60.0f, 1.0, 1.0, 400.0);glMatrixMode(GL_MODELVIEW);glDisable(GL_DITHER);int i;/* Create a red square */for (i=0; i The function dubbed RenderScene is used to draw the above imperiods. In this attribute, the API contact glDrawPixels is provided to render the imeras. Note that in glDrawPixels, the format GL_ABGR is supplied to attract the picture.

void RenderScene(void)glClearColor(0.0f, 0.0f, 0.0f, 1.0f); // Set babsence backgroundglClear(GL_COLOR_BUFFER_BIT);glEnable(GL_BLEND);glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);glRasterPos3i(-1.0, -0.5, -2.0);glDrawPixels(iImgLen, iImgLen, GL_ABGR_EXT, GL_UNSIGNED_BYTE, RedImg);glRasterPos3f(-0.2, -0.5, -2.0);glDrawPixels(iImgLen, iImgLen, GL_ABGR_EXT, GL_UNSIGNED_BYTE, GreenImg);glRasterPos3f(-0.7, -0.7 , -2.0);glDrawPixels(iImgLen, iImgLen, GL_ABGR_EXT, GL_UNSIGNED_BYTE, BlueImg);glRasterPos3f(-0.5, -1.0, -2.0);glDrawPixels(iImgLen, iImgLen, GL_ABGR_EXT, GL_UNSIGNED_BYTE, BrownImg);glFlush();The primary routine starts by checking whether or not the expansion GL_EXT_abgr is supported in the current GPU. If it is not supported, the routine sindicate exits; otherwise, it creates the over images in the ABGR styles and provides them.

int _tmain(int argc, char **argv) GLUT_SINGLE);// Type of screen mode: RGB, single bufferglutCreateWindow("Testing ABGR extension");// Captionif (!glutExtensionSupported("GL_EXT_abgr"))exit(-1);CreateImages();glutDisplayFunc(RenderScene);glutMainLoop();return 0; 

If the graphics hardware supports GL_EXT_abgr, the outcome is presented in the photo below. The overlap sections of the 4 squares have actually various colors because of the transparency effect of the squares.


Using OpenGL shading language

In this area, we present an instance of utilizing OpenGL shading language.

The code below reflects just how the application uses the vertex shader and also fragment shader. The source code of vertex and also fragment shaders are initially loaded through the API glShaderSourceARB, then they are compiled through glCompileShaderARB to produce shader objects. These shader objects are attached to a regime object dubbed g_routine. A program object is an OpenGL data structure object that contains all shader objects offered a details job. The compiled shader objects are then linked with glLinkProgramARB.

#encompass "stdafx.h"#encompass "glee.h"#incorporate GLhandleARB g_program;char infolog<1024>;char content<1024>;void Resize(int width, int height) glViewport(0, 0, width, height); glMatrixMode(GL_PROJECTION); gluPerspective(60, width / height, 0.1, 200.0); glMatrixMode(GL_MODELVIEW);void ProcessKey(unsigned char crucial, int x, int y)// type ESC to departure normallyif (crucial == 27) leave (0); bool LoadShader(char *file, GLenum type)// GLSL shader.GLhandleARB shaderObj;// Load shader"s resource text.FILE *fp;unsigned int ByteCount = 0;fp = fopen((char*) file, "rb");ByteCount = fread(content, sizeof(BYTE), 1024, fp);content = 0;// Create the shader from a text file.shaderObj = glCreateShaderObjectARB(type);const char * p = content;glShaderSourceARB(shaderObj, 1, (const char**)&p, NULL);glCompileShaderARB(shaderObj);GLint result, numChars = 0;// Returns the results of the shader compilation.glGetObjectParameterivARB(shaderObj, GL_OBJECT_COMPILE_STATUS_ARB, &result);// Display shader errors if any type of.if(result == 0)// Get the error message and display screen it.glGetInfoLogARB(shaderObj, sizeof(infolog), &numChars, infolog);printf("Error in %s...n%sn", file, infolog);rerotate false;// Attach to the routine.glAttachObjectARB(g_program, shaderObj);glDeleteObjectARB(shaderObj);rerevolve true;bool InitializeApp()glClearColor(0.0f, 0.0f, 0.0f, 1.0f);glShadeModel(GL_SMOOTH);glEnable(GL_DEPTH_TEST); //Load the vertex shader.if(LoadShader("vs.glsl", GL_VERTEX_SHADER_ARB) == false)rerotate false;// Load the fragment shader.if(LoadShader("fs.glsl", GL_FRAGMENT_SHADER_ARB) == false)rerevolve false;// Link together the vertex and also fragment shaders.glLinkProgramARB(g_program);GLint result, numChars = 0;glGetObjectParameterivARB(g_regimen, GL_OBJECT_LINK_STATUS_ARB, &result);if(outcome == 0)// Get the error message and screen it.glGetInfoLogARB(g_regimen, sizeof(infolog), &numChars, infolog);printf("Error linking shader...n%sn", infolog);rerotate false;rerotate true;The feature referred to as RenderShadedCube is offered to render a rotated cube in 3 dimensions. It specifies the eight vertices of a cube. The cube has 6 square faces, and each face is composed of four vertices. In each square confront, 4 vertices have 4 different colors. The API speak to glUseProgramObjectARB tells the compiler to install a program object’s executable code.


void RenderShadedCube()static float theta = 0.00;glClearColor(0.0f, 0.5f, 0.5f, 1.0f);// green backgroundglClear(GL_COLOR_BUFFER_BIT The major regimen starts by checking the OpenGL variation sustained by the GPU. Because GLSL becomes component of OpenGL beginning version 2.0, we deserve to query the shading variation if OpenGL version is better or equal to 2.0. If the OpenGL version is 1.x then we may examine the 4 extensions for GLSL which determines whether or not the existing GPU have the right to run GLSL or not. If GLSL is not supported, the regimen ssuggest exits; otherwise, it makes the rotated cube using the predifined vertex and grament shaders.

int _tmain(int argc, char **argv){glutInit(&argc, argv);glutInitWindowSize(600, 600);glutInitWindowPosition(100, 100);glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH);glutCreateWindow("GL Shading Language");int maj = 0;int min = 0;char *glver = (char*) glGetString(GL_VERSION);sscanf(glver, "%d.%d", &maj, &min);printf("OpenGL variation sustained -> major:%d minor:%dn", maj, min);if (maj >= 2)// Version 2+ has shaderschar *glshadingver = (char*) glGetString(GL_SHADING_LANGUAGE_VERSION);sscanf(glshadingver, "%d.%d", &maj, &min);else if (maj == 1) !glutExtensionSupported("GL_ARB_fragment_shader") printf("GLSL is ready!n");printf("GLSL version -> major:%d minor:%dn", maj, min);glutDisplayFunc(RenderShadedCube);glutReshapeFunc(Resize);glutKeyboardFunc(ProcessKey);// Create the regimen linked via shadersg_routine = glCreateProgramObjectARB();if(InitializeApp() == true)glutMainLoop();elseprintf("Error in InitializeApp()!nn");glDeleteObjectARB(g_program);rerevolve 0;Finally, the resource code of the vertex shader is displayed listed below. Keep in mind that it is written in OpenGL shading language, a high-level procedural language.

See more: Pdanet Usb Connection Dropped Code 2, How To Fix Usb Tethering Windows 10

differing vec4 color;void main() gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex; shade = gl_Color;Similarly, the resource code of the fragment shader is shown below.