Name

    SGIS_texture_filter4

Name Strings

    GL_SGIS_texture_filter4

Version

    $Date: 1997/03/24 18:56:21 $ $Revision: 1.9 $

Number

    7

Dependencies

    None

Overview

    This extension allows 1D and 2D textures to be filtered using an
    application-defined, four sample per dimension filter.  (In addition to
    the NEAREST and LINEAR filters defined in the original GL Specification.)
    Such filtering results in higher image quality.  It is defined only
    for non-mipmapped filters.  The filter that is specified must be
    symmetric and separable (in the 2D case).

Issues

    *	What should the default filter function be?
        -   Implementation dependent.

    *	Should this extension define 2-wide texture borders?  Do we really
	want to aggrandize this border stuff :-(
        -   No.

    *	Should this extension define 2D filtering only (and not 1D)?
        -   No.

    *	A GLU function that accepts Mitchell parameters and a texture
	target should be defined.

    *	This specification retains a separate filter function description
	with every texture.  In conjunction with EXT_texture_object, this
	may result in a lot of filter functions.  Implementations should
	optimize for the default filter function to save storage cost.

Reasoning

    *	The name is changed from "cubic" to "filter4" because the table
	allows the specification of filters that are not at all cubic in
	nature.  A true cubic filter extension would define the filter
	function as a cubic polynomial.

New Procedures and Functions

    void TexFilterFuncSGIS(enum target,
			   enum filter,
			   sizei n,
			   const float* weights);

    void GetTexFilterFuncSGIS(enum target,
			      enum filter, 
			      float* weights);

New Tokens

    Accepted by the <param> parameter of TexParameteri and TexParameterf,
    and by the <params> parameter of TexParameteriv and TexParameterfv, when
    their <pname> parameter is TEXTURE_MIN_FILTER or TEXTURE_MAG_FILTER.
    Also accepted by the <filter> parameters of TexFilterFuncSGIS and
    GetTexFilterFuncSGIS:

	FILTER4_SGIS

    Accepted by the <pname> parameter of GetTexParameteriv and
    GetTexParameterfv, when the <target> parameter is TEXTURE_1D or
    TEXTURE_2D:

	TEXTURE_FILTER4_SIZE_SGIS

Additions to Chapter 2 of the GL Specification (OpenGL Operation)

    None

Additions to Chapter 3 of the GL Specification (Rasterization)

    The additional token value FILTER4_SGIS is accepted as an enumerated
    value for the texture minification and magnification filters, causing
    Table 3.7 to be replaced with the table below:

	Name				Type		Legal Values
	----				----		------------
	TEXTURE_WRAP_S			integer		CLAMP, REPEAT
	TEXTURE_WRAP_T			integer		CLAMP, REPEAT
	TEXTURE_WRAP_R_EXT		integer		CLAMP, REPEAT
	TEXTURE_MIN_FILTER		integer		NEAREST, LINEAR,
							NEAREST_MIPMAP_NEAREST,
							NEAREST_MIPMAP_LINEAR,
							LINEAR_MIPMAP_NEAREST,
							LINEAR_MIPMAP_LINEAR,
							FILTER4_SGIS
	TEXTURE_MAG_FILTER		integer		NEAREST, LINEAR,
							FILTER4_SGIS
	TEXTURE_BORDER_COLOR		4 floats	any 4 values in [0,1]

	Table 3.7: Texture parameters and their values.

    Filter4 filtering is specified by calling TexParameteri, TexParameterf,
    TexParameteriv, or TexParameterfv with <pname> set to one of
    TEXTURE_MIN_FILTER or TEXTURE_MAG_FILTER, and <param> or <params> set to
    FILTER4_SGIS.  Because filter4 filtering is defined only for
    non-mipmapped textures, there is no difference between its definition
    for minification and magnification.  First consider the 1-dimensional
    case.  Let T be a computed texture value (one of R_t, G_t, B_t, or A_t).
    Let T[i] be the component value of the texel at location i in a
    1-dimensional texture image.  Then, if the appropriate texture filter
    mode is FILTER4_SGIS, a 4-texel group is selected:


	      /	floor(u - 1/2) mod 2**n,	TEXTURE_WRAP_S is REPEAT
	i1 = (
	      \	floor(u - 1/2),			TEXTURE_WRAP_S is CLAMP


	      /	(i1 + 1) mod 2**n,		TEXTURE_WRAP_S is REPEAT
	i2 = (
	      \	i1 + 1,				TEXTURE_WRAP_S is CLAMP


	      /	(i1 + 2) mod 2**n,		TEXTURE_WRAP_S is REPEAT
	i3 = (
	      \	i1 + 2,				TEXTURE_WRAP_S is CLAMP


	      /	(i1 - 1) mod 2**n,		TEXTURE_WRAP_S is REPEAT
	i0 = (
	      \	i1 - 1,				TEXTURE_WRAP_S is CLAMP


    Let f(x) be the filter weight function of positive distance x.  Let
    
	A = frac(u - 1/2)

    where frac(x) denotes the fractional part of x, and u is the texture
    image coordinate in the s direction, as illustrated in Figure 3.10 of
    the GL Specification.  Then the texture value T is found as

	T = f(1+A) * T[i0] +
	    f(A)   * T[i1] + 
	    f(1-A) * T[i2] +
	    f(2-A) * T[i3]

    If any of the selected T[i] in the above equation refer to a border
    texel with unspecified value, then the border color given by the current
    setting of TEXTURE_BORDER_COLOR is used instead of the unspecified value.

    For 2-dimensional textures the calculations for i0, i1, i2, i3, and A
    are identical to the 1-dimensional case.  A 16-texel group is selected,
    requiring four j values computed as


	      /	floor(v - 1/2) mod 2**m,	TEXTURE_WRAP_T is REPEAT
	j1 = (
	      \	floor(v - 1/2),			TEXTURE_WRAP_T is CLAMP


	      /	(j1 + 1) mod 2**m,		TEXTURE_WRAP_T is REPEAT
	j2 = (
	      \	j1 + 1,				TEXTURE_WRAP_T is CLAMP


	      /	(j1 + 2) mod 2**m,		TEXTURE_WRAP_T is REPEAT
	j3 = (
	      \	j1 + 2,				TEXTURE_WRAP_T is CLAMP


	      /	(j1 - 1) mod 2**m,		TEXTURE_WRAP_T is REPEAT
	j0 = (
	      \	j1 - 1,				TEXTURE_WRAP_T is CLAMP


    Let

	B = frac(v - 1/2)

    where v is the texture image coordinate in the t direction, as
    illustrated in Figure 3.10 of the GL Specification.  Then the texture
    value T is found as

	T = f(1+A) * f(1+B) * T[i0,j0] +
	    f(A)   * f(1+B) * T[i1,j0] + 
	    f(1-A) * f(1+B) * T[i2,j0] +
	    f(2-A) * f(1+B) * T[i3,j0] +
	    f(1+A) * f(B)   * T[i0,j1] +
	    f(A)   * f(B)   * T[i1,j1] + 
	    f(1-A) * f(B)   * T[i2,j1] +
	    f(2-A) * f(B)   * T[i3,j1] +
	    f(1+A) * f(1-B) * T[i0,j2] +
	    f(A)   * f(1-B) * T[i1,j2] + 
	    f(1-A) * f(1-B) * T[i2,j2] +
	    f(2-A) * f(1-B) * T[i3,j2] +
	    f(1+A) * f(2-B) * T[i0,j3] +
	    f(A)   * f(2-B) * T[i1,j3] + 
	    f(1-A) * f(2-B) * T[i2,j3] +
	    f(2-A) * f(2-B) * T[i3,j3]

    If any of the selected T[i,j] in the above equation refer to a border
    texel with unspecified value, then the border color given by the current
    setting of TEXTURE_BORDER_COLOR is used instead of the unspecified value.

    Filter4 texture filtering is currently undefined for 3-dimensional
    textures.

    Filter function
    ---------------

    The default filter function is implementation dependent.  The
    filter function is specified in table format by calling
    TexFilterFuncSGIS with <target> set to TEXTURE_1D or TEXTURE_2D,
    <filter> set to FILTER4_SGIS, and <weights> pointing an array of
    <n> floating point values.  The value <n> must equal 2**m + 1 for
    some nonnegative integer value of m.

    The array <weights> contains samples of the filter function f(x),
    0<=x<=2.  Each element <weights>[i] is the value of
    f((2*i)/(<n>-1)), 0<=i<=<n>-1.
    
    The filter function is stored and used by GL as a set of samples
    f((2*i)/(Size-1)), 0<=i<=Size-1, where Size is an implementation
    dependent constant.  If <n> equals Size, the array <weights> is
    stored directly in GL state.  Otherwise, an implementation
    dependent resampling method is used to compute the stored samples.

    Size must equal 2**m + 1 for some integer value of m greater than
    or equal to 4.  The value Size for texture <target> is returned by
    <params> when GetTexParameteriv or GetTexParameterfv is called
    with <pname> set to TEXTURE_FILTER4_SIZE_SGIS.

    Minification vs. Magnification
    ------------------------------

    If the magnification filter is given by FILTER4_SGIS, and the
    minification filter is given by NEAREST_MIPMAP_NEAREST or
    LINEAR_MIPMAP_NEAREST , then c = 0.5.  The parameter c is used to
    determine whether minification or magnification filtering is done,
    as described in Section 3.8.2 of the GL Specification (Texture
    Magnification).

Additions to Chapter 4 of the GL Specification (Per-Fragment Operations
and the Framebuffer)

    None

Additions to Chapter 5 of the GL Specification (Special Functions)

    GetTexFilterFuncSGIS is not included in display lists.

Additions to Chapter 6 of the GL Specification (State and State Requests)

    The filter weights for the filter4 filter associated with a
    texture are queried by calling GetTexFilterFuncSGIS with <target>
    set to the texture target and <filter> set to FILTER4_SGIS.  The
    Size weight values are returned in the array <weights>, which must
    have at least Size elements.  The value Size is an implementation
    dependent constant that is queried by the application by calling
    GetTexParameteriv or GetTexParameterfv as described above.

Additions to the GLX Specification

    None

GLX Protocol

    Two new GL commands are added.

    The following rendering command is sent to the server as part of
    a glXRender request:

        TexFilterFuncSGIS
            2           16*4n           rendering command length
            2           2064            rendering command opcode
            4           ENUM            target
            4           ENUM            filter
            4           INT32           n
            n           LISTofFLOATS    weights

    The remaining command is a non-rendering command and as such, is
    sent separately (i.e., not as part of a glXRender or glXRenderLarge
    request), using the glXVendorPrivateWithReply request:

	GetTexFilterFuncSGIS
            1           CARD8           opcode (X assigned)
            1           17              GLX opcode (glXVendorPrivateWithReply)
            2           5               request length
            4           4101            vendor specific opcode
            4           GLX_CONTEXT_TAG context tag
            4           ENUM            target
            4           ENUM            filter
          =>
            1           1               reply
            1                           unused
            2           CARD16          sequence number
            4           m               reply length, m = (n==1 ? 0 : n)
            4                           unused
            4           CARD32          n

            if (n=1) this follows:

            4           FLOAT32         params
            12                          unused

            otherwise this follows:

            16                          unused
            n*4         LISTofFLOAT32   params

        Note that n may be zero, indicating that a GL error occurred. 

Errors

    INVALID_ENUM is generated if TexFilterFuncSGIS or
    GetTexFilterFuncSGIS parameter <target> is not TEXTURE_1D or
    TEXTURE_2D.

    INVALID_ENUM is generated if TexFilterFuncSGIS or
    GetTexFilterFuncSGIS parameter <filter> is not FILTER4_SGIS.

    INVALID_VALUE is generated if TexFilterFuncSGIS parameter <n> does
    not equal 2**m + 1 for some nonnegative integer value of m.

    INVALID_ENUM is generated if GetTexParameteriv or GetTexParameterfv
    parameter <pname> is TEXTURE_FILTER4_SIZE_SGIS and parameter
    <target> is not TEXTURE_1D or TEXTURE_2D.

    INVALID_OPERATION is generated if TexFilterFuncSGIS or
    GetTexFilterFuncSGIS is executed between execution of Begin and the
    corresponding execution of End.

New State

    Get Value			Get Command		Type		Value		Attrib
    ---------			-----------		----		-------		------
    TEXTURE_FILTER4_FUNC_SGIS	GetTexFilterFuncSGIS	2 x Size x R	see text	texture

New Implementation Dependent State
								Minimum
    Get Value			Get Command		Type	Value
    ---------			-----------		----	-------
    TEXTURE_FILTER4_SIZE_SGIS	GetTexParameterfv	R	17