ARB (GPU assembly language)


ARB (GPU assembly language)

ARB - OpenGL Assembly Language is a low-level shading language. It was created by the OpenGL ARB to standardize GPU instructions controlling the hardware graphics pipeline.

History

Texas Instruments created the first programmable graphics processor in 1985: the TMS34010, which allowed developers to load and execute code on the processor to control pixel output on a video display. This was followed by the TMS34020 and TMS34082 in 1989, providing programmable 3D graphics output.

NVIDIA released its first video card NV1 in 1995, which supported quadratic texture mapping. This was followed by the Riva 128 (NV3) in 1997, providing the first hardware accelation for Direct3D.

Various video card vendors released their own accelerated boards, each with their own instruction set for GPU operations. The OpenGL Architecture Review Board (ARB) was formed in 1992, in part to establish standards for the GPU industry.

The ARB and NVIDIA established a number of OpenGL extensions to standardize GPU programming [ cite web | url = http://download.nvidia.com/developer/presentations/2004/6800_Leagues/6800_Leagues_OpenGL_exts.pdf | title = History of Programmability in OpenGL | author = Simon Green ] :

* EXT_texture_env_combine - provided a programmable method of combining textures.
* NV_register_combiners - GeForce 256
* NV_vertex_program - GeForce 3
* NV_texture_shader - GeForce 3
* NV_texture_shader3 - GeForce 4
* NV_vertex_program2 - GeForce FX
* NV_fragment_program - GeForce FX

This culminated with ARB's 2002 release of

* ARB_vertex_program [ cite web | url = http://oss.sgi.com/projects/ogl-sample/registry/ARB/vertex_program.txt | title = ARB_vertex_program | author = ARB ]
* ARB_fragment_program [ cite web | url = http://oss.sgi.com/projects/ogl-sample/registry/ARB/fragment_program.txt | title = ARB_fragment_program | author = ARB ]

These two extensions provided an industry standard for an assembly language that controlled the GPU pipeline for 3D vertex and interpolated pixel properties, respectively.

Subsequent high-level Shading languages compile to this ARB standard. While 3D developers are now more likely to use a C-like, high-level Shading language for GPU programming, ARB assembly has the advantage of being supported on a wide range of hardware.

Details

ARB_vertex_program

The ARB Vertex Program extension provides APIs to load ARBvp1.0 assembly instructions, enable selected programs, and to set various GPU parameters.

Vertex programs are used to modify vertex properties, such as position, normals and texture coordinates, that are passed to the next pipeline process: often a fragment shader; more recently, a geometry shader.

ARB_fragment_program

The ARB Fragment Program extension provides APIs to load ARBfp1.0 assembly instructions, enable selected programs, and to set various GPU parameters.

OpenGL fragments are interpolated pixel definitions. The GPU's vertex processor calculates all the pixels controlled by a set of vertices, interpolates their position and other properties and passes them onto its fragment process. Fragment programs allow developers to modify these pixel properties before they are rendered to a frame buffer for display.

OpenGL Parameters

* Attrib parameters are per-vertex attributes such as vertex normals.

* Local parameters are applied across a program's entire data set for a given shader pass.

* Env parameters are applied across all programs.

ARB Variables

All ARB assembly variables are float4 vectors, which may be addressed by xyzw or rgba suffixes.

ARB registers are scalar variables were only one element may be addressed.

* ADDRESS variables are registers.

* ATTRIB are per-vertex attributes.

* PARAM are uniform properties - constants, Env or Local.

* TEMP temporary variables.

* ALIAS provides alternate names for variables.

* OUTPUT designates variables that are passed back to the pipeline.

Vertex Attributes

ARB assembly supports the following suffixes for vertex attributes:

* position
* weight
* normal
* color
* fogcoord
* texcoord
* matrixindex
* attrib

tate Matrices

ARB assembly supports the following state matrices:

* modelview
* projection
* texture
* palette
* program

The following modifiers may be used:

* inverse
* transpose
* invtrans

ARB Assembly Instructions

ARB supports the following instructions:

* ABS - absolute value
* ADD - add
* ARL - address register load
* DP3 - 3-component dot product
* DP4 - 4-component dot product
* DPH - homgeneous dot product
* DST - distance vector
* EX2 - exponential base 2
* EX2 - exponential base 2 (approximate)
* FLR - floor
* FRC - fraction
* LG2 - logarithm base 2
* LIT - compute light coefficients
* LOG - logarithm base 2 (approximate)
* MAD - multiply and add
* MAX - maximum
* MIN - minimum
* MOV - move
* MUL - multiply
* POW - exponentiate
* RCP - reciprocal
* RSQ - reciprocal square root
* SGE - set on greater than or equal
* SLT - set on less than
* SUB - subtract
* SWZ - extended swizzle
* XPD - cross product

ARB assembly provides no instructions for flow control or branching. SGE and SLT may be used to conditionally set or clear vectors or registers.

ARB interfaces provide no compiling step for assembly language.

ample Code

A sample trivial ARB Vertex Shader

!!ARBvp1.0TEMP vertexClip;DP4 vertexClip.x, state.matrix.mvp.row [0] , vertex.position;DP4 vertexClip.y, state.matrix.mvp.row [1] , vertex.position;DP4 vertexClip.z, state.matrix.mvp.row [2] , vertex.position;DP4 vertexClip.w, state.matrix.mvp.row [3] , vertex.position;MOV result.position, vertexClip;MOV result.color, vertex.color;MOV result.texcoord [0] , vertex.texcoord;END

A sample trivial ARB Fragment Shader

!!ARBfp1.0TEMP color;MUL color, fragment.texcoord [0] .y, 2.0;ADD color, 1.0, -color;ABS color, color;ADD result.color, 1.0, -color;MOV result.color.a, 1.0;END

References

ee also

* OpenGL
* OpenGL Architecture Review Board
* Shader Languages
* Assembly Languages

External links


Wikimedia Foundation. 2010.

Look at other dictionaries:

  • Shading language — A shading language is a special programming language adapted to easily map on shader programming. Those kind of languages usually have special data types like color and normal. Because of the various target markets of 3D graphics, different… …   Wikipedia

  • OpenGL — Original author(s) Silicon Graphics Developer(s) Khronos Group Stable release 4.2 …   Wikipedia

  • GLSL — OpenGL Shading Language (abbreviated: GLSL or GLslang), is a high level shading language based on the syntax of the C programming language. It was created by the OpenGL ARB to give developers more direct control of the graphics pipeline without… …   Wikipedia

  • OpenGL Architecture Review Board — The OpenGL Architecture Review Board (ARB) is an industry consortium that governed the OpenGL specification. It was formed in 1992, and defined the conformance tests, approved the OpenGL specification and advanced the standard. On July 31, 2006,… …   Wikipedia

  • OpenGL Architecture Review Board — L OpenGL Architecture Review Board (ARB) est un consortium qui encadre les spécifications d OpenGL. Il a été formé en 1992 et défini les tests de conformité pour valider les spécifications d OpenGL et continue de mettre à jour les standards. Le… …   Wikipédia en Français

  • Comparison of OpenGL and Direct3D — Direct3D and OpenGL are competing application programming interfaces (APIs) which can be used in applications to render 2D and 3D computer graphics, taking advantage of hardware acceleration when available. Modern graphics processing unit (GPUs)… …   Wikipedia

  • Perl OpenGL — Infobox Software name = Perl OpenGL caption = A screenshot illustrating FBO and Vertex/Fragment program extensions via POGL developer = Stan Melax, Kenneth Albanowski, Ilya Zakharevich, Jean Louis Morel, Bob Free latest release version = 0.57… …   Wikipedia


Share the article and excerpts

Direct link
Do a right-click on the link above
and select “Copy Link”

We are using cookies for the best presentation of our site. Continuing to use this site, you agree with this.