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
|
/*
* Copyright © 2019 Intel Corporation
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice (including the next
* paragraph) shall be included in all copies or substantial portions of the
* Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
* IN THE SOFTWARE.
*/
#ifndef GEN_GUARDBAND_H
#define GEN_GUARDBAND_H
static inline void
gen_calculate_guardband_size(uint32_t fb_width, uint32_t fb_height,
float m00, float m11, float m30, float m31,
float *xmin, float *xmax,
float *ymin, float *ymax)
{
/* According to the "Vertex X,Y Clamping and Quantization" section of the
* Strips and Fans documentation:
*
* "The vertex X and Y screen-space coordinates are also /clamped/ to the
* fixed-point "guardband" range supported by the rasterization hardware"
*
* and
*
* "In almost all circumstances, if an object’s vertices are actually
* modified by this clamping (i.e., had X or Y coordinates outside of
* the guardband extent the rendered object will not match the intended
* result. Therefore software should take steps to ensure that this does
* not happen - e.g., by clipping objects such that they do not exceed
* these limits after the Drawing Rectangle is applied."
*
* I believe the fundamental restriction is that the rasterizer (in
* the SF/WM stages) have a limit on the number of pixels that can be
* rasterized. We need to ensure any coordinates beyond the rasterizer
* limit are handled by the clipper. So effectively that limit becomes
* the clipper's guardband size.
*
* It goes on to say:
*
* "In addition, in order to be correctly rendered, objects must have a
* screenspace bounding box not exceeding 8K in the X or Y direction.
* This additional restriction must also be comprehended by software,
* i.e., enforced by use of clipping."
*
* This makes no sense. Gen7+ hardware supports 16K render targets,
* and you definitely need to be able to draw polygons that fill the
* surface. Our assumption is that the rasterizer was limited to 8K
* on Sandybridge, which only supports 8K surfaces, and it was actually
* increased to 16K on Ivybridge and later.
*
* So, limit the guardband to 16K on Gen7+ and 8K on Sandybridge.
*/
const float gb_size = GEN_GEN >= 7 ? 16384.0f : 8192.0f;
/* Workaround: prevent gpu hangs on SandyBridge
* by disabling guardband clipping for odd dimensions.
*/
if (GEN_GEN == 6 && (fb_width & 1 || fb_height & 1)) {
*xmin = -1.0f;
*xmax = 1.0f;
*ymin = -1.0f;
*ymax = 1.0f;
return;
}
if (m00 != 0 && m11 != 0) {
/* First, we compute the screen-space render area */
const float ss_ra_xmin = MIN3( 0, m30 + m00, m30 - m00);
const float ss_ra_xmax = MAX3( fb_width, m30 + m00, m30 - m00);
const float ss_ra_ymin = MIN3( 0, m31 + m11, m31 - m11);
const float ss_ra_ymax = MAX3(fb_height, m31 + m11, m31 - m11);
/* We want the guardband to be centered on that */
const float ss_gb_xmin = (ss_ra_xmin + ss_ra_xmax) / 2 - gb_size;
const float ss_gb_xmax = (ss_ra_xmin + ss_ra_xmax) / 2 + gb_size;
const float ss_gb_ymin = (ss_ra_ymin + ss_ra_ymax) / 2 - gb_size;
const float ss_gb_ymax = (ss_ra_ymin + ss_ra_ymax) / 2 + gb_size;
/* Now we need it in native device coordinates */
const float ndc_gb_xmin = (ss_gb_xmin - m30) / m00;
const float ndc_gb_xmax = (ss_gb_xmax - m30) / m00;
const float ndc_gb_ymin = (ss_gb_ymin - m31) / m11;
const float ndc_gb_ymax = (ss_gb_ymax - m31) / m11;
/* Thanks to Y-flipping and ORIGIN_UPPER_LEFT, the Y coordinates may be
* flipped upside-down. X should be fine though.
*/
assert(ndc_gb_xmin <= ndc_gb_xmax);
*xmin = ndc_gb_xmin;
*xmax = ndc_gb_xmax;
*ymin = MIN2(ndc_gb_ymin, ndc_gb_ymax);
*ymax = MAX2(ndc_gb_ymin, ndc_gb_ymax);
} else {
/* The viewport scales to 0, so nothing will be rendered. */
*xmin = 0.0f;
*xmax = 0.0f;
*ymin = 0.0f;
*ymax = 0.0f;
}
}
#endif /* GEN_GUARDBAND_H */
|
