1 /*
2 * Copyright © 2009 Intel Corporation
3 *
4 * Permission is hereby granted, free of charge, to any person obtaining a
5 * copy of this software and associated documentation files (the "Software"),
6 * to deal in the Software without restriction, including without limitation
7 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
8 * and/or sell copies of the Software, and to permit persons to whom the
9 * Software is furnished to do so, subject to the following conditions:
10 *
11 * The above copyright notice and this permission notice (including the next
12 * paragraph) shall be included in all copies or substantial portions of the
13 * Software.
14 *
15 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
18 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
20 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
21 * IN THE SOFTWARE.
22 *
23 * Authors:
24 * Eric Anholt <eric@anholt.net>
25 *
26 */
27
28 #include "brw_context.h"
29 #include "brw_state.h"
30 #include "brw_defines.h"
31 #include "intel_batchbuffer.h"
32 #include "main/fbobject.h"
33 #include "main/framebuffer.h"
34 #include "main/viewport.h"
35
36 void
brw_calculate_guardband_size(const struct gen_device_info * devinfo,uint32_t fb_width,uint32_t fb_height,float m00,float m11,float m30,float m31,float * xmin,float * xmax,float * ymin,float * ymax)37 brw_calculate_guardband_size(const struct gen_device_info *devinfo,
38 uint32_t fb_width, uint32_t fb_height,
39 float m00, float m11, float m30, float m31,
40 float *xmin, float *xmax,
41 float *ymin, float *ymax)
42 {
43 /* According to the "Vertex X,Y Clamping and Quantization" section of the
44 * Strips and Fans documentation:
45 *
46 * "The vertex X and Y screen-space coordinates are also /clamped/ to the
47 * fixed-point "guardband" range supported by the rasterization hardware"
48 *
49 * and
50 *
51 * "In almost all circumstances, if an object’s vertices are actually
52 * modified by this clamping (i.e., had X or Y coordinates outside of
53 * the guardband extent the rendered object will not match the intended
54 * result. Therefore software should take steps to ensure that this does
55 * not happen - e.g., by clipping objects such that they do not exceed
56 * these limits after the Drawing Rectangle is applied."
57 *
58 * I believe the fundamental restriction is that the rasterizer (in
59 * the SF/WM stages) have a limit on the number of pixels that can be
60 * rasterized. We need to ensure any coordinates beyond the rasterizer
61 * limit are handled by the clipper. So effectively that limit becomes
62 * the clipper's guardband size.
63 *
64 * It goes on to say:
65 *
66 * "In addition, in order to be correctly rendered, objects must have a
67 * screenspace bounding box not exceeding 8K in the X or Y direction.
68 * This additional restriction must also be comprehended by software,
69 * i.e., enforced by use of clipping."
70 *
71 * This makes no sense. Gen7+ hardware supports 16K render targets,
72 * and you definitely need to be able to draw polygons that fill the
73 * surface. Our assumption is that the rasterizer was limited to 8K
74 * on Sandybridge, which only supports 8K surfaces, and it was actually
75 * increased to 16K on Ivybridge and later.
76 *
77 * So, limit the guardband to 16K on Gen7+ and 8K on Sandybridge.
78 */
79 const float gb_size = devinfo->gen >= 7 ? 16384.0f : 8192.0f;
80
81 if (m00 != 0 && m11 != 0) {
82 /* First, we compute the screen-space render area */
83 const float ss_ra_xmin = MIN3( 0, m30 + m00, m30 - m00);
84 const float ss_ra_xmax = MAX3( fb_width, m30 + m00, m30 - m00);
85 const float ss_ra_ymin = MIN3( 0, m31 + m11, m31 - m11);
86 const float ss_ra_ymax = MAX3(fb_height, m31 + m11, m31 - m11);
87
88 /* We want the guardband to be centered on that */
89 const float ss_gb_xmin = (ss_ra_xmin + ss_ra_xmax) / 2 - gb_size;
90 const float ss_gb_xmax = (ss_ra_xmin + ss_ra_xmax) / 2 + gb_size;
91 const float ss_gb_ymin = (ss_ra_ymin + ss_ra_ymax) / 2 - gb_size;
92 const float ss_gb_ymax = (ss_ra_ymin + ss_ra_ymax) / 2 + gb_size;
93
94 /* Now we need it in native device coordinates */
95 const float ndc_gb_xmin = (ss_gb_xmin - m30) / m00;
96 const float ndc_gb_xmax = (ss_gb_xmax - m30) / m00;
97 const float ndc_gb_ymin = (ss_gb_ymin - m31) / m11;
98 const float ndc_gb_ymax = (ss_gb_ymax - m31) / m11;
99
100 /* Thanks to Y-flipping and ORIGIN_UPPER_LEFT, the Y coordinates may be
101 * flipped upside-down. X should be fine though.
102 */
103 assert(ndc_gb_xmin <= ndc_gb_xmax);
104 *xmin = ndc_gb_xmin;
105 *xmax = ndc_gb_xmax;
106 *ymin = MIN2(ndc_gb_ymin, ndc_gb_ymax);
107 *ymax = MAX2(ndc_gb_ymin, ndc_gb_ymax);
108 } else {
109 /* The viewport scales to 0, so nothing will be rendered. */
110 *xmin = 0.0f;
111 *xmax = 0.0f;
112 *ymin = 0.0f;
113 *ymax = 0.0f;
114 }
115 }
116
117 static void
gen6_upload_sf_and_clip_viewports(struct brw_context * brw)118 gen6_upload_sf_and_clip_viewports(struct brw_context *brw)
119 {
120 struct gl_context *ctx = &brw->ctx;
121 const struct gen_device_info *devinfo = &brw->screen->devinfo;
122 struct gen6_sf_viewport *sfv;
123 struct brw_clipper_viewport *clv;
124 GLfloat y_scale, y_bias;
125
126 /* BRW_NEW_VIEWPORT_COUNT */
127 const unsigned viewport_count = brw->clip.viewport_count;
128
129 /* _NEW_BUFFERS */
130 struct gl_framebuffer *fb = ctx->DrawBuffer;
131 const bool render_to_fbo = _mesa_is_user_fbo(fb);
132 const uint32_t fb_width = _mesa_geometric_width(ctx->DrawBuffer);
133 const uint32_t fb_height = _mesa_geometric_height(ctx->DrawBuffer);
134
135 sfv = brw_state_batch(brw, AUB_TRACE_SF_VP_STATE,
136 sizeof(*sfv) * viewport_count,
137 32, &brw->sf.vp_offset);
138 memset(sfv, 0, sizeof(*sfv) * viewport_count);
139
140 clv = brw_state_batch(brw, AUB_TRACE_CLIP_VP_STATE,
141 sizeof(*clv) * viewport_count,
142 32, &brw->clip.vp_offset);
143
144 if (render_to_fbo) {
145 y_scale = 1.0;
146 y_bias = 0.0;
147 } else {
148 y_scale = -1.0;
149 y_bias = (float)fb_height;
150 }
151
152 for (unsigned i = 0; i < viewport_count; i++) {
153 float scale[3], translate[3];
154
155 /* _NEW_VIEWPORT */
156 _mesa_get_viewport_xform(ctx, i, scale, translate);
157 sfv[i].m00 = scale[0];
158 sfv[i].m11 = scale[1] * y_scale;
159 sfv[i].m22 = scale[2];
160 sfv[i].m30 = translate[0];
161 sfv[i].m31 = translate[1] * y_scale + y_bias;
162 sfv[i].m32 = translate[2];
163
164 brw_calculate_guardband_size(devinfo, fb_width, fb_height,
165 sfv[i].m00, sfv[i].m11,
166 sfv[i].m30, sfv[i].m31,
167 &clv[i].xmin, &clv[i].xmax,
168 &clv[i].ymin, &clv[i].ymax);
169 }
170
171 brw->ctx.NewDriverState |= BRW_NEW_SF_VP | BRW_NEW_CLIP_VP;
172 }
173
174 const struct brw_tracked_state gen6_sf_and_clip_viewports = {
175 .dirty = {
176 .mesa = _NEW_BUFFERS |
177 _NEW_VIEWPORT,
178 .brw = BRW_NEW_BATCH |
179 BRW_NEW_BLORP |
180 BRW_NEW_VIEWPORT_COUNT,
181 },
182 .emit = gen6_upload_sf_and_clip_viewports,
183 };
184
upload_viewport_state_pointers(struct brw_context * brw)185 static void upload_viewport_state_pointers(struct brw_context *brw)
186 {
187 BEGIN_BATCH(4);
188 OUT_BATCH(_3DSTATE_VIEWPORT_STATE_POINTERS << 16 | (4 - 2) |
189 GEN6_CC_VIEWPORT_MODIFY |
190 GEN6_SF_VIEWPORT_MODIFY |
191 GEN6_CLIP_VIEWPORT_MODIFY);
192 OUT_BATCH(brw->clip.vp_offset);
193 OUT_BATCH(brw->sf.vp_offset);
194 OUT_BATCH(brw->cc.vp_offset);
195 ADVANCE_BATCH();
196 }
197
198 const struct brw_tracked_state gen6_viewport_state = {
199 .dirty = {
200 .mesa = 0,
201 .brw = BRW_NEW_BATCH |
202 BRW_NEW_BLORP |
203 BRW_NEW_CC_VP |
204 BRW_NEW_CLIP_VP |
205 BRW_NEW_SF_VP |
206 BRW_NEW_STATE_BASE_ADDRESS,
207 },
208 .emit = upload_viewport_state_pointers,
209 };
210