Mobile intel 4 series express chipset family opengl

Introduction

For vr-tab-quebec.com chipset naming convention, please refer to the whitepaper “Quick Reference Guide to vr-tab-quebec.com 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

14.x

15.x

OpenGL 2.0

14.36

15.11

OpenGL 2.1

14.39

15.14

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

14.36

15.11

GLSL 1.2

14.39

15.14

ARB Extensions

OpenGL ARB extension

Short description

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

GL_ARB_multitexture

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

GL_ARB_transpose_matrix

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

WGL_ARB_buffer_region

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

GL_ARB_multisample

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

WGL_ARB_multisample

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

GL_ARB_texture_env_add

Texture setting function ADD

GL_ARB_texture_cube_map

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

WGL_ARB_extensions_string

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

WGL_ARB_pixel_format

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

WGL_ARB_make_current_read

Allow prehandling of image data in background.

WGL_ARB_pbuffer

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

GL_ARB_texture_compression

Allows OpenGL applications to use compressed texture images

GL_ARB_texture_border_clamp

Defines a second texture clamping algorithm

GL_ARB_point_parameters

Supports extra geometric qualities of points.

GL_ARB_texture_env_combine

Allows programmable texture combiner operations

GL_ARB_texture_env_crossbar

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

GL_ARB_texture_env_dot3

Adds brand-new operation to the texture combiner operations.

GL_ARB_texture_mirrored_repeat

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

GL_ARB_depth_texture

Define a brand-new texture setting feature ADD.

GL_ARB_shadow

Produces Boolean texture value, provided to implement shadow maps

GL_ARB_window_pos

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

GL_ARB_vertex_program

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

GL_ARB_fragment_program

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

GL_ARB_vertex_buffer_object

Provides interconfront to cache vertex variety data in memory buffer objects

GL_ARB_occlusion_query

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

GL_ARB_texture_rectangle

Adds a new texture target that supports 2D textures.

ARB Extensions available from vehicle drivers 14.36 and 15.11

GL_ARB_shader_objects

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

GL_ARB_vertex_shader

Adds programmable vertex level handling to OpenGL

GL_ARB_fragment_shader

Adds use to specify fragment shader objects.

GL_ARB_shading_language_100

Indicated open up gl shading language is supported.

GL_ARB_texture_non_power_of_two

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

GL_ARB_point_sprite

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

GL_ARB_draw_buffers

Exhas a tendency ARB_fragment_regime and ARB_fragment_shader to permit multiple output colors

GL_ARB_pixel_buffer_object

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

GL_ARB_color_buffer_float

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

WGL_ARB_pixel_format_float

Adds pixel formats with floating-suggest RGBA color components.

GL_ARB_texture_float

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

GL_ARB_half_float_pixel

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)

GL_EXT_abgr

Provide a reverse order different to image format RGBA.

GL_EXT_bgra

Provide layouts which match memory layout of Windows DIBs.

GL_EXT_blend_color

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

GL_EXT_blend_func_separate

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

GL_EXT_blend_minmax

Increase the blfinishing capability by defining 2 new blfinishing equations.

GL_EXT_blend_subtract

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

GL_EXT_clip_volume_hint

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

GL_EXT_compiled_vertex_array

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

See more: Control Panel Please Wait Until The Current Program

GL_EXT_fog_coord

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

GL_EXT_packed_pixels

Provide support for packed pixels in memory.

GL_EXT_rescale_normal

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

GL_EXT_separate_specular_color

Add a second color to rasterization.

GL_EXT_stencil_wrap

Allow maximum and minimum wrapping of stencil worths.

GL_EXT_texture_compression_s3tc

Add more texture compression usability for S3TC format.

GL_EXT_texture_env_add

Define a brand-new texture environment feature ADD.

GL_EXT_texture_env_combine

Define a brand-new texture environment function COMBINE_EXT.

GL_EXT_texture_filter_anisotropic

Provide a general mechanism for sustaining anisotropic texture filtering schemes.

GL_IBM_texture_mirrored_repeat

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

GL_NV_texgen_reflection

Provide 2 brand-new texture coordinate generation modes.

WGL_EXT_swap_control

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

GL_EXT_polygon_offset

Changes depth worth of polygons by an offset

GL_EXT_texture

Supports miscellaneous resolution of color component in texture images

GL_EXT_texture3D

Provides 3 dimensional texture mapping

GL_EXT_subtexture

Allows redefining existing portion of a texture image

GL_EXT_copy_texture

Defines methods to pack texture images directly from framebuffer

GL_EXT_texture_object

Allows naming of texture objects

GL_SGIS_texture_lod

Imposes constraints on texture level of images

GL_EXT_vertex_array

Allows definition of multiple geometry primitives

GL_SGIS_generate_mipmap

Allows techniques to derive whole mipmap variety values

GL_SGIS_texture_edge_clamp

Texture coordinate clamping algorithm

GL_EXT_point_parameters

Provides added geometric characterization of points

GL_EXT_blend_logic_op

Additional blfinishing equation provided

GL_SGIX_depth_texture

Defines new depth texture format

GL_EXT_draw_range_elements

New vertex rendering instructions

GL_EXT_secondary_color

Specifies RGB components for second color

GL_EXT_multi_draw_arrays

Handles multiple list of vertices in one call

GL_SUN_multi_draw_arrays

Alias of GL_EXT_multi_draw_arrays

GL_EXT_texture_lod_bias

Provides a way to adjust the mipmap computations

GL_NV_blend_square

Provide 4 additional blending components to have actually distinct results.

GL_EXT_texture_env_dot3

Adds brand-new operation to texture combiner operations.

GL_NV_texture_rectangle

Add brand-new texture target to support 2D textures

GL_NV_point_sprite

Allows intake of points than quads

GL_EXT_shadow_funcs

Allows assistance of all binary texture comparichild functions

GL_EXT_stencil_two_side

Allows two sided stencil testing and all connected stencil operations

GL_S3_s3tc

Specifies texture information in compressed s3TC format

GL_3DFX_texture_compression_FXT1

More texture compression assistance for FXT1 format

WGL_EXT_extensions_string

Used to find which WGL extensions are supported

Vendor Expansions easily accessible from motorists 14.38 and also 15.13

GL_ATI_separate_stencil

Allows changes to stencil format

GL_EXT_blend_equation_separate

Introduces separate RGB and alpha blfinish values

GL_EXT_framebuffer_object

Define a basic interchallenge for illustration to rendering desticountries.

Vendor Expansions accessible from vehicle drivers 14.38 and 15.13

GL_EXT_texture_sRGB

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 vr-tab-quebec.com 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.

*

Conclusion