| Name |
| |
| ATI_fragment_shader |
| |
| Name Strings |
| |
| GL_ATI_fragment_shader |
| |
| Contributors |
| |
| Dan Ginsburg |
| Evan Hart |
| Jason Mitchell |
| |
| Contact |
| |
| Benj Lipchak, AMD (benj.lipchak 'at' amd.com) |
| |
| Status |
| |
| Shipping (version 1.0) |
| |
| Version |
| |
| Last Modified Date: November 4, 2006 |
| Author Revision: 1.8 |
| |
| Number |
| |
| 245 |
| |
| Dependencies |
| |
| ARB_multitexture is required by this extension. |
| ARB_shadow interacts with this extension. |
| The extension is written against the OpenGL 1.2.1 Specification. |
| |
| Overview |
| |
| This extension exposes a powerful fragment shading model which |
| provides a very general means of expressing fragment color blending |
| and dependent texture address modification. The programming is |
| a register-based model in which there is a fixed number of |
| instructions, texture lookups, read/write registers, and constants. |
| |
| The fragment shader extension provides a unified instruction set |
| for operating on address or color data and eliminates the |
| distinction between the two. This extension provides all the |
| interfaces necessary to fully expose this programmable fragment |
| shader in GL. |
| |
| Although conceived as a device-independent extension which would |
| expose the capabilities of future generations of hardware, changing |
| trends in programmable hardware have affected the lifespan of this |
| extension. For this reason you will now find a fixed set of |
| features and resources exposed, and the queries to determine this |
| set have been deprecated. |
| |
| Issues |
| |
| None |
| |
| |
| New Procedures and Functions |
| |
| uint GenFragmentShadersATI (uint range); |
| |
| void BindFragmentShaderATI (uint id); |
| |
| void DeleteFragmentShaderATI (uint id); |
| |
| void BeginFragmentShaderATI (void); |
| |
| void EndFragmentShaderATI (void); |
| |
| void PassTexCoordATI (uint dst, uint coord, enum swizzle); |
| |
| void SampleMapATI (uint dst, uint interp, enum swizzle); |
| |
| void ColorFragmentOp1ATI (enum op, uint dst, uint dstMask, |
| uint dstMod, uint arg1, uint arg1Rep, |
| uint arg1Mod); |
| |
| void ColorFragmentOp2ATI (enum op, uint dst, uint dstMask, |
| uint dstMod, uint arg1, uint arg1Rep, |
| uint arg1Mod, uint arg2, uint arg2Rep, |
| uint arg2Mod); |
| |
| void ColorFragmentOp3ATI (enum op, uint dst, uint dstMask, |
| uint dstMod, uint arg1, uint arg1Rep, |
| uint arg1Mod, uint arg2, uint arg2Rep, |
| uint arg2Mod, uint arg3, uint arg3Rep, |
| uint arg3Mod); |
| |
| void AlphaFragmentOp1ATI (enum op, uint dst, uint dstMod, |
| uint arg1, uint arg1Rep, uint arg1Mod); |
| |
| void AlphaFragmentOp2ATI (enum op, uint dst, uint dstMod, |
| uint arg1, uint arg1Rep, uint arg1Mod, |
| uint arg2, uint arg2Rep, uint arg2Mod); |
| |
| void AlphaFragmentOp3ATI (enum op, uint dst, uint dstMod, |
| uint arg1, uint arg1Rep, uint arg1Mod, |
| uint arg2, uint arg2Rep, uint arg2Mod, |
| uint arg3, uint arg3Rep, uint arg3Mod); |
| |
| void SetFragmentShaderConstantATI (uint dst, const float *value); |
| |
| |
| New Tokens |
| |
| Accepted by the <cap> parameter of Enable, Disable, and IsEnabled, |
| and by the <pname> parameter of GetBooleanv, GetIntegerv, GetFloatv, |
| and GetDoublev: |
| |
| FRAGMENT_SHADER_ATI 0x8920 |
| |
| Accepted by the <dst> and <argN> parameters of |
| ColorFragmentOp[1..3]ATI and AlphaFragmentOp[1..3]ATI, and by the |
| <dst> and <coord> parameters of PassTexCoordATI, and by the <dst> |
| and <interp> parameters of SampleMapATI: |
| |
| REG_0_ATI 0x8921 |
| REG_1_ATI 0x8922 |
| REG_2_ATI 0x8923 |
| REG_3_ATI 0x8924 |
| REG_4_ATI 0x8925 |
| REG_5_ATI 0x8926 |
| |
| Accepted by the <dst> parameter of SetFragmentShaderConstantATI and |
| the <argN> parameter of ColorFragmentOp[1..3]ATI and |
| AlphaFragmentOp[1..3]ATI: |
| |
| CON_0_ATI 0x8941 |
| CON_1_ATI 0x8942 |
| CON_2_ATI 0x8943 |
| CON_3_ATI 0x8944 |
| CON_4_ATI 0x8945 |
| CON_5_ATI 0x8946 |
| CON_6_ATI 0x8947 |
| CON_7_ATI 0x8948 |
| |
| Accepted by the <op> parameter of ColorFragmentOp1ATI and |
| AlphaFragmentOp1ATI: |
| |
| MOV_ATI 0x8961 |
| |
| Accepted by the <op> parameter of ColorFragmentOp2ATI and |
| AlphaFragmentOp2ATI: |
| |
| ADD_ATI 0x8963 |
| MUL_ATI 0x8964 |
| SUB_ATI 0x8965 |
| DOT3_ATI 0x8966 |
| DOT4_ATI 0x8967 |
| |
| Accepted by the <op> parameter of ColorFragmentOp3ATI and |
| AlphaFragmentOp3ATI: |
| |
| MAD_ATI 0x8968 |
| LERP_ATI 0x8969 |
| CND_ATI 0x896A |
| CND0_ATI 0x896B |
| DOT2_ADD_ATI 0x896C |
| |
| Accepted by the <argN> parameter of ColorFragmentOp[1..3]ATI and |
| AlphaFragmentOp[1..3]ATI: |
| |
| ZERO |
| ONE |
| PRIMARY_COLOR_ARB |
| SECONDARY_INTERPOLATOR_ATI 0x896D |
| |
| Accepted by the <interp> parameter of SampleMapATI and the <coord> |
| parameter of PassTexCoordATI: |
| |
| TEXTURE0_ARB |
| TEXTURE1_ARB |
| TEXTURE2_ARB |
| TEXTURE3_ARB |
| TEXTURE4_ARB |
| TEXTURE5_ARB |
| TEXTURE6_ARB |
| TEXTURE7_ARB |
| |
| Accepted by the <swizzle> parameter of SampleMapATI and |
| PassTexCoordATI: |
| |
| SWIZZLE_STR_ATI 0x8976 |
| SWIZZLE_STQ_ATI 0x8977 |
| SWIZZLE_STR_DR_ATI 0x8978 |
| SWIZZLE_STQ_DQ_ATI 0x8979 |
| |
| Accepted by the <dstMask> parameter of ColorFragmentOp[1..3]ATI: |
| |
| NONE |
| RED_BIT_ATI 0x00000001 |
| GREEN_BIT_ATI 0x00000002 |
| BLUE_BIT_ATI 0x00000004 |
| |
| Accepted by the <argNRep> parameter of ColorFragmentOp[1..3]ATI and |
| AlphaFragmentOp[1..3]ATI: |
| |
| NONE |
| RED |
| GREEN |
| BLUE |
| ALPHA |
| |
| Accepted by the <dstMod> parameter of ColorFragmentOp[1..3]ATI and |
| AlphaFragmentOp[1..3]ATI: |
| |
| NONE |
| 2X_BIT_ATI 0x00000001 |
| 4X_BIT_ATI 0x00000002 |
| 8X_BIT_ATI 0x00000004 |
| HALF_BIT_ATI 0x00000008 |
| QUARTER_BIT_ATI 0x00000010 |
| EIGHTH_BIT_ATI 0x00000020 |
| SATURATE_BIT_ATI 0x00000040 |
| |
| |
| Accepted by the <argNMod> parameter of ColorFragmentOp[1..3]ATI and |
| AlphaFragmentOp[1..3]ATI: |
| |
| 2X_BIT_ATI 0x00000001 |
| COMP_BIT_ATI 0x00000002 |
| NEGATE_BIT_ATI 0x00000004 |
| BIAS_BIT_ATI 0x00000008 |
| |
| |
| Additions to Chapter 2 of the OpenGL 1.2.1 Specification (OpenGL |
| Operation) |
| |
| None |
| |
| |
| Additions to Chapter 3 of the OpenGL 1.2.1 Specification (Rasterization) |
| |
| Add New Subsection after 3.8.10, (p. 138) |
| |
| 3.8.11 Fragment Shaders |
| |
| By default, the current texture environment is used to determine |
| how textures are combined for rasterization. However, by enabling |
| FRAGMENT_SHADER_ATI, the currently bound fragment shader is used to |
| determine how textures are combined. The fragment shader replaces |
| the traditional texture environment by exposing a fragment shading |
| model which provides a very general means of expressing fragment |
| color blending and dependent texture address modification. The |
| distinction between texture address and color data becomes |
| irrelevant in the fragment shader as the two can be used |
| interchangeably. |
| |
| A shader is defined between a BeginFragmentShaderATI and |
| EndFragmentShaderATI block. These commands are defined as follows: |
| |
| void BeginFragmentShaderATI(void); |
| void EndFragmentShaderATI(void); |
| |
| Although there is no restriction as to which GL operations may be |
| specified between BeginFragmentShaderATI and EndFragmentShaderATI, |
| only the following operations will be compiled into a shader: |
| PassTexCoordATI, SampleMapATI, ColorFragmentOp[1..3]ATI, |
| AlphaFragmentOp[1..3]ATI, and SetFragmentShaderContantATI. |
| |
| In addition to a default fragment shader, named shaders can be |
| created. The namespace for shaders is unsigned integers with zero |
| reserved by the GL. A shader is created by binding an unused name |
| using: |
| |
| void BindFragmentShaderATI(uint id); |
| |
| where <id> is the unused name. Once a shader has been created it |
| can be rebound as the active shader by calling |
| BindFragmentShaderATI. A shader can be deleted, freeing the name, |
| by calling: |
| |
| void DeleteFragmentShaderATI(uint id); |
| |
| where <id> is the name to be deleted. Unique names can be generated |
| using: |
| |
| uint GenFragmentShadersATI(uint range); |
| |
| where <range> is the number of contiguous ids that should be |
| created. It returns an integer n such that <range> contiguous empty |
| shader ids, with values n, n+1, ..., n+<range>-1, are created. If |
| <range> is 0, if there is no group of <range> contiguous names |
| available, or if any error is generated, no shaders are generated, |
| and 0 is returned. |
| |
| If FRAGMENT_SHADER_ATI is enabled, but the currently bound shader is |
| invalid, the results of drawing commands are undefined. A shader |
| may be invalid because it is currently being specified (i.e., a |
| drawing command within a Begin/EndFragmentShader pair), or due to |
| some error during the specification of a shader. |
| |
| There are three types of data that can be in a fragment shader: |
| registers, constants, and interpolators. The 6 REG_x_ATI registers |
| can be used as source or destination in any color or alpha |
| instruction. The final result of the shader is whatever value is in |
| REG_0_ATI. This value will be the final color of the output |
| fragment passed. |
| |
| There are 8 constant registers available, CON_0_ATI through |
| CON_7_ATI. CON_x_ATI constants can be used as source in any color |
| or alpha instruction, but at most 2 different constants may be used |
| as source arguments in each instruction. |
| |
| Additionally, the primary and secondary color interpolators are |
| available as source in any color or alpha instruction, but only in |
| the last pass of the shader (i.e., the only pass of a one-pass |
| shader or the second pass of a two-pass shader). |
| |
| Either one or two passes may be specified in a shader. Each pass |
| may use up to 8 pairs of instructions for a total of at most 16 |
| pairs in the shader. A pair consists of one color instruction and |
| one alpha instruction. |
| |
| The first instructions specified in each pass of a shader are "free" |
| instructions in that they don't count against the 8 instructions |
| available in each pass. They are routing instructions which specify |
| from where the contents of the registers come. The first occurance |
| of one of these free instructions marks the beginning of a pass in |
| the shader. They are specified with SampleMapATI and |
| PassTexCoordATI. |
| |
| The entry point: |
| |
| void PassTexCoordATI (uint dst, uint coord, enum swizzle); |
| |
| specifies that the value present in <coord> is passed directly into |
| the contents of <dst> (one of the registers REG_x_ATI). This value |
| is then available for use as a source argument to subsequent color |
| and alpha instructions following in the same pass. <coord> may |
| either be the texture coordinates on a texture unit (TEXTUREx_ARB), |
| or in the case of a two-pass shader's second pass, it may be the |
| value of a register set in the first pass (REG_x_ATI). |
| |
| Note that in order to preserve the contents of a register from the |
| first pass to the second, there must be a PassTexCoordATI |
| instruction in the setup for the second pass that assigns that |
| register to itself. For example: |
| |
| PassTexCoordATI(REG_1_ATI, REG_1_ATI, SWIZZLE_STR_ATI); |
| |
| will preserve the first 3 components of REG_1_ATI for use in the |
| second pass. |
| |
| The entry point: |
| |
| void SampleMapATI (uint dst, uint interp, enum swizzle); |
| |
| specifies that the value present in the texture data bound on the |
| unit associated with <dst> will be written to that register. A |
| value for <dst> of REG_x_ATI means that TEXTUREx_ARB will be |
| sampled, and the result written to REG_x_ATI. The <interp> |
| parameter specifies which texture coordinate interpolator is used to |
| sample the map. A value of REG_x_ATI for <interp> in the second |
| pass of a two-pass shader will do dependent texture read sampling |
| using the value in register x. Otherwise, specifying TEXTUREx_ARB |
| will sample the map using the texture coordinates on unit x. |
| |
| Only the first 3 components of <coord> or <interp> are used in |
| PassTexCoordATI and SampleMapATI, respectively. The swizzle |
| parameter is used to select which of the 4 original components of |
| the source register or texture coordinates will be mapped to the 3 |
| available positions, and whether or not a projection will occur. |
| |
| Table 3.20 shows the <swizzle> modes: |
| |
| |
| Coordinates Used for 1D or Coordinates Used for |
| Swizzle 2D SampleMap and PassTexCoord 3D or cubemap SampleMap |
| ------- ----------------------------- ----------------------- |
| SWIZZLE_STR_ATI (s, t, r, undefined) (s, t, r, undefined) |
| SWIZZLE_STQ_ATI (s, t, q, undefined) (s, t, q, undefined) |
| SWIZZLE_STR_DR_ATI (s/r, t/r, 1/r, undefined) (undefined) |
| SWIZZLE_STQ_DQ_ATI (s/q, t/q, 1/q, undefined) (undefined) |
| |
| Table 3.20 Coordinate swizzles |
| |
| |
| Each texture coordinate source (TEXTUREx_ARB) used as a <coord> |
| and/or <interp> can only draw upon STR or STQ components throughout |
| the shader. For example, if TEXTURE2_ARB is used in a SampleMapATI |
| with <swizzle> SWIZZLE_STR_ATI, it cannot be used again later with a |
| <swizzle> of SWIZZLE_STQ_ATI. The projection, however, may vary. |
| It would be okay to later use TEXTURE2_ARB with a <swizzle> of |
| SWIZZLE_STR_DR_ATI. |
| |
| Additionally, when the <coord> or <interp> is a register (in the |
| second pass of a two-pass shader), only SWIZZLE_STR_ATI and |
| SWIZZLE_STR_DR_ATI are allowed. Note that if this is a |
| PassTexCoord, the fourth component (alpha channel if the register |
| contains RGBA) is not passed along and the fourth component of <dst> |
| becomes undefined. |
| |
| The color and alpha instructions performed in the shader are |
| specified with the following entry points: |
| |
| void ColorFragmentOp1ATI (enum op, uint dst, uint dstMask, uint dstMod, |
| uint arg1, uint arg1Rep, uint arg1Mod); |
| void ColorFragmentOp2ATI (enum op, uint dst, uint dstMask, uint dstMod, |
| uint arg1, uint arg1Rep, uint arg1Mod, |
| uint arg2, uint arg2Rep, uint arg2Mod); |
| void ColorFragmentOp3ATI (enum op, uint dst, uint dstMask, uint dstMod, |
| uint arg1, uint arg1Rep, uint arg1Mod, |
| uint arg2, uint arg2Rep, uint arg2Mod, |
| uint arg3, uint arg3Rep, uint arg3Mod); |
| void AlphaFragmentOp1ATI (enum op, uint dst, uint dstMod, |
| uint arg1, uint arg1Rep, uint arg1Mod); |
| void AlphaFragmentOp2ATI (enum op, uint dst, uint dstMod, |
| uint arg1, uint arg1Rep, uint arg1Mod, |
| uint arg2, uint arg2Rep, uint arg2Mod); |
| void AlphaFragmentOp3ATI (enum op, uint dst, uint dstMod, |
| uint arg1, uint arg1Rep, uint arg1Mod, |
| uint arg2, uint arg2Rep, uint arg2Mod, |
| uint arg3, uint arg3Rep, uint arg3Mod); |
| |
| A ColorFragmentOp[1..3]ATI followed by an AlphaFragmentOp[1..3]ATI |
| is considered to be an instruction pair, and 8 such pairs may be |
| specified per pass. The color and alpha instructions of a pair are |
| executed in parallel: the result of the color instruction cannot |
| affect the source arguments of the alpha instruction. Both a color |
| and an alpha instruction need not be specified for every pair; the |
| necessary color or alpha no-op is automatically inserted by the GL |
| to complete each instruction pair. |
| |
| The <op> parameter specifies the instruction to perform on the |
| sources. |
| |
| Table 3.21 shows the effect of each <op>. R(d), G(d), and B(d) are |
| the destination values when using the instruction on color and A(d) |
| is the destination value when using the instruction on alpha. |
| |
| |
| Op Result |
| -- ------ |
| ADD_ATI R(d) = R(a1) + R(a2) |
| G(d) = G(a1) + G(a2) |
| B(d) = B(a1) + B(a2) |
| A(d) = A(a1) + A(a2) |
| |
| SUB_ATI R(d) = R(a1) - R(a2) |
| G(d) = G(a1) - G(a2) |
| B(d) = B(a1) - B(a2) |
| A(d) = A(a1) - A(a2) |
| |
| MUL_ATI R(d) = R(a1) * R(a2) |
| G(d) = G(a1) * G(a2) |
| B(d) = B(a1) * B(a2) |
| A(d) = A(a1) * A(a2) |
| |
| MAD_ATI R(d) = R(a1) * R(a2) + R(a3) |
| G(d) = G(a1) * G(a2) + G(a3) |
| B(d) = B(a1) * B(a2) + B(a3) |
| A(d) = A(a1) * A(a2) + A(a3) |
| |
| LERP_ATI*** R(d) = R(a1) * R(a2) + (1 - R(a1)) * R(a3) |
| G(d) = G(a1) * G(a2) + (1 - G(a1)) * G(a3) |
| B(d) = B(a1) * B(a2) + (1 - B(a1)) * B(a3) |
| A(d) = A(a1) * A(a2) + (1 - A(a1)) * A(a3) |
| |
| MOV_ATI R(d) = R(a1) |
| G(d) = G(a1) |
| B(d) = B(a1) |
| A(d) = A(a1) |
| |
| CND_ATI R(d) = (R(a3) > 0.5) ? R(a1) : R(a2) |
| G(d) = (G(a3) > 0.5) ? G(a1) : G(a2) |
| B(d) = (B(a3) > 0.5) ? B(a1) : B(a2) |
| A(d) = (A(a3) > 0.5) ? A(a1) : A(a2) |
| |
| CND0_ATI R(d) = (R(a3) >= 0) ? R(a1) : R(a2) |
| G(d) = (G(a3) >= 0) ? G(a1) : G(a2) |
| B(d) = (B(a3) >= 0) ? B(a1) : B(a2) |
| A(d) = (A(a3) >= 0) ? A(a1) : A(a2) |
| |
| DOT2_ADD_ATI* R(d) = G(d) = B(d) = A(d) = R(a1) * R(a2) + |
| G(a1) * G(a2) + |
| B(a3) |
| |
| DOT3_ATI* R(d) = G(d) = B(d) = A(d) = R(a1) * R(a2) + |
| G(a1) * G(a2) + |
| B(a1) * B(a2) |
| |
| DOT4_ATI* ** R(d) = G(d) = B(d) = A(d) = R(a1) * R(a2) + |
| G(a1) * G(a2) + |
| B(a1) * B(a2) + |
| A(a1) * A(a2) |
| |
| Table 3.21 Color and Alpha Fragment Shader Instructions |
| |
| Special Notes: |
| * - DOT2_ADD_ATI/DOT3_ATI/DOT4_ATI can only be specified as |
| an alpha instruction directly after being specified as |
| a color instruction. When specified as an alpha |
| instruction, the parameters are ignored, although they |
| should be valid enumerants in order to compile. The |
| result of the color instruction will simply be placed |
| in the alpha <dst>. |
| |
| ** - After a DOT4_ATI color instruction is specified, the |
| only alpha instruction that can immediately follow is a |
| DOT4_ATI. This is because the DOT4 color instruction |
| implicitely uses an alpha instruction to calculate the |
| result. If another type of alpha instruction is |
| desired after a DOT4_ATI color instruction is issued, |
| there are two choices: either issue another color |
| instruction first, or issue the DOT4_ATI alpha |
| instruction followed by the desired alpha instruction. |
| |
| *** - The blend factor (a1) of LERP_ATI must be in the range |
| [0,1] or the results are undefined. |
| |
| The <dst> parameter specifies to which register (REG_x_ATI) the |
| result of the instruction is written. |
| |
| The <dstMask> parameter specifies which of the color components in |
| <dst> will be written (ColorFragmentOp[1..3]ATI only). This can |
| either be NONE, in which case there is no mask and everything is |
| written, or the bitwise-or of RED_BIT_ATI, GREEN_BIT_ATI, and |
| BLUE_BIT_ATI. |
| |
| The <dstMod> parameter specifies which modifications are performed |
| on each component of the destination. The result can be modulated |
| by specifying either 2X_BIT_ATI, 4X_BIT_ATI, 8X_BIT_ATI, |
| HALF_BIT_ATI, QUARTER_BIT_ATI, or EIGHTH_BIT_ATI. These are all |
| mutually exclusive, and can optionally be bitwise-or'd with |
| SATURATE_BIT_ATI, which clamps the result after any modulation |
| occurs. |
| |
| Table 3.22 shows the result of each <dstMod> modification. |
| |
| |
| Modifier Result |
| -------- ------ |
| NONE d = d |
| 2X_BIT_ATI d = 2 * d |
| 4X_BIT_ATI d = 4 * d |
| 8X_BIT_ATI d = 8 * d |
| HALF_BIT_ATI d = d / 2 |
| QUARTER_BIT_ATI d = d / 4 |
| EIGHTH_BIT_ATI d = d / 8 |
| SATURATE_BIT_ATI d = clamp(d) to range [0, 1] |
| |
| Table 3.22 Result of destination modification |
| |
| |
| Note that the internal precision of the fragment shader allows |
| values in the range [-8, 8]. |
| |
| The <argN> parameter specifies the source argument. The source can |
| come from REG_x_ATI, CON_x_ATI, ZERO, ONE, PRIMARY_COLOR_ARB, or |
| SECONDARY_INTERPOLATOR_ATI. Note that in a two-pass shader, |
| PRIMARY_COLOR_ARB and SECONDARY_INTERPOLATOR_ATI cannot be used in |
| the first pass of the shader. |
| |
| Each argument has an <argNRep> parameter which specifies the |
| replication of each component. |
| |
| Table 3.23 shows the result of each <argNRep> source replication. |
| |
| |
| Replication Result |
| ----------- ----- |
| NONE R(s) = R(s) |
| G(s) = G(s) |
| B(s) = B(s) |
| A(s) = A(s) |
| |
| RED R(s) = R(s) |
| G(s) = R(s) |
| B(s) = R(s) |
| A(s) = R(s) |
| |
| GREEN R(s) = G(s) |
| G(s) = G(s) |
| B(s) = G(s) |
| A(s) = G(s) |
| |
| BLUE R(s) = B(s) |
| G(s) = B(s) |
| B(s) = B(s) |
| A(s) = B(s) |
| |
| ALPHA R(s) = A(s) |
| G(s) = A(s) |
| B(s) = A(s) |
| A(s) = A(s) |
| |
| Table 3.23 Result of source replication |
| |
| |
| Each argument also has an <argNMod> parameter which specifies |
| modifiers to each component. A value of NONE specifies that no |
| modifiers are present. Otherwise, the bitwise-or of NEGATE_BIT_ATI, |
| BIAS_BIT_ATI, and 2X_BIT_ATI can be specified as modifiers. |
| |
| Table 3.24 shows the result of each <argNMod> source modifier. |
| |
| |
| Modifier Result |
| -------- ------ |
| NONE s = s |
| NEGATE_BIT_ATI s = -s |
| COMP_BIT_ATI s = 1 - s |
| BIAS_BIT_ATI s = s - 0.5 |
| 2X_BIT_ATI s = 2 * s |
| |
| Table 3.24 Result of source modification |
| |
| |
| If multiple source modifiers are applied, the order of operations is |
| COMP, BIAS, SCALE, then NEGATE. The following equation shows the |
| order of operations if all modifiers were to be applied: |
| |
| s = -(2 * ((1.0 - s) - 0.5)) |
| |
| In order to set the constants that can be used by shader |
| instructions, the entry point: |
| |
| void SetFragmentShaderConstantATI (uint dst, const float *value); |
| |
| is used. The <dst> parameter specifies which of the constants |
| (CON_x_ATI) to set. The <value> pointer must contain four floating |
| point values in the range [0, 1] to set the components of the |
| constant. Constant registers loaded with floating point values |
| outside of this range will have undefined values. Calls to this |
| function which occur inside a shader definition are automatically |
| bound when the shader is bound. This means that shader constants |
| have scope: if SetFragmentShaderConstantATI is called outside a |
| shader definition, it is bound globally. However, if that same |
| shader constant is set inside the shader, it overrides the global |
| definition when bound. |
| |
| |
| Additions to Chapter 4 of the OpenGL 1.2.1 Specification (Per-Fragment |
| Operations and the Framebuffer) |
| |
| None |
| |
| |
| Additions to Chapter 5 of the OpenGL 1.2.1 Specification (Special |
| Functions) |
| |
| Modify Section 5.4, Display Lists (p. 175) |
| |
| (modify last paragraph, p. 178) ... These are: IsList, GenLists, |
| ..., GenFragmentShadersATI, DeleteFragmentShadersATI, |
| BeginFragmentShaderATI, EndFragmentShaderATI, PassTexCoordATI, |
| SampleMapATI, ColorFragmentOp[1..3]ATI, AlphaFragmentOp[1..3]ATI, |
| as well as IsEnabled and all of the Get commands (see Chapter 6). |
| |
| |
| Additions to Chapter 6 of the OpenGL 1.2.1 Specification (State and |
| State Requests) |
| |
| None |
| |
| |
| Additions to Appendix A of the OpenGL 1.2.1 Specification (Invariance) |
| |
| None |
| |
| |
| Additions to the AGL/GLX/WGL Specifications |
| |
| None |
| |
| |
| Interactions with ARB_shadow |
| |
| The texture comparison introduced by ARB_shadow can be expressed in |
| terms of a fragment shader, and in fact use the same internal |
| resources on some implementations. Therefore, if fragment shader |
| mode is enabled, the GL behaves as if TEXTURE_COMPARE_MODE_ARB is |
| NONE. |
| |
| |
| Errors |
| |
| The error INVALID_VALUE is generated if GenFragmentShadersATI is |
| called where <range> is zero. |
| |
| The error INVALID_OPERATION is generated if GenFragmentShadersATI, |
| BindFragmentShaderATI, DeleteFragmentShaderATI, or |
| BeginFragmentShaderATI are specified inside a |
| Begin/EndFragmentShaderATI pair. |
| |
| The error INVALID_OPERATION is generated if EndFragmentShaderATI, |
| PassTexCoordATI, SampleMapATI, ColorFragmentOp[1..3]ATI, or |
| AlphaFragmentOp[1..3]ATI is specified outside a |
| Begin/EndFragmentShaderATI pair. |
| |
| The error INVALID_OPERATION is generated by EndFragmentShaderATI if |
| <argN> passed to ColorFragmentOp[1..3]ATI or |
| AlphaFragmentOp[1..3]ATI is PRIMARY_COLOR_ARB or |
| SECONDARY_INTERPOLATOR_ATI on the first pass of a two-pass shader, |
| or if the shader cannot be compiled due to some other |
| implementation-dependent limitation. EndFragmentShaderATI will |
| still have a side-effect if this error is encountered: the |
| Begin/EndFragmentShaderATI pair will be closed, and the current |
| shader will be undefined. |
| |
| The error INVALID_OPERATION is generated by PassTexCoordATI or |
| SampleMapATI if two shader passes have already been specified, or if |
| the same <dst> register is specified twice in the same pass. |
| |
| The error INVALID_OPERATION is generated by PassTexCoordATI or |
| SampleMapATI if <coord> passed to PassTexCoordATI or <interp> passed |
| to SampleMapATI is a register in the first pass, or a register with |
| SWIZZLE_STQ_ATI or SWIZZLE_STQ_DQ_ATI <swizzle> in the second pass, |
| or if different <swizzle> parameters are specified for the same |
| <coord> or <interp> in the same pass. |
| |
| The error INVALID_OPERATION is generated by ColorFragmentOp[1..3]ATI |
| or AlphaFragmentOp[1..3]ATI if more than 8 instructions have been |
| specified for a shader pass. |
| |
| The error INVALID_OPERATION is generated by ColorFragmentOp[1..3]ATI |
| if <argN> is SECONDARY_INTERPOLATOR_ATI and <argNRep> is ALPHA, or |
| by AlphaFragmentOp[1..3]ATI if <argN> is SECONDARY_INTERPOLATOR_ATI |
| and <argNRep> is ALPHA or NONE, or by ColorFragmentOp2ATI if <op> is |
| DOT4_ATI and <argN> is SECONDARY_INTERPOLATOR_ATI and <argNRep> is |
| ALPHA or NONE. |
| |
| The error INVALID_OPERATION is generated by ColorFragmentOp3ATI or |
| AlphaFragmentOp3ATI if all three <argN> parameters are constants, |
| and all three are different. |
| |
| The error INVALID_OPERATION is generated by AlphaFragmentOp[2..3]ATI |
| if <op> is DOT3_ATI, DOT4_ATI, or DOT2_ADD_ATI and there was no |
| matching ColorFragmentOp[2..3]ATI immediately preceding, or if <op> |
| is not DOT4_ATI and the immediately preceding ColorFragmentOp2ATI |
| specifies an <op> of DOT4_ATI. |
| |
| The error INVALID_ENUM is generated if <dst> passed to |
| PassTexCoordATI, SampleMapATI, ColorFragmentOp[1..3]ATI, or |
| AlphaFragmentOp[1..3]ATI is not a valid register or is greater than |
| the number of texture units available on the implementation. |
| |
| The error INVALID_ENUM is generated if <coord> passed to |
| PassTexCoordATI or <interp> passed to SampleMapATI is not a valid |
| register or texture unit, or the register or texture unit is greater |
| than the number of texture units available on the implementation. |
| |
| The error INVALID_ENUM is generated if <argN> passed to |
| ColorFragmentOp[1..3]ATI or AlphaFragmentOp[1..3]ATI is not a valid |
| constant, interpolator, or register. |
| |
| The error INVALID_ENUM is generated if <dstMod> passed to |
| ColorFragmentOp[1..3]ATI or AlphaFragmentOp[1..3]ATI contains |
| multiple mutually exclusive modifier bits, not counting |
| SATURATE_BIT_ATI. |
| |
| |
| New State |
| |
| Initial |
| Get Value Type Get Command Value Description Sec. Attribute |
| --------- ---- ----------- ------- ----------- ------ --------- |
| FRAGMENT_SHADER_ATI B IsEnabled False Fragment shader enable 3.8.11 enable |
| |
| Table X.6. New Accessible State Introduced by ATI_fragment_shader. |
| |
| |
| Get Value Type Get Command Initial Value Description Sec Attribute |
| --------- ------ ----------- ------------- ------------------- ------ --------- |
| - 6xR4 - undefined temporary registers 3.8.11 - |
| |
| Table X.9. Fragment Shader Per-fragment Execution State. All per-fragment |
| execution state registers are uninitialized at the beginning of program |
| execution. |
| |
| |
| New Implementation Dependent State |
| |
| None |
| |
| |
| Deprecated Functionality |
| |
| The following queryable implementation-dependent constants are |
| described here for backward-compatibility. They are now specified |
| to always return fixed values on all implementations, and are thus |
| obsolete. |
| |
| The number of available registers can be queried by doing a glGet on |
| NUM_FRAGMENT_REGISTERS_ATI. This refers to the number of |
| REG_x_ATI's, and is now fixed at 6. |
| |
| The number of available constants can be queried by doing a glGet on |
| NUM_FRAGMENT_CONSTANTS. This refers to the number of CON_x_ATI's, |
| and is now fixed at 8. |
| |
| The number of passes, instructions per pass, and total instructions |
| available to a shader can be queried using glGet. Querying for |
| NUM_PASSES_ATI returns the maximum number of passes that the shader |
| can perform, now fixed at 2. Querying for |
| NUM_INSTRUCTIONS_PER_PASS_ATI returns the maximum number of |
| instructions available on a given pass, now fixed at 8. Finally, |
| NUM_INSTRUCTIONS_TOTAL_ATI returns the maximum number of total |
| instructions available to a shader, now fixed at 16 (2 per pass). |
| |
| COLOR_ALPHA_PAIRING_ATI can be queried by glGet to determine if each |
| ColorFragmentOp[1..3]ATI/AlphaFragmentOp[1..3]ATI pair counts as one |
| instruction against the limit, or if each color and alpha |
| instruction is counted individually (i.e., each pair counts as two |
| instructions). This query now always returns TRUE: each pair counts |
| as one instruction against the 8 instructions allowed per pass. |
| |
| The number of components available in a coordinate interpolator, |
| passed in as <interp> to SampleMapATI or <coord> to PassTexCoord, |
| can be queried using NUM_INTERPOLATOR_COMPONENTS_ATI. This query |
| now always returns 3, meaning the fourth component is ignored. |
| |
| The number of components passed in the registers via PassTexCoord |
| from the first pass to the second can be queried using |
| NUM_LOOPBACK_COMPONENTS_ATI. This query now always returns 3, |
| meaning the fourth component of <dst> is undefined. |
| |
| |
| Sample Usage |
| |
| The following is an example that simulates a chrome surface: |
| |
| shadername = glGenFragmentShadersATI(1); |
| glBindFragmentShaderATI(shadername); |
| glBeginFragmentShaderATI(); |
| |
| // Pass 1 |
| glPassTexCoordATI(GL_REG_1_ATI, GL_TEXTURE1_ARB, GL_SWIZZLE_STR_ATI); // N |
| glPassTexCoordATI(GL_REG_2_ATI, GL_TEXTURE2_ARB, GL_SWIZZLE_STR_ATI); // light to vertex vector in light space |
| glPassTexCoordATI(GL_REG_3_ATI, GL_TEXTURE3_ARB, GL_SWIZZLE_STR_ATI); // H |
| glSampleMapATI(GL_REG_4_ATI, GL_TEXTURE4_ARB, GL_SWIZZLE_STR_ATI); // L (sample cubemap normalizer) |
| |
| // reg4 = N.L |
| glColorFragmentOp2ATI(GL_DOT3_ATI, GL_REG_4_ATI, GL_NONE, GL_NONE, |
| GL_REG_1_ATI, GL_NONE, GL_NONE, |
| GL_REG_4_ATI, GL_NONE, GL_2X_BIT_ATI|GL_BIAS_BIT_ATI); |
| |
| // reg1 = N.H |
| glColorFragmentOp2ATI(GL_DOT3_ATI, GL_REG_1_ATI, GL_NONE, GL_NONE, |
| GL_REG_1_ATI, GL_NONE, GL_NONE, |
| GL_REG_3_ATI, GL_NONE, GL_NONE); |
| |
| // reg1(green) = H.H (aka |H|^2) |
| glColorFragmentOp2ATI(GL_DOT3_ATI, GL_REG_1_ATI, GL_GREEN_BIT_ATI, GL_NONE, |
| GL_REG_3_ATI, GL_NONE, GL_NONE, |
| GL_REG_3_ATI, GL_NONE, GL_NONE); |
| |
| // reg2 = |light to vertex|^2 |
| glColorFragmentOp2ATI(GL_DOT3_ATI, GL_REG_2_ATI, GL_NONE, GL_NONE, |
| GL_REG_2_ATI, GL_NONE, GL_NONE, |
| GL_REG_2_ATI, GL_NONE, GL_NONE); |
| |
| // Pass 2 |
| glSampleMapATI(GL_REG_0_ATI, GL_TEXTURE5_ARB, GL_SWIZZLE_STR_ATI); // sample enviroment map using eye vector |
| glSampleMapATI(GL_REG_2_ATI, GL_REG_2_ATI, GL_SWIZZLE_STR_ATI); // sample attenuation map |
| glSampleMapATI(GL_REG_3_ATI, GL_REG_1_ATI, GL_SWIZZLE_STR_ATI); // sample specular NHHH map = (N.H)^256 |
| glPassTexCoordATI(GL_REG_4_ATI, GL_REG_4_ATI, GL_SWIZZLE_STR_ATI); // pass N.L through |
| |
| // reg3 = (N.H)^256 * (N.L) |
| // this ensures a pixel is only lit if facing the light (since the specular exponent |
| // makes negative N.H positive we must do this) |
| glColorFragmentOp2ATI(GL_MUL_ATI, GL_REG_3_ATI, GL_NONE, GL_NONE, |
| GL_REG_3_ATI, GL_NONE, GL_NONE, |
| GL_REG_4_ATI, GL_NONE, GL_NONE); |
| |
| // reg3 = specular * environment map |
| glColorFragmentOp2ATI(GL_MUL_ATI, GL_REG_3_ATI, GL_NONE, GL_NONE, |
| GL_REG_0_ATI, GL_NONE, GL_NONE, |
| GL_REG_3_ATI, GL_NONE, GL_NONE); |
| |
| // reg4 = diffuse * environment map |
| glColorFragmentOp2ATI(GL_MUL_ATI, GL_REG_4_ATI, GL_NONE, GL_NONE, |
| GL_REG_0_ATI, GL_NONE, GL_NONE, |
| GL_REG_4_ATI, GL_NONE, GL_NONE); |
| |
| // reg0 = (specular * environment map) + (diffuse * environment map) |
| glColorFragmentOp2ATI(GL_ADD_ATI, GL_REG_0_ATI, GL_NONE, GL_NONE, |
| GL_REG_3_ATI, GL_NONE, GL_NONE, |
| GL_REG_4_ATI, GL_NONE, GL_NONE); |
| |
| // apply point light attenuation |
| glColorFragmentOp2ATI(GL_MUL_ATI, GL_REG_0_ATI, GL_NONE, GL_SATURATE_BIT_ATI, |
| GL_REG_0_ATI, GL_NONE, GL_NONE, |
| GL_REG_2_ATI, GL_RED, GL_NONE); |
| glEndFragmentShaderATI(); |
| |
| |
| Revision History |
| |
| Date: 11/4/2006 |
| Revision: 1.8 |
| - Updated contact info after ATI/AMD merger. |
| |
| Date: 8/21/2002 |
| Revision: 1.7 |
| - Fixed lack of comma typo in glAlphaFragmentOp2ATI prototypes. |
| |
| Date: 8/1/2002 |
| Revision: 1.6 |
| - Changed DeleteFragmentShaderATI behavior to silently ignore the |
| deletion of non-existent or default shaders. |
| |
| Date: 6/5/2002 |
| Revision: 1.5 |
| - Added interaction with ARB_shadow. |
| |
| Date: 5/30/2002 |
| Revision: 1.4 |
| - Specified that LERP's blend factor must be in the range [0,1]. |
| - Added error condition when trying to use secondary color in DOT4 |
| color instruction when replication is GL_NONE or GL_ALPHA. |
| |
| Date: 5/21/2002 |
| Revision: 1.3 |
| - Made number of registers (REG_x_ATI) explicit: 6. |
| - Changed CND0_ATI definition from >0 to >=0. |
| - Added wording to emphasize [0,1] range for constants. |
| - Added wording to reflect that EndFragmentShaderATI will close |
| Begin/End pair even if error is encountered. |
| - Added wording to reflect parallelism of color/alpha pairs. |
| - Added error condition when trying to use secondary color alpha. |
| - Added error condition when generating shader IDs with <range> 0. |
| - Added display list exclusion for everything except |
| BindFragmentShaderATI and SetFragmentShaderConstantATI. |
| - Cleaned up, fixed typos, and reformatted. |
| - Added New State section. |
| - Replaced sample code. |
| |
| Date: 4/19/2002 |
| Revision: 1.2 |
| - Updated swizzle table to indicate that projected texcoords are |
| undefined when used in conjunction with cubemaps or 3D textures. |
| |
| Date: 3/20/2002 |
| Revision: 1.1 |
| - Made resource availability explicit. |
| - Deprecated implementation-dependent constant queries. |
| - Added various error conditions described in prose of spec. |
| - Changed PRIMARY_COLOR_EXT to PRIMARY_COLOR_ARB. |
| - Cleaned up and fixed typos throughout. |
| |
| Date: 1/2/2002 |
| Revision: 1.02 |
| - Added note that PRIMARY_COLOR_EXT and SECONDARY_INTERPOLATOR_ATI can not |
| be used on the first pass of a two pass shader. Also added error |
| for this case to Errors section. |
| - Added note that in order to save the contents of a register from the |
| first pass to the second, there has to be a PassTexCoordATI() on that |
| register to itself on the next pass. |
| - Changed PRIMARY_COLOR to PRIMARY_COLOR_EXT. |
| |
| Date: 10/15/2001 |
| Revision: 1.01 |
| - Fixed typos in example program. |
| - Added language about the shader result being placed in REG_0_ATI. |
| - Specify range supported [-8..8]. |
| - Added notes on how to specify whether DOT4/DOT3/DOT2_ADD result |
| goes to alpha channel. |
| |
| Date: 8/21/2001 |
| Revision: 1.0 |
| - Added equation for source modifiers. |
| |
| Date: 8/6/2001 |
| Revision: 0.6 |
| - Added restraint that only SWIZZLE_STR_ATI and SWIZZLE_STR_DR_ATI |
| can be used on the second pass when the source is a register. |
| |
| Date: 6/29/2001 |
| Revision: 0.5 |
| - Removed glTexProjectATI and change glSampleMapATI/glPassTexCoordATI to |
| take a <swizzle> parameter instead of <project>. |
| - Changed MAD_ATI from (a + b * c) to (a * b + c). |
| |
| Date: 6/11/2001 |
| Revision: 0.4 |
| - Removed FRAC_ATI. |
| - Added <project> parameter to SampleMapATI and PassTexCoordATI to |
| match current implementation. |
| |
| Date: 5/01/2001 |
| Revision: 0.3 |
| - Added COLOR_ALPHA_PAIRING_ATI. |
| - Attempted to clarify definition of SampleMapATI in the documentation |
| section. Changed <map> to <interp>. |
| - Added TexProjectATI and documented texture projection modes to allow |
| implementations that only support 3-tuples to select between (s, t, r) |
| and (s, t, q) coordinates. |
| |
| Date: 4/19/2001 |
| Revision: 0.2 |
| - Removed <dstRot> from ColorFragmentOp[1..3]ATI. |
| - Changed SHADER_ATI to FRAGMENT_SHADER_ATI. |
| - Fixed the <op>'s in the New Tokens section to go to the proper |
| Color/AlphaOp functions. |
| - Added ZERO and ONE constants. |
| - Made number of passes queryable: removed NUM_PASSn_INSTRUCTIONS_ATI, |
| replaced with NUM_PASSES_ATI, NUM_INSTRUCTIONS_PER_PASS_ATI, and |
| NUM_INSTRUCTIONS_TOTAL_ATI. |
| - Documented when new pass starts (SampleMapATI/PassCoordATI). |
| - Added NUM_INPUT_INTERPOLATOR_COMPONENTS_ATI/NUM_LOOPBACK_COMPONENTS_ATI. |
| - Fixed sample usage to not do a dependent read on the base map. |
| |
| Date: 4/16/2001 |
| Revision: 0.1 |
| - First draft |
