1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
|
# Create an 8x8 texture with four miplevels, colored red, green, blue, and
# white, respectively. Draw the following:
#
# .0 .5
#
# miplevel 3 +
#
# miplevel 2 +-+ +-+
# +-+ +-+
#
# miplevel 1 +---+ +---+
# |1.0| |1.5|
# +---+ +---+
#
# +------+ +------+
# miplevel 0 | 0.0 | | 0.5 |
# | | | |
# +------+ +------+
#
#
# The ARB_texture_query_lod spec says:
#
# "The x component of the result vector contains information on the mipmap
# array(s) that would be accessed by a normal texture lookup using the
# same coordinates. If a single level of detail would be accessed, the
# level-of-detail number relative to the base level is returned."
#
# The results of texture() are compared with textureLod() as a sanity check,
# and then the x component of textureQueryLOD() is compared with what we
# calculated to be the LOD when doing linear filtering.
#
# Since this test uses no LOD-biasing, the base level is 0, and the
# ARB_texture_query_lod spec says:
#
# "The computed level of detail lambda_prime (equation 3.19), relative to
# the base level, is returned in the y component of the result vector."
#
# we also check that the y component returned by textureQueryLOD() is equal
# to the x component.
[require]
GLSL >= 1.30
GL_ARB_texture_query_lod
[fragment shader]
#extension GL_ARB_texture_query_lod : enable
uniform sampler2D tex;
uniform float lod;
#define tolerance (1.0/255.0)
#define equal_v4(x,y) all(lessThanEqual(abs((x) - (y)), vec4(tolerance)))
#define equal(x,y) (abs((x) - (y)) <= tolerance)
void main()
{
vec4 frag1 = texture(tex, gl_TexCoord[0].st);
vec4 frag2 = textureLod(tex, gl_TexCoord[0].st, lod);
if (!equal_v4(frag1, frag2)) {
discard;
}
vec2 queried_lod = textureQueryLOD(tex, gl_TexCoord[0].st);
if (!equal(queried_lod.x, queried_lod.y)) {
discard;
}
if (!equal(queried_lod.x, lod)) {
discard;
}
gl_FragColor = frag1;
}
[vertex shader]
void main()
{
gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
gl_TexCoord[0] = gl_MultiTexCoord0;
}
[test]
ortho
clear color 0 0 0 0
clear
uniform int tex 0
texture miptree 0
# Draw the miptree: basic integer LODs.
texparameter 2D min linear_mipmap_linear
texparameter 2D mag linear
uniform float lod 0
draw rect tex 10 10 8 8 0 0 1 1
uniform float lod 1
draw rect tex 10 28 4 4 0 0 1 1
uniform float lod 2
draw rect tex 10 42 2 2 0 0 1 1
uniform float lod 3
draw rect tex 10 54 1 1 0 0 1 1
# Fractional LODs: linear filtering between miplevels
#
# Widths are calculated such that they correspond to fractional LODs. From the
# GL spec (section: Scale Factor and Level of Detail):
#
# lambda_base(x, y) = log2(rho(x, y))
#
# where rho() is the scale factor. Since we're texturing squares, x == y and
# rho(x) is <width of base level> / x. Thus we can solve for x given lambda
# with
# x = <width of base level> / (2^lambda)
uniform float lod 0.5
draw rect tex 28 10 5.65685424949238019521 5.65685424949238019521 0 0 1 1
uniform float lod 1.5
draw rect tex 28 28 2.82842712474619009761 2.82842712474619009761 0 0 1 1
uniform float lod 2.5
draw rect tex 28 42 1.41421356237309504880 1.41421356237309504880 0 0 1 1
# Probes: integer LODs
probe rgb 10 10 1.0 0.0 0.0
probe rgb 10 28 0.0 1.0 0.0
probe rgb 10 42 0.0 0.0 1.0
probe rgb 10 54 1.0 1.0 1.0
# Probes: linear filtering
tolerance 0.05 0.05 0.05 0.05
probe rgb 28 10 0.5 0.5 0.0
probe rgb 28 28 0.0 0.5 0.5
probe rgb 28 42 0.5 0.5 1.0
|
